diff --git a/src/topupopt/problems/__init__.py b/src/topupopt/problems/__init__.py
index 80cf2ba9bd7b049c85c1ff82e75ab35967c5e803..7c68785e9d0b64e1fe46403c4316a9fe1ea36eeb 100644
--- a/src/topupopt/problems/__init__.py
+++ b/src/topupopt/problems/__init__.py
@@ -1,2 +1 @@
-# -*- coding: utf-8 -*-
-# from . import mvesipp
+# -*- coding: utf-8 -*-
\ No newline at end of file
diff --git a/src/topupopt/problems/esipp/blocks/__init__.py b/src/topupopt/problems/esipp/blocks/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..7c68785e9d0b64e1fe46403c4316a9fe1ea36eeb
--- /dev/null
+++ b/src/topupopt/problems/esipp/blocks/__init__.py
@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-
\ No newline at end of file
diff --git a/src/topupopt/problems/esipp/blocks/delta.py b/src/topupopt/problems/esipp/blocks/delta.py
new file mode 100644
index 0000000000000000000000000000000000000000..2cdc79bff68a727a725a8c8db28b3caacdf246d2
--- /dev/null
+++ b/src/topupopt/problems/esipp/blocks/delta.py
@@ -0,0 +1,413 @@
+# imports
+
+import pyomo.environ as pyo
+
+# *****************************************************************************
+# *****************************************************************************
+
+def price_delta_block(
+ model: pyo.AbstractModel,
+ enable_default_values: bool = True,
+ enable_validation: bool = True,
+ enable_initialisation: bool = True
+ ):
+
+ # auxiliary set for pyomo
+ model.set_GLQPK = model.set_GL_exp_imp*model.set_QPK
+
+ # create a block for a transshipment node during a given time interval
+ def rule_block_prices(b, g, l, q, p, k):
+
+ # *********************************************************************
+ # *********************************************************************
+
+ # sets
+
+ # set of price segments
+ b.set_S = pyo.Set()
+
+ # *********************************************************************
+ # *********************************************************************
+
+ # parameters
+
+ # resource prices
+ b.param_p_s = pyo.Param(b.set_S, within=pyo.NonNegativeReals)
+
+ # price function convexity
+ b.param_price_function_is_convex = pyo.Param(within=pyo.Boolean)
+
+ # maximum resource volumes for each prices
+ b.param_v_max_s = pyo.Param(b.set_S, within=pyo.NonNegativeReals)
+
+ # *********************************************************************
+ # *********************************************************************
+
+ # variables
+
+ # *********************************************************************
+ # *********************************************************************
+
+ # TODO: consider replacing None in the bounds with inf in the parameter
+
+ # import and export flows
+ def bounds_var_trans_flows(b):
+ try:
+ return (0, sum(b.param_v_max_s[s] for s in b.set_S))
+ except Exception:
+ return (0, None)
+ b.var_trans_flows = pyo.Var(
+ # within=pyo.NonNegativeReals,
+ bounds=bounds_var_trans_flows
+ )
+
+ # segment usage variables
+ b.var_segment_usage_s = pyo.Var(
+ b.set_S,
+ within=pyo.UnitInterval,
+ )
+
+ # *********************************************************************
+ # *********************************************************************
+
+ # import flow costs and export flow revenues (y function)
+ def rule_constr_trans_monetary_flows(b):
+ if (g,l) in b.parent_block().set_GL_imp:
+ return (
+ sum(
+ b.var_segment_usage_s[s]*b.param_p_s[s]*b.param_v_max_s[s]
+ for s in b.set_S
+ )
+ == b.parent_block().var_ifc_glqpk[(g,l,q,p,k)]
+ )
+ else:
+ return (
+ sum(
+ b.var_segment_usage_s[s]*b.param_p_s[s]*b.param_v_max_s[s]
+ for s in b.set_S
+ )
+ == b.parent_block().var_efr_glqpk[(g,l,q,p,k)]
+ )
+ b.constr_trans_monetary_flows = pyo.Constraint(
+ rule=rule_constr_trans_monetary_flows
+ )
+
+ # imported and exported flows (x function)
+ def rule_constr_trans_flows_seg(b):
+ return sum(
+ b.var_segment_usage_s[s]*b.param_v_max_s[s]
+ for s in b.set_S
+ ) == b.var_trans_flows
+ b.constr_trans_flows_seg = pyo.Constraint(rule=rule_constr_trans_flows_seg)
+
+ # imported and exported flows: energy system defines the x value
+ def rule_constr_trans_flows_sys(b):
+ if (g,l) in b.parent_block().set_GL_imp:
+ return sum(
+ b.parent_block().var_v_glljqk[(g,l,l_star,j,q,k)]
+ for l_star in b.parent_block().set_L[g]
+ if l_star not in b.parent_block().set_L_imp[g]
+ for j in b.parent_block().set_J[(g,l,l_star)] # only directed arcs
+ ) == b.var_trans_flows
+ else:
+ return sum(
+ b.parent_block().var_v_glljqk[(g,l_star,l,j,q,k)]
+ * b.parent_block().param_eta_glljqk[(g,l_star,l,j,q,k)]
+ for l_star in b.parent_block().set_L[g]
+ if l_star not in b.parent_block().set_L_exp[g]
+ for j in b.parent_block().set_J[(g,l_star,l)] # only directed arcs
+ ) == b.var_trans_flows
+ b.constr_trans_flows_sys = pyo.Constraint(rule=rule_constr_trans_flows_sys)
+
+ # *********************************************************************
+ # *********************************************************************
+
+ # non-convex price functions
+ if not b.param_price_function_is_convex:
+ # this means the segment usage variables are binary
+
+ # variables to indicate if the segments are active
+ b.var_segment_is_full = pyo.Var(
+ b.set_S,
+ within=pyo.Binary
+ )
+
+ # if next level is active, bin. var. for current level must be one
+ # if bin. var. for current level is one, segment must be used fully
+ # if previous level is not full, bin. var for current level must be zero
+ # if bin. var. for current level is zero,
+ def rule_constr_nonconvex_p1(b, s):
+ if s == len(b.set_S)-1:
+ # last segment, skip
+ return pyo.Constraint.Skip
+ return (
+ b.var_segment_usage_s[s+1] <=
+ b.var_segment_is_full[s]
+ )
+ b.constr_nonconvex_p1 = pyo.Constraint(
+ b.set_S, rule=rule_constr_nonconvex_p1
+ )
+
+ def rule_constr_nonconvex_p2(b, s):
+ if s == len(b.set_S)-1:
+ # last segment, skip
+ return pyo.Constraint.Skip
+ return (
+ b.var_segment_usage_s[s] >=
+ b.var_segment_is_full[s]
+ )
+ b.constr_nonconvex_p2 = pyo.Constraint(
+ b.set_S, rule=rule_constr_nonconvex_p2
+ )
+
+ def rule_constr_nonconvex_p3(b, s):
+ if s == len(b.set_S)-1:
+ # last segment, skip
+ return pyo.Constraint.Skip
+ return (
+ b.var_segment_usage_s[s] >=
+ b.var_segment_is_full[s+1]
+ )
+ b.constr_nonconvex_p3 = pyo.Constraint(
+ b.set_S, rule=rule_constr_nonconvex_p3
+ )
+
+ def rule_constr_nonconvex_p4(b, s):
+ if s == len(b.set_S)-1:
+ # last segment, skip
+ return pyo.Constraint.Skip
+ return (
+ b.var_segment_usage_s[s+1] <=
+ b.var_segment_is_full[s+1]
+ )
+ b.constr_nonconvex_p4 = pyo.Constraint(
+ b.set_S, rule=rule_constr_nonconvex_p4
+ )
+
+
+ # *********************************************************************
+ # *********************************************************************
+
+ model.block_prices = pyo.Block(model.set_GLQPK, rule=rule_block_prices)
+
+ # *************************************************************************
+ # *************************************************************************
+
+# *****************************************************************************
+# *****************************************************************************
+# *****************************************************************************
+# *****************************************************************************
+# *****************************************************************************
+# *****************************************************************************
+# *****************************************************************************
+# *****************************************************************************
+# *****************************************************************************
+# *****************************************************************************
+# *****************************************************************************
+# *****************************************************************************
+
+def price_delta_no_block(
+ model: pyo.AbstractModel,
+ # convex_price_function: bool = True,
+ enable_default_values: bool = True,
+ enable_validation: bool = True,
+ enable_initialisation: bool = True
+ ):
+
+ # auxiliary set for pyomo
+ model.set_GLQPK = model.set_GL_exp_imp*model.set_QPK
+
+ # set of price segments
+ model.set_S = pyo.Set(model.set_GLQPK)
+
+ # set of GLQKS tuples
+ def init_set_GLQPKS(m):
+ return (
+ (g, l, q, p, k, s)
+ # for (g,l) in m.set_GL_exp_imp
+ # for (q,k) in m.set_QK
+ for (g, l, q, p, k) in m.set_S
+ for s in m.set_S[(g, l, q, p, k)]
+ )
+
+ model.set_GLQPKS = pyo.Set(
+ dimen=6, initialize=(init_set_GLQPKS if enable_initialisation else None)
+ )
+
+ # *************************************************************************
+ # *************************************************************************
+
+ # parameters
+
+ # resource prices
+
+ model.param_p_glqpks = pyo.Param(model.set_GLQPKS, within=pyo.NonNegativeReals)
+
+ # price function convexity
+
+ model.param_price_function_is_convex = pyo.Param(
+ model.set_GLQPK,
+ within=pyo.Boolean
+ )
+
+ # maximum resource volumes for each prices
+
+ model.param_v_max_glqpks = pyo.Param(
+ model.set_GLQPKS,
+ within=pyo.NonNegativeReals,
+ # default=math.inf
+ )
+
+ # *************************************************************************
+ # *************************************************************************
+
+ # variables
+
+ # *************************************************************************
+ # *************************************************************************
+
+ # import and export flows
+ def bounds_var_trans_flows_glqpk(m, g, l, q, p, k):
+ try:
+ return (0, sum(m.param_v_max_glqpks[s] for s in m.set_S[(g, l, q, p, k)]))
+ except Exception:
+ return (0, None)
+ model.var_trans_flows_glqpk = pyo.Var(
+ model.set_GLQPK, within=pyo.NonNegativeReals, bounds=bounds_var_trans_flows_glqpk
+ )
+
+ # segment usage variables
+ model.var_segment_usage_glqpks = pyo.Var(
+ model.set_GLQPKS,
+ within=pyo.UnitInterval,
+ )
+
+ # *************************************************************************
+ # *************************************************************************
+
+
+ # import flow costs and export flow revenues (y function)
+ def rule_constr_trans_monetary_flows(m, g, l, q, p, k):
+ if (g,l) in m.set_GL_imp:
+ return (
+ sum(
+ m.var_segment_usage_glqpks[(g, l, q, p, k, s)]*
+ m.param_p_glqpks[(g, l, q, p, k, s)]*
+ m.param_v_max_glqpks[(g, l, q, p, k, s)]
+ for s in m.set_S[(g, l, q, p, k)]
+ )
+ == m.var_ifc_glqpk[(g,l,q,p,k)]
+ )
+ else:
+ return (
+ sum(
+ m.var_segment_usage_glqpks[(g, l, q, p, k, s)]*
+ m.param_p_glqpks[(g, l, q, p, k, s)]*
+ m.param_v_max_glqpks[(g, l, q, p, k, s)]
+ for s in m.set_S[(g, l, q, p, k)]
+ )
+ == m.var_efr_glqpk[(g,l,q,p,k)]
+ )
+ model.constr_trans_monetary_flows = pyo.Constraint(
+ model.set_GLQPK,
+ rule=rule_constr_trans_monetary_flows
+ )
+
+ # imported and exported flows (x function)
+ def rule_constr_trans_flows_seg(m, g, l, q, p, k):
+ return sum(
+ m.var_segment_usage_glqpks[(g, l, q, p, k, s)]*m.param_v_max_glqpks[(g, l, q, p, k, s)]
+ for s in m.set_S[(g, l, q, p, k)]
+ ) == m.var_trans_flows_glqpk[(g, l, q, p, k)]
+ model.constr_trans_flows_seg = pyo.Constraint(
+ model.set_GLQPK,
+ rule=rule_constr_trans_flows_seg
+ )
+
+ # imported and exported flows: energy system defines the x value
+ def rule_constr_trans_flows_sys(m, g, l, q, p, k):
+ if (g,l) in m.set_GL_imp:
+ return sum(
+ m.var_v_glljqk[(g,l,l_star,j,q,k)]
+ for l_star in m.set_L[g]
+ if l_star not in m.set_L_imp[g]
+ for j in m.set_J[(g,l,l_star)] # only directed arcs
+ ) == m.var_trans_flows_glqpk[(g, l, q, p, k)]
+ else:
+ return sum(
+ m.var_v_glljqk[(g,l_star,l,j,q,k)]
+ * m.param_eta_glljqk[(g,l_star,l,j,q,k)]
+ for l_star in m.set_L[g]
+ if l_star not in m.set_L_exp[g]
+ for j in m.set_J[(g,l_star,l)] # only directed arcs
+ ) == m.var_trans_flows_glqpk[(g, l, q, p, k)]
+ model.constr_trans_flows_sys = pyo.Constraint(
+ model.set_GLQPK,
+ rule=rule_constr_trans_flows_sys
+ )
+
+ # *************************************************************************
+ # *************************************************************************
+
+ # non-convex price functions
+
+ # variables to indicate if the segments are active
+ model.var_segment_is_full = pyo.Var(
+ model.set_GLQPKS,
+ within=pyo.Binary
+ )
+
+ # if next level is active, bin. var. for current level must be one
+ # if bin. var. for current level is one, segment must be used fully
+ # if previous level is not full, bin. var for current level must be zero
+ # if bin. var. for current level is zero,
+ def rule_constr_nonconvex_p1(m, g, l, q, p, k, s):
+ if s == len(m.set_S[(g, l, q, p, k)])-1:
+ # last segment, skip
+ return pyo.Constraint.Skip
+ return (
+ m.var_segment_usage_glqpks[(g,l,q,p,k,s+1)] <=
+ m.var_segment_is_full[(g,l,q,p,k,s)]
+ )
+ model.constr_nonconvex_p1 = pyo.Constraint(
+ model.set_GLQPKS, rule=rule_constr_nonconvex_p1
+ )
+
+ def rule_constr_nonconvex_p2(m, g, l, q, p, k, s):
+ if s == len(m.set_S[(g, l, q, p, k)])-1:
+ # last segment, skip
+ return pyo.Constraint.Skip
+ return (
+ m.var_segment_usage_glqpks[(g,l,q,p,k,s)] >=
+ m.var_segment_is_full[(g,l,q,p,k,s)]
+ )
+ model.constr_nonconvex_p2 = pyo.Constraint(
+ model.set_GLQPKS, rule=rule_constr_nonconvex_p2
+ )
+
+ def rule_constr_nonconvex_p3(m, g, l, q, p, k, s):
+ if s == len(m.set_S[(g, l, q, p, k)])-1:
+ # last segment, skip
+ return pyo.Constraint.Skip
+ return (
+ m.var_segment_usage_glqpks[(g,l,q,p,k,s)] >=
+ m.var_segment_is_full[(g,l,q,p,k,s+1)]
+ )
+ model.constr_nonconvex_p3 = pyo.Constraint(
+ model.set_GLQPKS, rule=rule_constr_nonconvex_p3
+ )
+
+ def rule_constr_nonconvex_p4(m, g, l, q, p, k, s):
+ if s == len(m.set_S[(g, l, q, p, k)])-1:
+ # last segment, skip
+ return pyo.Constraint.Skip
+ return (
+ m.var_segment_usage_glqpks[(g,l,q,p,k,s+1)] <=
+ m.var_segment_is_full[(g,l,q,p,k,s+1)]
+ )
+ model.constr_nonconvex_p4 = pyo.Constraint(
+ model.set_GLQPKS, rule=rule_constr_nonconvex_p4
+ )
+
+# *****************************************************************************
+# *****************************************************************************
\ No newline at end of file
diff --git a/src/topupopt/problems/esipp/blocks/lambda_.py b/src/topupopt/problems/esipp/blocks/lambda_.py
new file mode 100644
index 0000000000000000000000000000000000000000..4a2d7223328d519f038aaddf4765eee2fc109cb6
--- /dev/null
+++ b/src/topupopt/problems/esipp/blocks/lambda_.py
@@ -0,0 +1,393 @@
+# imports
+
+import pyomo.environ as pyo
+
+# *****************************************************************************
+# *****************************************************************************
+
+def price_lambda_block(
+ model: pyo.AbstractModel,
+ enable_default_values: bool = True,
+ enable_validation: bool = True,
+ enable_initialisation: bool = True
+ ):
+
+ # auxiliary set for pyomo
+ model.set_GLQPK = model.set_GL_exp_imp*model.set_QPK
+
+ # create a block for a transshipment node during a given time interval
+ def rule_block_prices(b, g, l, q, p, k):
+
+ # *********************************************************************
+ # *********************************************************************
+
+ # sets
+
+ # set of price segments
+ b.set_S = pyo.Set()
+
+ # *********************************************************************
+ # *********************************************************************
+
+ # parameters
+
+ # resource prices
+ b.param_p_s = pyo.Param(b.set_S, within=pyo.NonNegativeReals)
+
+ # price function convexity
+ b.param_price_function_is_convex = pyo.Param(within=pyo.Boolean)
+
+ # maximum resource volumes for each prices
+ b.param_v_max_s = pyo.Param(b.set_S, within=pyo.NonNegativeReals)
+
+ # *********************************************************************
+ # *********************************************************************
+
+ # variables
+
+ # *********************************************************************
+ # *********************************************************************
+
+ # set of points
+ b.set_O = pyo.Set(initialize=[i for i in range(len(b.set_S)+1)])
+
+ # set of x points
+ def init_param_x_o(b, o):
+ return 0 if o == 0 else sum(b.param_v_max_s[i] for i in range(o))
+ b.param_x_o = pyo.Param(
+ b.set_O,
+ within=pyo.NonNegativeReals,
+ initialize=init_param_x_o
+ )
+
+ # set of y points
+ def init_param_y_o(b, o):
+ return 0 if o == 0 else (b.param_x_o[o]-b.param_x_o[o-1])*b.param_p_s[o-1]+b.param_y_o[o-1]
+ # sum(b.param_p_s[i] for i in range(p+1))
+ b.param_y_o = pyo.Param(
+ b.set_O,
+ within=pyo.NonNegativeReals,
+ initialize=init_param_y_o
+ )
+
+ # interpoint weights
+ b.var_weights_o = pyo.Var(b.set_O, within=pyo.UnitInterval)
+
+ # TODO: consider replacing None in the bounds with inf in the parameter
+
+ # transshipment flows
+ def bounds_var_trans_flows(b):
+ try:
+ return (0, sum(b.param_v_max_s[s] for s in b.set_S))
+ except Exception:
+ return (0, None)
+ b.var_trans_flows = pyo.Var(bounds=bounds_var_trans_flows)
+
+ # *********************************************************************
+ # *********************************************************************
+
+ def rule_constr_stick_to_line(b):
+ return sum(b.var_weights_o[p] for p in b.set_O) == 1
+ b.constr_stick_to_line = pyo.Constraint(rule=rule_constr_stick_to_line)
+
+ # *********************************************************************
+ # *********************************************************************
+
+ # import flow costs and export flow revenues (y equation)
+ def rule_constr_y_equation(b):
+ if (g,l) in b.parent_block().set_GL_imp:
+ return (
+ sum(b.var_weights_o[p]*b.param_y_o[p] for p in b.set_O)
+ == b.parent_block().var_ifc_glqpk[(g,l,q,p,k)]
+ )
+ else:
+ return (
+ sum(b.var_weights_o[p]*b.param_y_o[p] for p in b.set_O)
+ == b.parent_block().var_efr_glqpk[(g,l,q,p,k)]
+ )
+ b.constr_y_equation = pyo.Constraint(rule=rule_constr_y_equation)
+
+ # imported and exported flows (x equation)
+ def rule_constr_x_equation(b):
+ if (g,l) in b.parent_block().set_GL_imp:
+ return (
+ sum(b.var_weights_o[p]*b.param_x_o[p] for p in b.set_O)
+ == b.var_trans_flows
+ )
+ else:
+ return (
+ sum(b.var_weights_o[p]*b.param_x_o[p] for p in b.set_O)
+ == b.var_trans_flows
+ )
+ b.constr_x_equation = pyo.Constraint(rule=rule_constr_x_equation)
+
+ # imported and exported flows (system equation)
+ def rule_constr_sys_equation(b):
+ if (g,l) in b.parent_block().set_GL_imp:
+ return sum(
+ b.parent_block().var_v_glljqk[(g,l,l_star,j,q,k)]
+ for l_star in b.parent_block().set_L[g]
+ if l_star not in b.parent_block().set_L_imp[g]
+ for j in b.parent_block().set_J[(g,l,l_star)] # only directed arcs
+ ) == b.var_trans_flows
+ else:
+ return sum(
+ b.parent_block().var_v_glljqk[(g,l_star,l,j,q,k)]
+ * b.parent_block().param_eta_glljqk[(g,l_star,l,j,q,k)]
+ for l_star in b.parent_block().set_L[g]
+ if l_star not in b.parent_block().set_L_exp[g]
+ for j in b.parent_block().set_J[(g,l_star,l)] # only directed arcs
+ ) == b.var_trans_flows
+ b.constr_sys_equation = pyo.Constraint(rule=rule_constr_sys_equation)
+
+ # *********************************************************************
+ # *********************************************************************
+
+ # non-convex price functions
+ if not b.param_price_function_is_convex:
+
+ # declare SOS2
+ def rule_constr_sos2_weights(b):
+ return [b.var_weights_o[p] for p in b.set_O]
+ b.constr_sos2_weights = pyo.SOSConstraint(rule=rule_constr_sos2_weights, sos=2)
+
+ # *********************************************************************
+ # *********************************************************************
+
+ model.block_prices = pyo.Block(model.set_GLQPK, rule=rule_block_prices)
+
+ # *************************************************************************
+ # *************************************************************************
+
+# *****************************************************************************
+# *****************************************************************************
+# *****************************************************************************
+# *****************************************************************************
+# *****************************************************************************
+# *****************************************************************************
+# *****************************************************************************
+# *****************************************************************************
+# *****************************************************************************
+# *****************************************************************************
+# *****************************************************************************
+# *****************************************************************************
+
+def price_lambda_no_block(
+ model: pyo.AbstractModel,
+ # convex_price_function: bool = True,
+ enable_default_values: bool = True,
+ enable_validation: bool = True,
+ enable_initialisation: bool = True
+ ):
+
+ # auxiliary set for pyomo
+ model.set_GLQPK = model.set_GL_exp_imp*model.set_QPK
+
+ # set of price segments
+ model.set_S = pyo.Set(model.set_GLQPK)
+
+ # set of GLQKS tuples
+ def init_set_GLQPKS(m):
+ return (
+ (g, l, q, p, k, s)
+ # for (g,l) in m.set_GL_exp_imp
+ # for (q,k) in m.set_QK
+ for (g, l, q, p, k) in m.set_S
+ for s in m.set_S[(g, l, q, p, k)]
+ )
+
+ model.set_GLQPKS = pyo.Set(
+ dimen=6, initialize=(init_set_GLQPKS if enable_initialisation else None)
+ )
+
+ # *************************************************************************
+ # *************************************************************************
+
+ # parameters
+
+ # resource prices
+ model.param_p_glqpks = pyo.Param(model.set_GLQPKS, within=pyo.NonNegativeReals)
+
+ # price function convexity
+ model.param_price_function_is_convex = pyo.Param(
+ model.set_GLQPK,
+ within=pyo.Boolean
+ )
+
+ # maximum resource volumes for each prices
+ model.param_v_max_glqpks = pyo.Param(
+ model.set_GLQPKS,
+ within=pyo.NonNegativeReals,
+ # default=math.inf
+ )
+
+ # *************************************************************************
+ # *************************************************************************
+
+ # variables
+
+ # *************************************************************************
+ # *************************************************************************
+
+ # set of points
+ def init_set_O(m, g, l, q, p, k):
+ return [i for i in range(len(m.set_S[(g,l,q,p,k)])+1)]
+ # return 0 if o == 0 else sum(m.param_v_max_glqpks[i] for i in range(o))
+ model.set_O = pyo.Set(
+ model.set_GLQPK,
+ initialize=(init_set_O if enable_initialisation else None)
+ )
+
+
+ # set of GLQKS tuples
+ def init_set_GLQPKO(m):
+ return (
+ (g, l, q, p, k, o)
+ # for (g,l) in m.set_GL_exp_imp
+ # for (q,k) in m.set_QK
+ for (g, l, q, p, k) in m.set_O
+ for o in m.set_O[(g, l, q, p, k)]
+ )
+ model.set_GLQPKO = pyo.Set(
+ dimen=6, initialize=(init_set_GLQPKO if enable_initialisation else None)
+ )
+
+ # set of x points
+ def init_param_x_glqpko(m, g, l, q, p, k, o):
+ return 0 if o == 0 else sum(m.param_v_max_glqpks[(g,l,q,p,k,i)] for i in range(o))
+ model.param_x_glqpko = pyo.Param(
+ model.set_GLQPKO,
+ within=pyo.NonNegativeReals,
+ initialize=init_param_x_glqpko
+ )
+
+ # set of y points
+ def init_param_y_glqpko(m, g, l, q, p, k, o):
+ return (
+ 0
+ if o == 0 else
+ (m.param_x_glqpko[(g,l,q,p,k,o)]
+ -m.param_x_glqpko[(g,l,q,p,k,o-1)])*
+ m.param_p_glqpks[(g,l,q,p,k,o-1)]+
+ m.param_y_glqpko[(g,l,q,p,k,o-1)]
+ )
+ model.param_y_glqpko = pyo.Param(
+ model.set_GLQPKO,
+ within=pyo.NonNegativeReals,
+ initialize=init_param_y_glqpko
+ )
+
+ # interpoint weights
+ model.var_weights_glqpko = pyo.Var(
+ model.set_GLQPKO,
+ within=pyo.UnitInterval
+ )
+
+ # TODO: consider replacing None in the bounds with inf in the parameter
+
+ # transshipment flows
+ def bounds_var_trans_flows_glqpk(m, g, l, q, p, k):
+ try:
+ return (0, sum(m.param_v_max_glqpks[(g, l, q, p, k, s)]
+ for s in m.set_S[(g, l, q, p, k)]))
+ except Exception:
+ return (0, None)
+ model.var_trans_flows_glqpk = pyo.Var(
+ model.set_GLQPK,
+ bounds=bounds_var_trans_flows_glqpk
+ )
+
+ # *************************************************************************
+ # *************************************************************************
+
+ def rule_constr_stick_to_line(m, g, l, q, p, k):
+ return sum(m.var_weights_glqpko[(g,l,q,p,k,o)]
+ for o in m.set_O[(g,l,q,p,k)]) == 1
+ model.constr_stick_to_line = pyo.Constraint(
+ model.set_GLQPK,
+ rule=rule_constr_stick_to_line
+ )
+
+ # *************************************************************************
+ # *************************************************************************
+
+ # import flow costs and export flow revenues (y equation)
+ def rule_constr_y_equation(m, g, l, q, p, k):
+ if (g,l) in m.set_GL_imp:
+ return (
+ sum(m.var_weights_glqpko[(g,l,q,p,k,o)]*
+ m.param_y_glqpko[(g,l,q,p,k,o)]
+ for o in m.set_O[(g,l,q,p,k)])
+ == m.var_ifc_glqpk[(g,l,q,p,k)]
+ )
+ else:
+ return (
+ sum(m.var_weights_glqpko[(g,l,q,p,k,o)]*
+ m.param_y_glqpko[(g,l,q,p,k,o)]
+ for o in m.set_O[(g,l,q,p,k)])
+ == m.var_efr_glqpk[(g,l,q,p,k)]
+ )
+ model.constr_y_equation = pyo.Constraint(
+ model.set_GLQPK,
+ rule=rule_constr_y_equation
+ )
+
+ # imported and exported flows (x equation)
+ def rule_constr_x_equation(m, g, l, q, p, k):
+ if (g,l) in m.set_GL_imp:
+ return (
+ sum(m.var_weights_glqpko[(g,l,q,p,k,o)]*m.param_x_glqpko[(g,l,q,p,k,o)] for o in m.set_O[(g,l,q,p,k)])
+ == m.var_trans_flows_glqpk[(g,l,q,p,k)]
+ )
+ else:
+ return (
+ sum(m.var_weights_glqpko[(g,l,q,p,k,o)]*m.param_x_glqpko[(g,l,q,p,k,o)] for o in m.set_O[(g,l,q,p,k)])
+ == m.var_trans_flows_glqpk[(g,l,q,p,k)]
+ )
+ model.constr_x_equation = pyo.Constraint(
+ model.set_GLQPK,
+ rule=rule_constr_x_equation
+ )
+
+ # imported and exported flows (system equation)
+ def rule_constr_sys_equation(m, g, l, q, p, k):
+ if (g,l) in m.set_GL_imp:
+ return sum(
+ m.var_v_glljqk[(g,l,l_star,j,q,k)]
+ for l_star in m.set_L[g]
+ if l_star not in m.set_L_imp[g]
+ for j in m.set_J[(g,l,l_star)] # only directed arcs
+ ) == m.var_trans_flows_glqpk[(g,l,q,p,k)]
+ else:
+ return sum(
+ m.var_v_glljqk[(g,l_star,l,j,q,k)]
+ * m.param_eta_glljqk[(g,l_star,l,j,q,k)]
+ for l_star in m.set_L[g]
+ if l_star not in m.set_L_exp[g]
+ for j in m.set_J[(g,l_star,l)] # only directed arcs
+ ) == m.var_trans_flows_glqpk[(g,l,q,p,k)]
+ model.constr_sys_equation = pyo.Constraint(
+ model.set_GLQPK,
+ rule=rule_constr_sys_equation
+ )
+
+ # *************************************************************************
+ # *************************************************************************
+
+ # non-convex price functions
+
+ # declare SOS2
+ def rule_constr_sos2_weights(m, g, l, q, p, k):
+ if m.param_price_function_is_convex[(g,l,q,p,k)]:
+ return pyo.SOSConstraint.Skip
+ return [m.var_weights_glqpko[(g,l,q,p,k,o)] for o in m.set_O[(g,l,q,p,k)]]
+ model.constr_sos2_weights = pyo.SOSConstraint(
+ model.set_GLQPK,
+ rule=rule_constr_sos2_weights,
+ sos=2)
+
+ # *************************************************************************
+ # *************************************************************************
+
+# *****************************************************************************
+# *****************************************************************************
\ No newline at end of file
diff --git a/src/topupopt/problems/esipp/blocks/other.py b/src/topupopt/problems/esipp/blocks/other.py
new file mode 100644
index 0000000000000000000000000000000000000000..ac4718040d3e7f90512278bba604a7f8c9586064
--- /dev/null
+++ b/src/topupopt/problems/esipp/blocks/other.py
@@ -0,0 +1,378 @@
+# imports
+
+import pyomo.environ as pyo
+
+# *****************************************************************************
+# *****************************************************************************
+
+# description: variation of the delta formulation
+
+# *****************************************************************************
+# *****************************************************************************
+
+def price_other_block(
+ model: pyo.AbstractModel,
+ enable_default_values: bool = True,
+ enable_validation: bool = True,
+ enable_initialisation: bool = True
+ ):
+
+ # auxiliary set for pyomo
+ model.set_GLQPK = model.set_GL_exp_imp*model.set_QPK
+
+ # create a block for a transshipment node during a given time interval
+ def rule_block_prices(b, g, l, q, p, k):
+
+ # *********************************************************************
+ # *********************************************************************
+
+ # sets
+
+ # set of price segments
+ b.set_S = pyo.Set()
+
+ # TODO: introduce a set of price segments for non-convex tariffs
+ # def init_set_S_nonconvex(b, s):
+ # return (s for s in b.set_S if b.param_price_function_is_convex)
+ # b.set_S_nonconvex = pyo.Set(within=b.set_S, initialize=init_set_S_nonconvex)
+
+ # *********************************************************************
+ # *********************************************************************
+
+ # parameters
+
+ # resource prices
+ b.param_p_s = pyo.Param(b.set_S, within=pyo.NonNegativeReals)
+
+ # price function convexity
+ b.param_price_function_is_convex = pyo.Param(within=pyo.Boolean)
+
+ # maximum resource volumes for each prices
+ b.param_v_max_s = pyo.Param(b.set_S, within=pyo.NonNegativeReals)
+
+ # *********************************************************************
+ # *********************************************************************
+
+ # variables
+
+ # *********************************************************************
+ # *********************************************************************
+
+ # TODO: consider replacing None in the bounds with inf in the parameter
+
+ # import and export flows
+ def bounds_var_trans_flows_s(b, s):
+ if s in b.param_v_max_s:
+ # predefined finite capacity
+ return (0, b.param_v_max_s[s])
+ else:
+ # infinite capacity
+ return (0, None)
+ b.var_trans_flows_s = pyo.Var(
+ b.set_S,
+ within=pyo.NonNegativeReals,
+ bounds=bounds_var_trans_flows_s
+ )
+
+ # *********************************************************************
+ # *********************************************************************
+
+ # import flow costs and export flow revenues
+ def rule_constr_trans_monetary_flows(b):
+ if (g,l) in b.parent_block().set_GL_imp:
+ return (
+ sum(b.var_trans_flows_s[s]*b.param_p_s[s]
+ for s in b.set_S)
+ == b.parent_block().var_ifc_glqpk[(g,l,q,p,k)]
+ )
+ else:
+ return (
+ sum(b.var_trans_flows_s[s]*b.param_p_s[s]
+ for s in b.set_S)
+ == b.parent_block().var_efr_glqpk[(g,l,q,p,k)]
+ )
+ b.constr_trans_monetary_flows = pyo.Constraint(
+ rule=rule_constr_trans_monetary_flows
+ )
+
+ # imported and exported flows
+ def rule_constr_trans_flows(b):
+ if (g,l) in b.parent_block().set_GL_imp:
+ return sum(
+ b.parent_block().var_v_glljqk[(g,l,l_star,j,q,k)]
+ for l_star in b.parent_block().set_L[g]
+ if l_star not in b.parent_block().set_L_imp[g]
+ for j in b.parent_block().set_J[(g,l,l_star)] # only directed arcs
+ ) == sum(b.var_trans_flows_s[s] for s in b.set_S)
+ else:
+ return sum(
+ b.parent_block().var_v_glljqk[(g,l_star,l,j,q,k)]
+ * b.parent_block().param_eta_glljqk[(g,l_star,l,j,q,k)]
+ for l_star in b.parent_block().set_L[g]
+ if l_star not in b.parent_block().set_L_exp[g]
+ for j in b.parent_block().set_J[(g,l_star,l)] # only directed arcs
+ ) == sum(b.var_trans_flows_s[s] for s in b.set_S)
+ b.constr_trans_flows = pyo.Constraint(rule=rule_constr_trans_flows)
+
+ # *********************************************************************
+ # *********************************************************************
+
+ # non-convex price functions
+ if not b.param_price_function_is_convex:
+
+ # delta variables
+ b.var_active_segment_s = pyo.Var(b.set_S, within=pyo.Binary)
+
+ # segments must be empty if the respective delta variable is zero
+ def rule_constr_empty_segment_if_delta_zero(b, s):
+ if len(b.set_S) == 1 or b.param_price_function_is_convex:
+ # single segment, skip
+ # convex, skip
+ return pyo.Constraint.Skip
+ return (
+ b.var_trans_flows_s[s] <=
+ b.param_v_max_s[s]*b.var_active_segment_s[s]
+ )
+ b.constr_empty_segment_if_delta_zero = pyo.Constraint(
+ b.set_S, rule=rule_constr_empty_segment_if_delta_zero
+ )
+
+ # if delta var is one, previous ones must be one too
+ # if delta var is zero, the next ones must also be zero
+ def rule_constr_delta_summing_logic(b, s):
+ if s == len(b.set_S)-1 or b.param_price_function_is_convex:
+ # last segment, skip
+ # convex, skip
+ return pyo.Constraint.Skip
+ return (
+ b.var_active_segment_s[s] >=
+ b.var_active_segment_s[s+1]
+ )
+ b.constr_delta_summing_logic = pyo.Constraint(
+ b.set_S, rule=rule_constr_delta_summing_logic
+ )
+
+ # if a segment is not completely used, the next ones must remain empty
+ def rule_constr_fill_up_segment_before_next(b, s):
+ if s == len(b.set_S)-1 or b.param_price_function_is_convex:
+ # last segment, skip
+ # convex, skip
+ return pyo.Constraint.Skip
+ return (
+ b.var_trans_flows_s[s] >=
+ b.var_active_segment_s[s+1]*
+ b.param_v_max_s[s]
+ )
+ b.constr_fill_up_segment_before_next = pyo.Constraint(
+ b.set_S, rule=rule_constr_fill_up_segment_before_next
+ )
+
+ # *********************************************************************
+ # *********************************************************************
+
+ model.block_prices = pyo.Block(model.set_GLQPK, rule=rule_block_prices)
+
+ # *************************************************************************
+ # *************************************************************************
+
+
+# *****************************************************************************
+# *****************************************************************************
+# *****************************************************************************
+# *****************************************************************************
+# *****************************************************************************
+# *****************************************************************************
+# *****************************************************************************
+# *****************************************************************************
+# *****************************************************************************
+# *****************************************************************************
+# *****************************************************************************
+# *****************************************************************************
+
+def price_other_no_block(
+ model: pyo.AbstractModel,
+ # convex_price_function: bool = True,
+ enable_default_values: bool = True,
+ enable_validation: bool = True,
+ enable_initialisation: bool = True
+ ):
+
+ # auxiliary set for pyomo
+ model.set_GLQPK = model.set_GL_exp_imp*model.set_QPK
+
+ # set of price segments
+ model.set_S = pyo.Set(model.set_GLQPK)
+
+ # set of GLQKS tuples
+ def init_set_GLQPKS(m):
+ return (
+ (g, l, q, p, k, s)
+ # for (g,l) in m.set_GL_exp_imp
+ # for (q,k) in m.set_QK
+ for (g, l, q, p, k) in m.set_S
+ for s in m.set_S[(g, l, q, p, k)]
+ )
+
+ model.set_GLQPKS = pyo.Set(
+ dimen=6, initialize=(init_set_GLQPKS if enable_initialisation else None)
+ )
+
+ # *************************************************************************
+ # *************************************************************************
+
+ # parameters
+
+ # resource prices
+
+ model.param_p_glqpks = pyo.Param(model.set_GLQPKS, within=pyo.NonNegativeReals)
+
+ # price function convexity
+
+ model.param_price_function_is_convex = pyo.Param(
+ model.set_GLQPK,
+ within=pyo.Boolean
+ )
+
+ # maximum resource volumes for each prices
+
+ model.param_v_max_glqpks = pyo.Param(
+ model.set_GLQPKS,
+ within=pyo.NonNegativeReals,
+ # default=math.inf
+ )
+
+ # *************************************************************************
+ # *************************************************************************
+
+ # variables
+
+ # *************************************************************************
+ # *************************************************************************
+
+ # import and export flows
+ def bounds_var_trans_flows_glqpks(m, g, l, q, p, k, s):
+ # return (0, m.param_v_max_glqpks[(g, l, q, p, k, s)])
+ if (g, l, q, p, k, s) in m.param_v_max_glqpks:
+ # predefined finite capacity
+ return (0, m.param_v_max_glqpks[(g, l, q, p, k, s)])
+ else:
+ # infinite capacity
+ return (0, None)
+ model.var_trans_flows_glqpks = pyo.Var(
+ model.set_GLQPKS, within=pyo.NonNegativeReals, bounds=bounds_var_trans_flows_glqpks
+ )
+
+ # *************************************************************************
+ # *************************************************************************
+
+ # import flow costs and export flow revenues
+ def rule_constr_trans_monetary_flows(m, g, l, q, p, k):
+ if (g,l) in m.set_GL_imp:
+ return (
+ sum(
+ m.var_trans_flows_glqpks[(g, l, q, p, k, s)]
+ * m.param_p_glqpks[(g, l, q, p, k, s)]
+ for s in m.set_S[(g, l, q, p, k)]
+ )
+ == m.var_ifc_glqpk[(g, l, q, p, k)]
+ )
+ else:
+ return (
+ sum(
+ m.var_trans_flows_glqpks[(g, l, q, p, k, s)]
+ * m.param_p_glqpks[(g, l, q, p, k, s)]
+ for s in m.set_S[(g, l, q, p, k)]
+ )
+ == m.var_efr_glqpk[(g, l, q, p, k)]
+ )
+ model.constr_trans_monetary_flows = pyo.Constraint(
+ model.set_GLQPK, rule=rule_constr_trans_monetary_flows
+ )
+
+ # imported and exported flows
+ def rule_constr_trans_flows(m, g, l, q, p, k):
+ if (g,l) in m.set_GL_imp:
+ return sum(
+ m.var_v_glljqk[(g, l, l_star, j, q, k)]
+ for l_star in m.set_L[g]
+ if l_star not in m.set_L_imp[g]
+ for j in m.set_J[(g, l, l_star)] # only directed arcs
+ ) == sum(m.var_trans_flows_glqpks[(g, l, q, p, k, s)] for s in m.set_S[(g, l, q, p, k)])
+ else:
+ return sum(
+ m.var_v_glljqk[(g, l_star, l, j, q, k)]
+ * m.param_eta_glljqk[(g, l_star, l, j, q, k)]
+ for l_star in m.set_L[g]
+ if l_star not in m.set_L_exp[g]
+ for j in m.set_J[(g, l_star, l)] # only directed arcs
+ ) == sum(m.var_trans_flows_glqpks[(g, l, q, p, k, s)] for s in m.set_S[(g, l, q, p, k)])
+
+ model.constr_trans_flows = pyo.Constraint(
+ model.set_GLQPK, rule=rule_constr_trans_flows
+ )
+
+ # *************************************************************************
+ # *************************************************************************
+
+ # non-convex price functions
+ # TODO: remove these variables from the model if they are not needed
+ # delta variables
+ model.var_active_segment_glqpks = pyo.Var(
+ model.set_GLQPKS, within=pyo.Binary
+ )
+
+ # segments must be empty if the respective delta variable is zero
+ def rule_constr_empty_segment_if_delta_zero(m, g, l, q, p, k, s):
+ if len(m.set_S[(g,l,q,p,k)]) == 1 or m.param_price_function_is_convex[(g,l,q,p,k)]:
+ # single segment, skip
+ # convex, skip
+ return pyo.Constraint.Skip
+ return (
+ m.var_trans_flows_glqpks[(g,l,q,p,k,s)] <=
+ m.param_v_max_glqpks[(g,l,q,p,k,s)]*
+ m.var_active_segment_glqpks[(g,l,q,p,k,s)]
+ )
+ model.constr_empty_segment_if_delta_zero = pyo.Constraint(
+ model.set_GLQPKS, rule=rule_constr_empty_segment_if_delta_zero
+ )
+
+ # if delta var is one, previous ones must be one too
+ # if delta var is zero, the next ones must also be zero
+ def rule_constr_delta_summing_logic(m, g, l, q, p, k, s):
+ if s == len(m.set_S[(g,l,q,p,k)])-1 or m.param_price_function_is_convex[(g,l,q,p,k)]:
+ # last segment, skip
+ # convex, skip
+ return pyo.Constraint.Skip
+ return (
+ m.var_active_segment_glqpks[(g,l,q,p,k,s)] >=
+ m.var_active_segment_glqpks[(g,l,q,p,k,s+1)]
+ )
+ model.constr_delta_summing_logic = pyo.Constraint(
+ model.set_GLQPKS, rule=rule_constr_delta_summing_logic
+ )
+
+ # if a segment is not completely used, the next ones must remain empty
+ def rule_constr_fill_up_segment_before_next(m, g, l, q, p, k, s):
+ if s == len(m.set_S[(g,l,q,p,k)])-1 or m.param_price_function_is_convex[(g,l,q,p,k)]:
+ # last segment, skip
+ # convex, skip
+ return pyo.Constraint.Skip
+ return (
+ m.var_trans_flows_glqpks[(g,l,q,p,k,s)] >=
+ m.var_active_segment_glqpks[(g,l,q,p,k,s+1)]*
+ m.param_v_max_glqpks[(g,l,q,p,k,s)]
+ )
+ # return (
+ # m.var_if_glqpks[(g,l,q,p,k,s)]/m.param_v_max_glqpks[(g,l,q,p,k,s)] >=
+ # m.var_active_segment_glqpks[(g,l,q,p,k,s+1)]
+ # )
+ # return (
+ # m.param_v_max_glqpks[(g,l,q,p,k,s)]-m.var_if_glqpks[(g,l,q,p,k,s)] <=
+ # m.param_v_max_glqpks[(g,l,q,p,k,s)]*(1- m.var_active_segment_glqpks[(g,l,q,p,k,s+1)])
+ # )
+ model.constr_fill_up_segment_before_next = pyo.Constraint(
+ model.set_GLQPKS, rule=rule_constr_fill_up_segment_before_next
+ )
+
+# *****************************************************************************
+# *****************************************************************************
\ No newline at end of file
diff --git a/src/topupopt/problems/esipp/blocks/prices.py b/src/topupopt/problems/esipp/blocks/prices.py
index 8fc17ca0d1f5df77e235b10251cdd385d81422b3..4951fc78c17af35574e75bfbbf1b704c6b4f6b14 100644
--- a/src/topupopt/problems/esipp/blocks/prices.py
+++ b/src/topupopt/problems/esipp/blocks/prices.py
@@ -1,699 +1,51 @@
# imports
import pyomo.environ as pyo
-# *****************************************************************************
-# *****************************************************************************
-
-def add_prices_block(
- model: pyo.AbstractModel,
- **kwargs
-):
-
- # *************************************************************************
- # *************************************************************************
-
- # model.node_price_block = pyo.Block(model.set_QPK)
-
- price_other(model, **kwargs)
- # price_block_other(model, **kwargs)
+from .other import price_other_block, price_other_no_block
+from .delta import price_delta_block, price_delta_no_block
+from .lambda_ import price_lambda_block, price_lambda_no_block
# *****************************************************************************
# *****************************************************************************
-# TODO: try to implement it as a block
-def price_block_other(
- model: pyo.AbstractModel,
- enable_default_values: bool = True,
- enable_validation: bool = True,
- enable_initialisation: bool = True
- ):
-
- model.set_GLQPK = model.set_GL_exp_imp*model.set_QPK
-
- def rule_node_prices(b, g, l, q, p, k):
-
- # imported flow
- def bounds_var_if_glqpks(m, g, l, q, p, k, s):
- if (g, l, q, p, k, s) in m.param_v_max_glqpks:
- # predefined finite capacity
- return (0, m.param_v_max_glqpks[(g, l, q, p, k, s)])
- else:
- # infinite capacity
- return (0, None)
-
- b.var_trans_flow_s = pyo.Var(
- b.set_GLQPKS, within=pyo.NonNegativeReals, bounds=bounds_var_trans_flow_s
- )
- # imported flow cost
- def rule_constr_imp_flow_cost(m, g, l, q, p, k):
- return (
- sum(
- m.var_if_glqpks[(g, l, q, p, k, s)]
- * m.param_p_glqpks[(g, l, q, p, k, s)]
- for s in m.set_S[(g, l, q, p, k)]
- )
- == m.var_ifc_glqpk[(g, l, q, p, k)]
- )
-
- model.constr_imp_flow_cost = pyo.Constraint(
- model.set_GL_imp, model.set_QPK, rule=rule_constr_imp_flow_cost
- )
-
- # imported flows
- def rule_constr_imp_flows(m, g, l, q, p, k):
- return sum(
- m.var_v_glljqk[(g, l, l_star, j, q, k)]
- for l_star in m.set_L[g]
- if l_star not in m.set_L_imp[g]
- for j in m.set_J[(g, l, l_star)] # only directed arcs
- ) == sum(m.var_if_glqpks[(g, l, q, p, k, s)] for s in m.set_S[(g, l, q, p, k)])
-
- model.constr_imp_flows = pyo.Constraint(
- model.set_GL_imp, model.set_QPK, rule=rule_constr_imp_flows
- )
-
-
-
-
- # if (g,l) in b.parent_block().set_GL_imp:
- # # import node
-
-
-
- # pass
- # elif (g,l) in b.parent_block().set_GL_exp:
- # # export node
- # pass
- # otherwise: do nothing
-
- model.node_price_block = pyo.Block(model.set_GLQPK, rule=rule_node_prices)
-
- # set of price segments
- model.node_price_block.set_S = pyo.Set()
-
- # set of GLQKS tuples
- def init_set_GLQPKS(m):
- return (
- (g, l, q, p, k, s)
- # for (g,l) in m.set_GL_exp_imp
- # for (q,k) in m.set_QK
- for (g, l, q, p, k) in m.node_price_block.set_S
- for s in m.node_price_block.set_S[(g, l, q, p, k)]
- )
-
- model.node_price_block.set_GLQPKS = pyo.Set(
- dimen=6, initialize=(init_set_GLQPKS if enable_initialisation else None)
- )
-
- def init_set_GLQPKS_exp(m):
- return (
- glqpks for glqpks in m.set_GLQPKS if glqpks[1] in m.set_L_exp[glqpks[0]]
- )
-
- model.node_price_block.set_GLQPKS_exp = pyo.Set(
- dimen=6, initialize=(init_set_GLQPKS_exp if enable_initialisation else None)
- )
-
- def init_set_GLQPKS_imp(m):
- return (
- glqpks for glqpks in m.set_GLQPKS if glqpks[1] in m.set_L_imp[glqpks[0]]
- )
-
- model.node_price_block.set_GLQPKS_imp = pyo.Set(
- dimen=6, initialize=(init_set_GLQPKS_imp if enable_initialisation else None)
- )
-
- # *************************************************************************
- # *************************************************************************
-
- # parameters
-
- # resource prices
-
- model.param_p_glqpks = pyo.Param(model.set_GLQPKS, within=pyo.NonNegativeReals)
-
- # maximum resource volumes for each prices
-
- model.param_v_max_glqpks = pyo.Param(
- model.set_GLQPKS,
- within=pyo.NonNegativeReals
- )
- # *************************************************************************
- # *************************************************************************
-
- # variables
-
- # *************************************************************************
- # *************************************************************************
-
- # exported flow
-
- # TODO: validate the bounds by ensuring inf. cap. only exists in last segm.
-
- def bounds_var_ef_glqpks(m, g, l, q, p, k, s):
- if (g, l, q, p, k, s) in m.param_v_max_glqpks:
- # predefined finite capacity
- return (0, m.param_v_max_glqpks[(g, l, q, p, k, s)])
- else:
- # infinite capacity
- return (0, None)
-
- model.var_ef_glqpks = pyo.Var(
- model.set_GLQPKS_exp, within=pyo.NonNegativeReals, bounds=bounds_var_ef_glqpks
+NODE_PRICE_LAMBDA = 'lambda'
+NODE_PRICE_DELTA = 'delta'
+NODE_PRICE_OTHER = None
+NODE_PRICES = (
+ NODE_PRICE_LAMBDA,
+ NODE_PRICE_DELTA,
+ NODE_PRICE_OTHER
)
-
-
- # *************************************************************************
- # *************************************************************************
-
- # exported flow revenue
- def rule_constr_exp_flow_revenue(m, g, l, q, p, k):
- return (
- sum(
- m.var_ef_glqpks[(g, l, q, p, k, s)]
- * m.param_p_glqpks[(g, l, q, p, k, s)]
- for s in m.set_S[(g, l, q, p, k)]
- )
- == m.var_efr_glqpk[(g, l, q, p, k)]
- )
-
- model.constr_exp_flow_revenue = pyo.Constraint(
- model.set_GL_exp, model.set_QPK, rule=rule_constr_exp_flow_revenue
- )
-
-
-
- # exported flows
- def rule_constr_exp_flows(m, g, l, q, p, k):
- return sum(
- m.var_v_glljqk[(g, l_star, l, j, q, k)]
- * m.param_eta_glljqk[(g, l_star, l, j, q, k)]
- for l_star in m.set_L[g]
- if l_star not in m.set_L_exp[g]
- for j in m.set_J[(g, l_star, l)] # only directed arcs
- ) == sum(m.var_ef_glqpks[(g, l, q, p, k, s)] for s in m.set_S[(g, l, q, p, k)])
-
- model.constr_exp_flows = pyo.Constraint(
- model.set_GL_exp, model.set_QPK, rule=rule_constr_exp_flows
- )
- # *************************************************************************
- # *************************************************************************
-
- # # non-convex price functions
-
- # if not convex_price_function:
-
- # # delta variables
- # model.var_active_segment_glqpks = pyo.Var(
- # model.set_GLQPKS, within=pyo.Binary
- # )
-
- # # segments must be empty if the respective delta variable is zero
- # def rule_constr_empty_segment_if_delta_zero_imp(m, g, l, q, p, k, s):
- # return (
- # m.var_if_glqpks[(g,l,q,p,k,s)] <=
- # m.param_v_max_glqpks[(g,l,q,p,k,s)]*
- # m.var_active_segment_glqpks[(g,l,q,p,k,s)]
- # )
- # model.constr_empty_segment_if_delta_zero_imp = pyo.Constraint(
- # model.set_GLQPKS_imp, rule=rule_constr_empty_segment_if_delta_zero_imp
- # )
-
- # # segments must be empty if the respective delta variable is zero
- # def rule_constr_empty_segment_if_delta_zero_exp(m, g, l, q, p, k, s):
- # return (
- # m.var_ef_glqpks[(g,l,q,p,k,s)] <=
- # m.param_v_max_glqpks[(g,l,q,p,k,s)]*
- # m.var_active_segment_glqpks[(g,l,q,p,k,s)]
- # )
- # model.constr_empty_segment_if_delta_zero_exp = pyo.Constraint(
- # model.set_GLQPKS_exp, rule=rule_constr_empty_segment_if_delta_zero_exp
- # )
-
- # # if delta var is one, previous ones must be one too
- # def rule_constr_delta_summing_logic(m, g, l, q, p, k, s):
- # if s == len(m.set_S)-1:
- # return pyo.Constraint.Skip
- # return (
- # m.var_active_segment_glqpks[(g,l,q,p,k,s)] >=
- # m.var_active_segment_glqpks[(g,l,q,p,k,s+1)]
- # )
- # model.constr_delta_summing_logic = pyo.Constraint(
- # model.set_GLQPKS, rule=rule_constr_delta_summing_logic
- # )
- # # if delta var is zero, subsequent ones must also be zero
- # def rule_constr_delta_next_zeros(m, g, l, q, p, k, s):
- # if s == len(m.set_S)-1:
- # return pyo.Constraint.Skip
- # return (
- # 1-m.var_active_segment_glqpks[(g,l,q,p,k,s)] >=
- # m.var_active_segment_glqpks[(g,l,q,p,k,s+1)]
- # )
- # model.constr_delta_next_zeros = pyo.Constraint(
- # model.set_GLQPKS, rule=rule_constr_delta_next_zeros
- # )
-
- # *************************************************************************
- # *************************************************************************
-
-
-# *****************************************************************************
-# *****************************************************************************
-
-# def price_other2(
-# model: pyo.AbstractModel,
-# convex_price_function: bool = False,
-# enable_default_values: bool = True,
-# enable_validation: bool = True,
-# enable_initialisation: bool = True
-# ):
-
-# # set of price segments
-# model.set_S = pyo.Set(model.set_GL_exp_imp, model.set_QPK)
-
-# # set of GLQKS tuples
-# def init_set_GLQPKS(m):
-# return (
-# (g, l, q, p, k, s)
-# # for (g,l) in m.set_GL_exp_imp
-# # for (q,k) in m.set_QK
-# for (g, l, q, p, k) in m.set_S
-# for s in m.set_S[(g, l, q, p, k)]
-# )
-
-# model.set_GLQPKS = pyo.Set(
-# dimen=6, initialize=(init_set_GLQPKS if enable_initialisation else None)
-# )
-
-# def init_set_GLQPKS_exp(m):
-# return (
-# glqpks for glqpks in m.set_GLQPKS if glqpks[1] in m.set_L_exp[glqpks[0]]
-# )
-
-# model.set_GLQPKS_exp = pyo.Set(
-# dimen=6, initialize=(init_set_GLQPKS_exp if enable_initialisation else None)
-# )
-
-# def init_set_GLQPKS_imp(m):
-# return (
-# glqpks for glqpks in m.set_GLQPKS if glqpks[1] in m.set_L_imp[glqpks[0]]
-# )
-
-# model.set_GLQPKS_imp = pyo.Set(
-# dimen=6, initialize=(init_set_GLQPKS_imp if enable_initialisation else None)
-# )
-
-# # *************************************************************************
-# # *************************************************************************
-
-# # parameters
-
-# # resource prices
-
-# model.param_p_glqpks = pyo.Param(model.set_GLQPKS, within=pyo.NonNegativeReals)
-
-# # maximum resource volumes for each prices
-
-# model.param_v_max_glqpks = pyo.Param(
-# model.set_GLQPKS,
-# within=pyo.NonNegativeReals
-# )
-
-# # *************************************************************************
-# # *************************************************************************
-
-# # variables
-
-# # *************************************************************************
-# # *************************************************************************
-
-# # exported flow
-
-# # TODO: validate the bounds by ensuring inf. cap. only exists in last segm.
-
-# def bounds_var_ef_glqpks(m, g, l, q, p, k, s):
-# if (g, l, q, p, k, s) in m.param_v_max_glqpks:
-# # predefined finite capacity
-# return (0, m.param_v_max_glqpks[(g, l, q, p, k, s)])
-# else:
-# # infinite capacity
-# return (0, None)
-
-# model.var_ef_glqpks = pyo.Var(
-# model.set_GLQPKS_exp, within=pyo.NonNegativeReals, bounds=bounds_var_ef_glqpks
-# )
-
-# # imported flow
-
-# def bounds_var_if_glqpks(m, g, l, q, p, k, s):
-# if (g, l, q, p, k, s) in m.param_v_max_glqpks:
-# # predefined finite capacity
-# return (0, m.param_v_max_glqpks[(g, l, q, p, k, s)])
-# else:
-# # infinite capacity
-# return (0, None)
-
-# model.var_if_glqpks = pyo.Var(
-# model.set_GLQPKS_imp, within=pyo.NonNegativeReals, bounds=bounds_var_if_glqpks
-# )
-
-# # *************************************************************************
-# # *************************************************************************
-
-# # exported flow revenue
-# def rule_constr_exp_flow_revenue(m, g, l, q, p, k):
-# return (
-# sum(
-# m.var_ef_glqpks[(g, l, q, p, k, s)]
-# * m.param_p_glqpks[(g, l, q, p, k, s)]
-# for s in m.set_S[(g, l, q, p, k)]
-# )
-# == m.var_efr_glqpk[(g, l, q, p, k)]
-# )
-
-# model.constr_exp_flow_revenue = pyo.Constraint(
-# model.set_GL_exp, model.set_QPK, rule=rule_constr_exp_flow_revenue
-# )
-
-# # imported flow cost
-# def rule_constr_imp_flow_cost(m, g, l, q, p, k):
-# return (
-# sum(
-# m.var_if_glqpks[(g, l, q, p, k, s)]
-# * m.param_p_glqpks[(g, l, q, p, k, s)]
-# for s in m.set_S[(g, l, q, p, k)]
-# )
-# == m.var_ifc_glqpk[(g, l, q, p, k)]
-# )
-
-# model.constr_imp_flow_cost = pyo.Constraint(
-# model.set_GL_imp, model.set_QPK, rule=rule_constr_imp_flow_cost
-# )
-
-# # exported flows
-# def rule_constr_exp_flows(m, g, l, q, p, k):
-# return sum(
-# m.var_v_glljqk[(g, l_star, l, j, q, k)]
-# * m.param_eta_glljqk[(g, l_star, l, j, q, k)]
-# for l_star in m.set_L[g]
-# if l_star not in m.set_L_exp[g]
-# for j in m.set_J[(g, l_star, l)] # only directed arcs
-# ) == sum(m.var_ef_glqpks[(g, l, q, p, k, s)] for s in m.set_S[(g, l, q, p, k)])
-
-# model.constr_exp_flows = pyo.Constraint(
-# model.set_GL_exp, model.set_QPK, rule=rule_constr_exp_flows
-# )
-
-# # imported flows
-# def rule_constr_imp_flows(m, g, l, q, p, k):
-# return sum(
-# m.var_v_glljqk[(g, l, l_star, j, q, k)]
-# for l_star in m.set_L[g]
-# if l_star not in m.set_L_imp[g]
-# for j in m.set_J[(g, l, l_star)] # only directed arcs
-# ) == sum(m.var_if_glqpks[(g, l, q, p, k, s)] for s in m.set_S[(g, l, q, p, k)])
-
-# model.constr_imp_flows = pyo.Constraint(
-# model.set_GL_imp, model.set_QPK, rule=rule_constr_imp_flows
-# )
-
-# # *************************************************************************
-# # *************************************************************************
-
-# # non-convex price functions
-
-# if not convex_price_function:
-
-# # delta variables
-# model.var_active_segment_glqpks = pyo.Var(
-# model.set_GLQPKS, within=pyo.Binary
-# )
-
-# # segments must be empty if the respective delta variable is zero
-# def rule_constr_empty_segment_if_delta_zero_imp(m, g, l, q, p, k, s):
-# return (
-# m.var_if_glqpks[(g,l,q,p,k,s)] <=
-# m.param_v_max_glqpks[(g,l,q,p,k,s)]*
-# m.var_active_segment_glqpks[(g,l,q,p,k,s)]
-# )
-# model.constr_empty_segment_if_delta_zero_imp = pyo.Constraint(
-# model.set_GLQPKS_imp, rule=rule_constr_empty_segment_if_delta_zero_imp
-# )
-
-# # segments must be empty if the respective delta variable is zero
-# def rule_constr_empty_segment_if_delta_zero_exp(m, g, l, q, p, k, s):
-# return (
-# m.var_ef_glqpks[(g,l,q,p,k,s)] <=
-# m.param_v_max_glqpks[(g,l,q,p,k,s)]*
-# m.var_active_segment_glqpks[(g,l,q,p,k,s)]
-# )
-# model.constr_empty_segment_if_delta_zero_exp = pyo.Constraint(
-# model.set_GLQPKS_exp, rule=rule_constr_empty_segment_if_delta_zero_exp
-# )
-
-# # if delta var is one, previous ones must be one too
-# # if delta var is zero, the next ones must also be zero
-# def rule_constr_delta_summing_logic(m, g, l, q, p, k, s):
-# if s == len(m.set_S[(g,l,q,p,k)])-1:
-# # last segment, skip
-# return pyo.Constraint.Skip
-# return (
-# m.var_active_segment_glqpks[(g,l,q,p,k,s)] >=
-# m.var_active_segment_glqpks[(g,l,q,p,k,s+1)]
-# )
-# model.constr_delta_summing_logic = pyo.Constraint(
-# model.set_GLQPKS, rule=rule_constr_delta_summing_logic
-# )
-
-# # if a segment is not completely used, the next ones must remain empty
-# def rule_constr_fill_up_segment_before_next(m, g, l, q, p, k, s):
-# if s == len(m.set_S[(g,l,q,p,k)])-1:
-# # last segment, skip
-# return pyo.Constraint.Skip
-# if (g,l) in m.set_GL_imp:
-# return (
-# m.var_if_glqpks[(g,l,q,p,k,s)] >=
-# m.var_active_segment_glqpks[(g,l,q,p,k,s+1)]*
-# m.param_v_max_glqpks[(g,l,q,p,k,s)]
-# )
-# else:
-# return (
-# m.var_ef_glqpks[(g,l,q,p,k,s)] >=
-# m.var_active_segment_glqpks[(g,l,q,p,k,s+1)]*
-# m.param_v_max_glqpks[(g,l,q,p,k,s)]
-# )
-# # return (
-# # m.var_if_glqpks[(g,l,q,p,k,s)]/m.param_v_max_glqpks[(g,l,q,p,k,s)] >=
-# # m.var_active_segment_glqpks[(g,l,q,p,k,s+1)]
-# # )
-# # return (
-# # m.param_v_max_glqpks[(g,l,q,p,k,s)]-m.var_if_glqpks[(g,l,q,p,k,s)] <=
-# # m.param_v_max_glqpks[(g,l,q,p,k,s)]*(1- m.var_active_segment_glqpks[(g,l,q,p,k,s+1)])
-# # )
-# model.constr_fill_up_segment_before_next = pyo.Constraint(
-# model.set_GLQPKS, rule=rule_constr_fill_up_segment_before_next
-# )
-
-# *****************************************************************************
-# *****************************************************************************
-
-def price_other(
+def add_price_functions(
model: pyo.AbstractModel,
- convex_price_function: bool = True,
- enable_default_values: bool = True,
- enable_validation: bool = True,
- enable_initialisation: bool = True
- ):
+ use_blocks: bool = True,
+ node_price_model = NODE_PRICE_OTHER,
+ **kwargs
+):
- # auxiliary set for pyomo
- model.set_GLQPK = model.set_GL_exp_imp*model.set_QPK
-
- # set of price segments
- model.set_S = pyo.Set(model.set_GLQPK)
-
- # set of GLQKS tuples
- def init_set_GLQPKS(m):
- return (
- (g, l, q, p, k, s)
- # for (g,l) in m.set_GL_exp_imp
- # for (q,k) in m.set_QK
- for (g, l, q, p, k) in m.set_S
- for s in m.set_S[(g, l, q, p, k)]
- )
-
- model.set_GLQPKS = pyo.Set(
- dimen=6, initialize=(init_set_GLQPKS if enable_initialisation else None)
- )
-
# *************************************************************************
# *************************************************************************
-
- # parameters
-
- # resource prices
-
- model.param_p_glqpks = pyo.Param(model.set_GLQPKS, within=pyo.NonNegativeReals)
- # price function convexity
-
- model.param_price_function_is_convex = pyo.Param(
- model.set_GLQPK,
- within=pyo.Boolean
- )
-
- # maximum resource volumes for each prices
-
- model.param_v_max_glqpks = pyo.Param(
- model.set_GLQPKS,
- within=pyo.NonNegativeReals
- )
-
- # *************************************************************************
- # *************************************************************************
-
- # variables
-
- # *************************************************************************
- # *************************************************************************
-
- # import and export flows
- def bounds_var_trans_flows_glqpks(m, g, l, q, p, k, s):
- if (g, l, q, p, k, s) in m.param_v_max_glqpks:
- # predefined finite capacity
- return (0, m.param_v_max_glqpks[(g, l, q, p, k, s)])
+ if use_blocks:
+ # with blocks
+ if node_price_model == NODE_PRICE_LAMBDA:
+ price_lambda_block(model, **kwargs)
+ elif node_price_model == NODE_PRICE_DELTA:
+ price_delta_block(model, **kwargs)
else:
- # infinite capacity
- return (0, None)
- model.var_trans_flows_glqpks = pyo.Var(
- model.set_GLQPKS, within=pyo.NonNegativeReals, bounds=bounds_var_trans_flows_glqpks
- )
-
- # *************************************************************************
- # *************************************************************************
-
- # import flow costs and export flow revenues
- def rule_constr_trans_monetary_flows(m, g, l, q, p, k):
- if (g,l) in m.set_GL_imp:
- return (
- sum(
- m.var_trans_flows_glqpks[(g, l, q, p, k, s)]
- * m.param_p_glqpks[(g, l, q, p, k, s)]
- for s in m.set_S[(g, l, q, p, k)]
- )
- == m.var_ifc_glqpk[(g, l, q, p, k)]
- )
+ price_other_block(model, **kwargs)
+ else:
+ # without blocks
+ if node_price_model == NODE_PRICE_LAMBDA:
+ price_lambda_no_block(model, **kwargs)
+ elif node_price_model == NODE_PRICE_DELTA:
+ price_delta_no_block(model, **kwargs)
else:
- return (
- sum(
- m.var_trans_flows_glqpks[(g, l, q, p, k, s)]
- * m.param_p_glqpks[(g, l, q, p, k, s)]
- for s in m.set_S[(g, l, q, p, k)]
- )
- == m.var_efr_glqpk[(g, l, q, p, k)]
- )
- model.constr_trans_monetary_flows = pyo.Constraint(
- model.set_GLQPK, rule=rule_constr_trans_monetary_flows
- )
-
- # imported and exported flows
- def rule_constr_trans_flows(m, g, l, q, p, k):
- if (g,l) in m.set_GL_imp:
- return sum(
- m.var_v_glljqk[(g, l, l_star, j, q, k)]
- for l_star in m.set_L[g]
- if l_star not in m.set_L_imp[g]
- for j in m.set_J[(g, l, l_star)] # only directed arcs
- ) == sum(m.var_trans_flows_glqpks[(g, l, q, p, k, s)] for s in m.set_S[(g, l, q, p, k)])
- else:
- return sum(
- m.var_v_glljqk[(g, l_star, l, j, q, k)]
- * m.param_eta_glljqk[(g, l_star, l, j, q, k)]
- for l_star in m.set_L[g]
- if l_star not in m.set_L_exp[g]
- for j in m.set_J[(g, l_star, l)] # only directed arcs
- ) == sum(m.var_trans_flows_glqpks[(g, l, q, p, k, s)] for s in m.set_S[(g, l, q, p, k)])
-
- model.constr_trans_flows = pyo.Constraint(
- model.set_GLQPK, rule=rule_constr_trans_flows
- )
-
+ price_other_no_block(model, **kwargs)
+
# *************************************************************************
# *************************************************************************
-
- # non-convex price functions
-
- # delta variables
- model.var_active_segment_glqpks = pyo.Var(
- model.set_GLQPKS, within=pyo.Binary
- )
-
- # segments must be empty if the respective delta variable is zero
- def rule_constr_empty_segment_if_delta_zero(m, g, l, q, p, k, s):
- if len(m.set_S[(g,l,q,p,k)]) == 1 or m.param_price_function_is_convex[(g,l,q,p,k)]:
- # single segment, skip
- # convex, skip
- return pyo.Constraint.Skip
- return (
- m.var_trans_flows_glqpks[(g,l,q,p,k,s)] <=
- m.param_v_max_glqpks[(g,l,q,p,k,s)]*
- m.var_active_segment_glqpks[(g,l,q,p,k,s)]
- )
- model.constr_empty_segment_if_delta_zero = pyo.Constraint(
- model.set_GLQPKS, rule=rule_constr_empty_segment_if_delta_zero
- )
-
- # if delta var is one, previous ones must be one too
- # if delta var is zero, the next ones must also be zero
- def rule_constr_delta_summing_logic(m, g, l, q, p, k, s):
- if s == len(m.set_S[(g,l,q,p,k)])-1 or m.param_price_function_is_convex[(g,l,q,p,k)]:
- # last segment, skip
- # convex, skip
- return pyo.Constraint.Skip
- return (
- m.var_active_segment_glqpks[(g,l,q,p,k,s)] >=
- m.var_active_segment_glqpks[(g,l,q,p,k,s+1)]
- )
- model.constr_delta_summing_logic = pyo.Constraint(
- model.set_GLQPKS, rule=rule_constr_delta_summing_logic
- )
-
- # if a segment is not completely used, the next ones must remain empty
- def rule_constr_fill_up_segment_before_next(m, g, l, q, p, k, s):
- if s == len(m.set_S[(g,l,q,p,k)])-1 or m.param_price_function_is_convex[(g,l,q,p,k)]:
- # last segment, skip
- # convex, skip
- return pyo.Constraint.Skip
- return (
- m.var_trans_flows_glqpks[(g,l,q,p,k,s)] >=
- m.var_active_segment_glqpks[(g,l,q,p,k,s+1)]*
- m.param_v_max_glqpks[(g,l,q,p,k,s)]
- )
- # return (
- # m.var_if_glqpks[(g,l,q,p,k,s)]/m.param_v_max_glqpks[(g,l,q,p,k,s)] >=
- # m.var_active_segment_glqpks[(g,l,q,p,k,s+1)]
- # )
- # return (
- # m.param_v_max_glqpks[(g,l,q,p,k,s)]-m.var_if_glqpks[(g,l,q,p,k,s)] <=
- # m.param_v_max_glqpks[(g,l,q,p,k,s)]*(1- m.var_active_segment_glqpks[(g,l,q,p,k,s+1)])
- # )
- model.constr_fill_up_segment_before_next = pyo.Constraint(
- model.set_GLQPKS, rule=rule_constr_fill_up_segment_before_next
- )
-
-# *****************************************************************************
-# *****************************************************************************
-
-def price_block_lambda(model: pyo.AbstractModel, **kwargs):
-
- raise NotImplementedError
-
-# *****************************************************************************
-# *****************************************************************************
-
-def price_block_delta(model: pyo.AbstractModel, **kwargs):
-
- raise NotImplementedError
# *****************************************************************************
# *****************************************************************************
\ No newline at end of file
diff --git a/src/topupopt/problems/esipp/model.py b/src/topupopt/problems/esipp/model.py
index 62e387cbcdb247594a8f94602fb96ed87c52a242..68bb0b3f2a80207f5f06945841176f0ffd536ee5 100644
--- a/src/topupopt/problems/esipp/model.py
+++ b/src/topupopt/problems/esipp/model.py
@@ -3,7 +3,7 @@
import pyomo.environ as pyo
from .blocks.networks import add_network_restrictions
-from .blocks.prices import add_prices_block
+from .blocks.prices import add_price_functions
# *****************************************************************************
# *****************************************************************************
@@ -11,9 +11,11 @@ from .blocks.prices import add_prices_block
def create_model(
name: str,
+ use_prices_block: bool,
+ node_price_model: str,
enable_default_values: bool = True,
enable_validation: bool = True,
- enable_initialisation: bool = True,
+ enable_initialisation: bool = True
):
# TODO: test initialisation
@@ -57,33 +59,26 @@ def create_model(
# *************************************************************************
# set of assessments
-
model.set_Q = pyo.Set()
# TODO: use rangesets for time-related sets
# set of time step intervals for each assessment
-
model.set_K_q = pyo.Set(model.set_Q)
# set of representative evaluation periods for each assessment
-
model.set_P_q = pyo.Set(model.set_Q)
# set of networks
-
model.set_G = pyo.Set()
# set of nodes on each network
-
model.set_L = pyo.Set(model.set_G)
# set of importing nodes on each network
-
model.set_L_imp = pyo.Set(model.set_G, within=model.set_L)
# set of exporting nodes on each network
-
model.set_L_exp = pyo.Set(model.set_G, within=model.set_L)
# *************************************************************************
@@ -963,20 +958,6 @@ def create_model(
initialize=(init_set_GLLJH_arc_inv_sos1 if enable_initialisation else None),
)
- # set of GLLJ-indexed GLLJH tuples for new arcs modelled using SOS1
-
- def init_set_GLLJH_arc_inv_sos1_gllj(m, g, l1, l2, j):
- return ((g, l1, l2, j, h) for h in m.set_H_gllj[(g, l1, l2, j)])
-
- model.set_GLLJH_arc_inv_sos1_gllj = pyo.Set(
- model.set_GLLJ_arc_inv_sos1,
- dimen=5,
- within=model.set_GLLJH_arc_inv_sos1,
- initialize=(
- init_set_GLLJH_arc_inv_sos1_gllj if enable_initialisation else None
- ),
- )
-
# *************************************************************************
# flow sense determination using SOS1
@@ -1315,18 +1296,6 @@ def create_model(
dimen=2, within=model.set_TH, initialize=init_set_TH_arc_inv_sos1
)
- # set of t-indexed TH tuples for groups of arcs relying on SOS1
-
- def init_set_TH_arc_inv_sos1_t(m, t):
- return ((t, h) for h in m.set_H_t[t])
-
- model.set_TH_arc_inv_sos1_t = pyo.Set(
- model.set_T_sos1,
- dimen=2,
- within=model.set_TH_arc_inv_sos1,
- initialize=init_set_TH_arc_inv_sos1_t,
- )
-
# minimum cost of a group of arcs
model.param_c_arc_min_th = pyo.Param(model.set_TH, within=pyo.NonNegativeReals)
@@ -2163,7 +2132,11 @@ def create_model(
)
# prices
- add_prices_block(model)
+ add_price_functions(
+ model,
+ use_blocks=use_prices_block,
+ node_price_model=node_price_model
+ )
# *************************************************************************
# *************************************************************************
@@ -2435,14 +2408,21 @@ def create_model(
# *************************************************************************
- # SOS1 constraints for arc selection
-
+ # SOS1 constraints for arc selection
+ def rule_constr_arc_sos1(m, g, l1, l2, j):
+ var_list = [
+ m.var_delta_arc_inv_glljh[(g, l1, l2, j, h)]
+ for h in m.set_H_gllj[(g, l1, l2, j)]
+ ]
+ weight_list = [
+ m.param_arc_inv_sos1_weights_glljh[(g, l1, l2, j, h)]
+ for h in m.set_H_gllj[(g, l1, l2, j)]
+ ]
+ return (var_list, weight_list)
model.constr_arc_sos1 = pyo.SOSConstraint(
- model.set_GLLJ_arc_inv_sos1, # for (directed and undirected) new arcs
- var=model.var_delta_arc_inv_glljh, # set_GLLJH_sgl indexes the variables
- index=model.set_GLLJH_arc_inv_sos1_gllj, # key: GLLJ; value: GLLJH
- weights=model.param_arc_inv_sos1_weights_glljh, # key: GLLJH; alue: weight
- sos=1,
+ model.set_GLLJ_arc_inv_sos1,
+ rule=rule_constr_arc_sos1,
+ sos=1
)
# *************************************************************************
@@ -2572,16 +2552,29 @@ def create_model(
# *************************************************************************
# SOS1 constraints for flow sense determination (undirected arcs)
-
+ # model.constr_sns_sos1 = pyo.SOSConstraint(
+ # model.set_GLLJ_und, # one constraint per undirected arc
+ # model.set_QK, # and time interval
+ # var=model.var_zeta_sns_glljqk, # set_GLLJ_und_red and set_K
+ # index=model.set_GLLJQK_und_sns_sos1_red_gllj, #
+ # weights=model.param_arc_sns_sos1_weights_glljqk,
+ # sos=1,
+ # )
+ # TODO: make the weight list dependent in model options rather than literal
+ def rule_constr_sns_sos1(m, g, l1, l2, j, q, k):
+ var_list = [
+ m.var_zeta_sns_glljqk[(g, l1, l2, j, q, k)],
+ m.var_zeta_sns_glljqk[(g, l2, l1, j, q, k)]
+ ]
+ weight_list = [1, 2] if True else [2, 1]
+ return (var_list, weight_list)
model.constr_sns_sos1 = pyo.SOSConstraint(
- model.set_GLLJ_und, # one constraint per undirected arc
- model.set_QK, # and time interval
- var=model.var_zeta_sns_glljqk, # set_GLLJ_und_red and set_K
- index=model.set_GLLJQK_und_sns_sos1_red_gllj, #
- weights=model.param_arc_sns_sos1_weights_glljqk,
- sos=1,
+ model.set_GLLJ_und,
+ model.set_QK,
+ rule=rule_constr_sns_sos1,
+ sos=1
)
-
+
# *************************************************************************
# static losses
@@ -2941,13 +2934,20 @@ def create_model(
# *************************************************************************
# SOS1 constraints for arc group selection
-
+ def rule_constr_arc_group_sos1(m, t):
+ var_list = [
+ m.var_delta_arc_inv_th[(t, h)]
+ for h in m.set_H_t[t]
+ ]
+ weight_list = [
+ m.param_arc_inv_sos1_weights_th[(t, h)]
+ for h in m.set_H_t[t]
+ ]
+ return (var_list, weight_list)
model.constr_arc_group_sos1 = pyo.SOSConstraint(
- model.set_T_sos1, # for all groups using sos1
- var=model.var_delta_arc_inv_th, # set_TH indexes the variables
- index=model.set_TH_arc_inv_sos1_t, # key: t; value: TH
- weights=model.param_arc_inv_sos1_weights_th, # key: TH; value: weight
- sos=1,
+ model.set_T_sos1,
+ rule=rule_constr_arc_group_sos1,
+ sos=1
)
# *************************************************************************
diff --git a/src/topupopt/problems/esipp/network.py b/src/topupopt/problems/esipp/network.py
index 5e12053e74d96231b39831107d71a0f2dcfb43ea..be2f17a9fb35dd1bf56048151bb98303b348f6a3 100644
--- a/src/topupopt/problems/esipp/network.py
+++ b/src/topupopt/problems/esipp/network.py
@@ -15,9 +15,9 @@ from math import inf
# import numpy as np
import networkx as nx
-
+from ...data.gis.identify import get_edges_involving_node
from ...data.gis.identify import find_unconnected_nodes
-from .resource import are_prices_time_invariant
+# from .resource import are_prices_time_invariant, ResourcePrice
# *****************************************************************************
# *****************************************************************************
@@ -624,20 +624,34 @@ class Network(nx.MultiDiGraph):
)
def __init__(self, network_type = NET_TYPE_HYBRID, **kwargs):
- # run base class init routine
-
- nx.MultiDiGraph.__init__(self, **kwargs)
-
- # identify node types
-
- self.identify_node_types()
+
+ # initialise the node type
+ self.import_nodes = set()
+ self.export_nodes = set()
+ self.source_sink_nodes = set()
+ self.waypoint_nodes = set()
# declare variables for the nodes without directed arc limitations
+ if network_type not in self.NET_TYPES:
+ raise ValueError('Unknown network type.')
self.network_type = network_type
-
+ # nodes without incoming directed arcs limitations
self.nodes_w_in_dir_arc_limitations = dict()
-
+ # nodes without outgoing directed arcs limitations
self.nodes_w_out_dir_arc_limitations = dict()
+
+ # run base class init routine
+ nx.MultiDiGraph.__init__(self, **kwargs)
+
+ # process the input data
+ for node_key in self.nodes():
+ self._process_node_data(node_key, data=self.nodes[node_key])
+
+ # # set up initial nodes if the network is not hybrid
+ # if self.network_type != self.NET_TYPE_HYBRID:
+ # for node_key in self.nodes():
+ # self._set_up_node(node_key)
+
# *************************************************************************
# *************************************************************************
@@ -671,16 +685,226 @@ class Network(nx.MultiDiGraph):
# *************************************************************************
# *************************************************************************
+
+ def _process_node_data(self, node_key, data: dict, **kwargs):
+ "Check the data, determine the node type and update the structures."
+
+ # find out whicht type of node it is
+ # no data: waypoint
+ # prices: transshipment (imp/exp)
+ # flows: source/sink
+ if type(data) == type(None):
+ self.waypoint_nodes.add(node_key)
+ elif type(data) == dict:
+ # transshipment or source/sink
+ if self.KEY_NODE_BASE_FLOW in data and len(data) == 1:
+ # source/sink
+ self.source_sink_nodes.add(node_key)
+ elif self.KEY_NODE_PRICES in data and self.KEY_NODE_TYPE in data and data[self.KEY_NODE_TYPE] == self.KEY_NODE_TYPE_IMP:
+ # import node
+ self.import_nodes.add(node_key)
+ elif self.KEY_NODE_PRICES in data and self.KEY_NODE_TYPE in data and data[self.KEY_NODE_TYPE] == self.KEY_NODE_TYPE_EXP:
+ # export node
+ self.export_nodes.add(node_key)
+ elif self.KEY_NODE_PRICES not in data:
+ # waypoint node
+ self.waypoint_nodes.add(node_key)
+ else:
+ # error
+ raise TypeError('Invalid input data combination.')
+ else:
+ raise TypeError('Invalid type for node data.')
+ # set up the node
+ self._set_up_node(node_key, **kwargs)
+
+ # TODO: automatically identify import and export nodes (without defining them explicitly)
+
+ # *************************************************************************
+ # *************************************************************************
+
+ def is_export_node(self, node_key) -> bool:
+ "Returns True if the key matches that of an export node."
+ return node_key in self.export_nodes
+
+ def is_import_node(self, node_key) -> bool:
+ "Returns True if the key matches that of an import node."
+ return node_key in self.import_nodes
+
+ def is_waypoint_node(self, node_key) -> bool:
+ "Returns True if the key matches that of an waypoint node."
+ return node_key in self.waypoint_nodes
+
+ def is_source_sink_node(self, node_key) -> bool:
+ "Returns True if the key matches that of an source or sink node."
+ return node_key in self.source_sink_nodes
+
+ # *************************************************************************
+ # *************************************************************************
+
+ def _reset_node_type(self, node_key):
+
+ if self.is_export_node(node_key):
+ # export node
+ self.export_nodes.remove(node_key)
+ elif self.is_import_node(node_key):
+ # import node
+ self.import_nodes.remove(node_key)
+ elif self.is_source_sink_node(node_key):
+ # source/sink node
+ self.source_sink_nodes.remove(node_key)
+ elif self.is_waypoint_node(node_key):
+ # has to be a waypoint node
+ self.waypoint_nodes.remove(node_key)
+ # No need to reset node but this could mean something is up
+ # else:
+ # raise ValueError('Unknown node type.')
+
+ # *************************************************************************
+ # *************************************************************************
+
+ # TODO: use a decorator function to prevent the original method(s) from being used inappropriately
+
+ def add_node(self, node_key, **kwargs):
+ # check if the node can be added and add it
+ self._handle_node(node_key, **kwargs)
+
+ # *************************************************************************
+ # *************************************************************************
+
+ def modify_node(self, node_key, **kwargs):
+ if not self.has_node(node_key):
+ raise ValueError('The node indicated does not exist.')
+ self._handle_node(node_key, **kwargs)
+
+ # *************************************************************************
+ # *************************************************************************
+
+ # TODO: automatically check if node already exists and implications when "adding" one
+
+ # def add_nodes(self, node_key_data: list):
+
+ # # process the input data
+ # for entry in node_key_data:
+ # if type(entry) != tuple :
+ # raise ValueError('The input must be a list of tuples.')
+ # # self._handle_node(entry[0], **entry[1])
+ # self._process_node_data(entry[0], entry[1])
+ # # add the nodes
+ # nx.MultiDiGraph.add_nodes_from(self, node_key_data)
+
+ # *************************************************************************
+ # *************************************************************************
+
+ def add_nodes_from(self, nodes_for_adding, **kwargs):
+
+ # input formats:
+ # 1) container of node keys
+ # 2) container of tuples
+ # process the input data
+ for entry in nodes_for_adding:
+ if type(entry) == tuple and len(entry) == 2 and type(entry[1]) == dict:
+ # option 2
+ # update the dict
+ new_dict = kwargs.copy()
+ new_dict.update(entry[1])
+ self._handle_node(entry[0], **new_dict)
+ else:
+ # option 1
+ self._handle_node(entry, **kwargs)
+
+ # *************************************************************************
+ # *************************************************************************
+
+ def modify_nodes_from(self, nodes_for_adding, **kwargs):
+
+ # input formats:
+ # 1) container of node keys
+ # 2) container of tuples
+ # process the input data
+ for entry in nodes_for_adding:
+ if type(entry) == tuple and len(entry) == 2 and type(entry[1]) == dict:
+ # option 2
+ new_dict = kwargs.copy()
+ new_dict.update(entry[1])
+ if not self.has_node(entry[0]):
+ raise ValueError('The node indicated does not exist.')
+ self._handle_node(entry[0], **new_dict)
+ else:
+ # option 1
+ if not self.has_node(entry):
+ raise ValueError('The node indicated does not exist.')
+ self._handle_node(entry, **kwargs)
+
+ # *************************************************************************
+ # *************************************************************************
+
+ def _handle_node(self, node_key, **kwargs):
+
+ # node has to exist
+ # the changes have to be compatible with the arcs involving the node
+ # - has outgoing arcs: cannot be an export node
+ # - has incoming arcs: cannot be an import node
+ # - has no arcs: can be anything
+ # the structures have to be updated accordingly
+
+ if self.has_node(node_key):
+ # node exists
+ if type(kwargs) != type(None):
+ # has data, check if the node type changes
+ if self.KEY_NODE_TYPE in kwargs:
+ # node type is in the dict
+ _edges = get_edges_involving_node(self, node_key, include_self_loops=False)
+ # the node type is specified, possible change of node
+ if kwargs[self.KEY_NODE_TYPE] == self.KEY_NODE_TYPE_EXP and not self.is_export_node(node_key):
+ # change to an export node: it cannot have outgoing arcs
+ for _edge in _edges:
+ if _edge[0] == node_key:
+ # outgoing arc, raise error
+ raise ValueError(
+ 'A node with outgoing arcs cannot be an '
+ 'export node.'
+ )
+ # change the node type
+ elif kwargs[self.KEY_NODE_TYPE] == self.KEY_NODE_TYPE_IMP and not self.is_import_node(node_key):
+ # change to an import node: it cannot have incoming arcs
+ for _edge in _edges:
+ if _edge[1] == node_key:
+ # incoming arc, raise error
+ raise ValueError(
+ 'A node with incoming arcs cannot be an '
+ 'import node.'
+ )
+ # else:
+ # raise ValueError('Unknown option.')
+ # everything seems to be okay: reset node data
+ self._reset_node_type(node_key)
+ else:
+ # no data: waypoint node, clear node data
+ self._reset_node_type(node_key)
+ keys = (self.KEY_NODE_BASE_FLOW, self.KEY_NODE_PRICES)
+ for key in keys:
+ if key in self.nodes[node_key]:
+ self.nodes[node_key].pop(key)
+ # the changes seem okay
+ self._process_node_data(node_key, kwargs)
+ nx.MultiDiGraph.add_node(self, node_key, **kwargs)
+
+ else:
+ # process the input data
+ self._process_node_data(node_key, kwargs)
+ # add the node
+ nx.MultiDiGraph.add_node(self, node_key, **kwargs)
+
+ # *************************************************************************
+ # *************************************************************************
# add a new import node
def add_import_node(self, node_key, prices: dict):
node_dict = {
self.KEY_NODE_TYPE: self.KEY_NODE_TYPE_IMP,
- self.KEY_NODE_PRICES: prices,
- self.KEY_NODE_PRICES_TIME_INVARIANT: (are_prices_time_invariant(prices)),
+ self.KEY_NODE_PRICES: prices
}
-
self.add_node(node_key, **node_dict)
# *************************************************************************
@@ -691,10 +915,8 @@ class Network(nx.MultiDiGraph):
def add_export_node(self, node_key, prices: dict):
node_dict = {
self.KEY_NODE_TYPE: self.KEY_NODE_TYPE_EXP,
- self.KEY_NODE_PRICES: prices,
- self.KEY_NODE_PRICES_TIME_INVARIANT: (are_prices_time_invariant(prices)),
+ self.KEY_NODE_PRICES: prices
}
-
self.add_node(node_key, **node_dict)
# *************************************************************************
@@ -704,169 +926,164 @@ class Network(nx.MultiDiGraph):
def add_source_sink_node(self, node_key, base_flow: dict, **kwargs):
node_dict = {
- self.KEY_NODE_TYPE: self.KEY_NODE_TYPE_SOURCE_SINK,
self.KEY_NODE_BASE_FLOW: base_flow,
}
-
self.add_node(node_key, **node_dict)
- self._set_up_node(node_key, **kwargs)
# *************************************************************************
# *************************************************************************
# add a new waypoint node
- def add_waypoint_node(self, node_key, **kwargs):
- node_dict = {self.KEY_NODE_TYPE: self.KEY_NODE_TYPE_WAY}
-
- self.add_node(node_key, **node_dict)
- self._set_up_node(node_key, **kwargs)
+ def add_waypoint_node(self, node_key):
+ self.add_node(node_key)
# *************************************************************************
# *************************************************************************
- # modify an existing network node
+ # # modify an existing network node
- def modify_network_node(self, node_key, node_data: dict):
- """
- Modifies a node in the network object.
+ # def modify_network_node(self, node_key, node_data: dict, **kwargs):
+ # """
+ # Modifies a node in the network object.
- Parameters
- ----------
- node_key : hashable-type
- The key that identifies the node.
- node_data : dict
- A dictionary with the data that one wishes to change in the object.
-
- Raises
- ------
- ValueError
- Errors are raised if the node does not exist in the network object,
- and if the node changed has arcs that are incompatible with its new
- version, namely in terms of incoming and outgoing arcs.
+ # Parameters
+ # ----------
+ # node_key : hashable-type
+ # The key that identifies the node.
+ # node_data : dict
+ # A dictionary with the data that one wishes to change in the object.
- Returns
- -------
- None.
+ # Raises
+ # ------
+ # ValueError
+ # Errors are raised if the node does not exist in the network object,
+ # and if the node changed has arcs that are incompatible with its new
+ # version, namely in terms of incoming and outgoing arcs.
- """
+ # Returns
+ # -------
+ # None.
- if self.has_node(node_key):
- # check if there will be changes to the type of node
+ # """
- if (
- self.KEY_NODE_TYPE in node_data
- and self.KEY_NODE_TYPE in self.nodes[node_key]
- ):
- if (
- node_data[self.KEY_NODE_TYPE]
- != self.nodes[node_key][self.KEY_NODE_TYPE]
- ):
- # the node type changed: check if final node is imp./exp.
+ # if self.has_node(node_key):
+ # # check if there will be changes to the type of node
- # to export nodes
+ # if (
+ # self.KEY_NODE_TYPE in node_data
+ # and self.KEY_NODE_TYPE in self.nodes[node_key]
+ # ):
+ # if (
+ # node_data[self.KEY_NODE_TYPE]
+ # != self.nodes[node_key][self.KEY_NODE_TYPE]
+ # ):
+ # # the node type changed: check if final node is imp./exp.
- if node_data[self.KEY_NODE_TYPE] == self.KEY_NODE_TYPE_EXP:
- # export nodes cannot have outgoing arcs
- # check if there are outgoing arcs involving this node
+ # # to export nodes
- number_out_arcs = len(
- tuple(
- arc_key
- for arc_key in self.edges(keys=True)
- if arc_key[0] == node_key # is source
- )
- )
+ # if node_data[self.KEY_NODE_TYPE] == self.KEY_NODE_TYPE_EXP:
+ # # export nodes cannot have outgoing arcs
+ # # check if there are outgoing arcs involving this node
- if number_out_arcs > 0:
- raise ValueError(
- "A node with outgoing arcs cannot be changed"
- + " into an export node, since export nodes "
- + " cannot have outgoing arcs."
- )
-
- # to import nodes
-
- if node_data[self.KEY_NODE_TYPE] == self.KEY_NODE_TYPE_IMP:
- # import nodes cannot have incoming arcs
- # check if there are incoming arcs involving this node
-
- number_in_arcs = len(
- tuple(
- arc_key
- for arc_key in self.edges(keys=True)
- if arc_key[1] == node_key # is destination
- )
- )
+ # number_out_arcs = len(
+ # tuple(
+ # arc_key
+ # for arc_key in self.edges(keys=True)
+ # if arc_key[0] == node_key # is source
+ # )
+ # )
- if number_in_arcs > 0:
- raise ValueError(
- "A node with incoming arcs cannot be changed"
- + " into an import node, since import nodes "
- + " cannot have incoming arcs."
- )
+ # if number_out_arcs > 0:
+ # raise ValueError(
+ # "A node with outgoing arcs cannot be changed"
+ # + " into an export node, since export nodes "
+ # + " cannot have outgoing arcs."
+ # )
- # all good
+ # # to import nodes
- self.add_node(node_key, **node_data)
+ # if node_data[self.KEY_NODE_TYPE] == self.KEY_NODE_TYPE_IMP:
+ # # import nodes cannot have incoming arcs
+ # # check if there are incoming arcs involving this node
- else:
- raise ValueError("No such node was found.")
+ # number_in_arcs = len(
+ # tuple(
+ # arc_key
+ # for arc_key in self.edges(keys=True)
+ # if arc_key[1] == node_key # is destination
+ # )
+ # )
- # *************************************************************************
- # *************************************************************************
+ # if number_in_arcs > 0:
+ # raise ValueError(
+ # "A node with incoming arcs cannot be changed"
+ # + " into an import node, since import nodes "
+ # + " cannot have incoming arcs."
+ # )
- # identify importing nodes
+ # # all good
- def identify_import_nodes(self):
- self.import_nodes = tuple(
- node_key
- for node_key in self.nodes
- if self.KEY_NODE_TYPE in self.nodes[node_key]
- if (self.nodes[node_key][self.KEY_NODE_TYPE] == self.KEY_NODE_TYPE_IMP)
- )
+ # self.add_node(node_key, **node_data)
+ # self._set_up_node(node_key, **kwargs)
+
+ # else:
+ # raise ValueError("No such node was found.")
# *************************************************************************
# *************************************************************************
- # identify exporting nodes
+ # # identify importing nodes
- def identify_export_nodes(self):
- self.export_nodes = tuple(
- node_key
- for node_key in self.nodes
- if self.KEY_NODE_TYPE in self.nodes[node_key]
- if (self.nodes[node_key][self.KEY_NODE_TYPE] == self.KEY_NODE_TYPE_EXP)
- )
+ # def identify_import_nodes(self):
+ # self.import_nodes = tuple(
+ # node_key
+ # for node_key in self.nodes
+ # if self.KEY_NODE_TYPE in self.nodes[node_key]
+ # if (self.nodes[node_key][self.KEY_NODE_TYPE] == self.KEY_NODE_TYPE_IMP)
+ # )
- # *************************************************************************
- # *************************************************************************
+ # # *************************************************************************
+ # # *************************************************************************
- # identify waypoint nodes
+ # # identify exporting nodes
+
+ # def identify_export_nodes(self):
+ # self.export_nodes = tuple(
+ # node_key
+ # for node_key in self.nodes
+ # if self.KEY_NODE_TYPE in self.nodes[node_key]
+ # if (self.nodes[node_key][self.KEY_NODE_TYPE] == self.KEY_NODE_TYPE_EXP)
+ # )
- def identify_waypoint_nodes(self):
- self.waypoint_nodes = tuple(
- node_key
- for node_key in self.nodes
- if self.KEY_NODE_TYPE in self.nodes[node_key]
- if (self.nodes[node_key][self.KEY_NODE_TYPE] == self.KEY_NODE_TYPE_WAY)
- )
+ # # *************************************************************************
+ # # *************************************************************************
- # *************************************************************************
- # *************************************************************************
+ # # identify waypoint nodes
- # identify source sink nodes
+ # def identify_waypoint_nodes(self):
+ # self.waypoint_nodes = tuple(
+ # node_key
+ # for node_key in self.nodes
+ # if self.KEY_NODE_TYPE in self.nodes[node_key]
+ # if (self.nodes[node_key][self.KEY_NODE_TYPE] == self.KEY_NODE_TYPE_WAY)
+ # )
- def identify_source_sink_nodes(self):
- self.source_sink_nodes = tuple(
- node_key
- for node_key in self.nodes
- if self.KEY_NODE_TYPE in self.nodes[node_key]
- if (
- self.nodes[node_key][self.KEY_NODE_TYPE]
- == self.KEY_NODE_TYPE_SOURCE_SINK
- )
- )
+ # # *************************************************************************
+ # # *************************************************************************
+
+ # # identify source sink nodes
+
+ # def identify_source_sink_nodes(self):
+ # self.source_sink_nodes = tuple(
+ # node_key
+ # for node_key in self.nodes
+ # if self.KEY_NODE_TYPE in self.nodes[node_key]
+ # if (
+ # self.nodes[node_key][self.KEY_NODE_TYPE]
+ # == self.KEY_NODE_TYPE_SOURCE_SINK
+ # )
+ # )
# *************************************************************************
# *************************************************************************
@@ -910,52 +1127,47 @@ class Network(nx.MultiDiGraph):
# *************************************************************************
# *************************************************************************
- # identify node types
+ # # identify node types
- def identify_node_types(self):
- "Identifies the node type for each node in the network objects."
+ # def identify_node_types(self):
+ # "Identifies the node type for each node in the network objects."
- # identify import nodes
+ # # identify import nodes
- self.identify_import_nodes()
+ # self.identify_import_nodes()
- # identify export nodes
+ # # identify export nodes
- self.identify_export_nodes()
+ # self.identify_export_nodes()
- # identify source/sink nodes
+ # # identify source/sink nodes
- self.identify_source_sink_nodes()
+ # self.identify_source_sink_nodes()
- # identify waypoint nodes
+ # # identify waypoint nodes
- self.identify_waypoint_nodes()
+ # self.identify_waypoint_nodes()
- # validate
+ # # validate
- self.validate()
+ # self.validate()
# *************************************************************************
# *************************************************************************
def add_directed_arc(self, node_key_a, node_key_b, arcs: Arcs):
# check if the arc ends in an import node
-
if node_key_b in self.import_nodes:
raise ValueError("Directed arcs cannot end in an import node.")
# check if the arc starts in an export node
-
if node_key_a in self.export_nodes:
raise ValueError("Directed arcs cannot start in an export node.")
# check the arc is between import and export nodes
-
if node_key_a in self.import_nodes and node_key_b in self.export_nodes:
# it is between import and export nodes
-
# check if it involves static losses
-
if arcs.has_static_losses():
raise ValueError(
"Arcs between import and export nodes cannot have static "
@@ -963,7 +1175,6 @@ class Network(nx.MultiDiGraph):
)
# add a new arc
-
return self.add_edge(
node_key_a, node_key_b, **{self.KEY_ARC_TECH: arcs, self.KEY_ARC_UND: False}
)
diff --git a/src/topupopt/problems/esipp/problem.py b/src/topupopt/problems/esipp/problem.py
index 3659ad67caea582d20dab8d2251aa3d023987d71..4d89b122ee5940d4a3c7a56aa7e2a35cbb938221 100644
--- a/src/topupopt/problems/esipp/problem.py
+++ b/src/topupopt/problems/esipp/problem.py
@@ -16,6 +16,7 @@ from .system import EnergySystem
from .resource import ResourcePrice
from .time import EconomicTimeFrame
from .time import entries_are_invariant
+from .blocks.prices import NODE_PRICE_OTHER, NODE_PRICES
# *****************************************************************************
# *****************************************************************************
@@ -63,15 +64,6 @@ class InfrastructurePlanningProblem(EnergySystem):
STATIC_LOSS_MODE_US,
STATIC_LOSS_MODE_DS,
)
-
- NODE_PRICE_LAMBDA = 1
- NODE_PRICE_DELTA = 2
- NODE_PRICE_OTHER = 3
- NODE_PRICES = (
- NODE_PRICE_LAMBDA,
- NODE_PRICE_DELTA,
- NODE_PRICE_OTHER
- )
# *************************************************************************
# *************************************************************************
@@ -89,7 +81,8 @@ class InfrastructurePlanningProblem(EnergySystem):
converters: dict = None,
prepare_model: bool = True,
validate_inputs: bool = True,
- node_price_model = NODE_PRICE_DELTA
+ node_price_model = NODE_PRICE_OTHER,
+ use_prices_block: bool = True #False
): # TODO: switch to False when everything is more mature
# *********************************************************************
@@ -122,6 +115,16 @@ class InfrastructurePlanningProblem(EnergySystem):
# self.number_time_intervals = {
# q: len(time_frame.time_intervals[q]) for q in self.time_frame.assessments
# }
+
+ # *********************************************************************
+ # *********************************************************************
+
+ # options
+ self.use_prices_block = use_prices_block
+ self.node_price_model = node_price_model
+
+ # *********************************************************************
+ # *********************************************************************
# initialise
@@ -470,6 +473,7 @@ class InfrastructurePlanningProblem(EnergySystem):
use_sos1: bool = False,
use_interface: bool = False,
use_nnr_variables_if_possible: bool = False,
+ sos1_weight_method: int = SOS1_ARC_WEIGHTS_NONE
) -> int:
"""
Create a group of arcs whose invesment is to be decided collectively.
@@ -490,14 +494,14 @@ class InfrastructurePlanningProblem(EnergySystem):
Returns the key that identifies the arc group, an integer.
"""
-
+
# make sure there is at least one arc
if len(gllj_tuples) < 2:
raise ValueError(
"At least two arcs need to be identified to create a group."
)
-
+
for arc_number, gllj in enumerate(gllj_tuples):
# does the network exist?
@@ -555,10 +559,10 @@ class InfrastructurePlanningProblem(EnergySystem):
# groups using interfaces
self.groups_int[new_t] = use_interface
-
+ # TODO: allow users to set the weights
# groups using sos1 for arc selection
-
- self.groups_arc_sos1[new_t] = use_sos1
+ if use_sos1:
+ self.groups_arc_sos1[new_t] = [i for i in range(number_options)]
# groups using nnr for arc selection
@@ -1625,28 +1629,22 @@ class InfrastructurePlanningProblem(EnergySystem):
raise ValueError(
"The method to determine the SOS1 weights was not recognised."
)
-
if method == self.SOS1_ARC_WEIGHTS_CAP:
sos1_weights = tuple(capacity for capacity in arcs.capacity)
-
elif method == self.SOS1_ARC_WEIGHTS_COST:
sos1_weights = tuple(cost for cost in arcs.minimum_cost)
-
elif method == self.SOS1_ARC_WEIGHTS_SPEC_CAP:
sos1_weights = tuple(
cap / cost for cap, cost in zip(arcs.capacity, arcs.minimum_cost)
)
-
elif method == self.SOS1_ARC_WEIGHTS_SPEC_COST:
sos1_weights = tuple(
cost / cap for cap, cost in zip(arcs.capacity, arcs.minimum_cost)
)
-
else: # SOS1_ARC_WEIGHTS_NONE
return None
# make sure they are unique
-
if verify_weights:
for weight in sos1_weights:
if sos1_weights.count(weight) >= 2: # TODO: reach this point
@@ -1655,7 +1653,6 @@ class InfrastructurePlanningProblem(EnergySystem):
+ "special ordered sets of type 1 (SOS1),"
+ " since some weights are not unique."
)
-
return sos1_weights
# *************************************************************************
@@ -1663,10 +1660,12 @@ class InfrastructurePlanningProblem(EnergySystem):
def prepare(self, name = None):
"""Sets up the problem model with which instances can be built."""
-
# create pyomo model (AbstractModel)
-
- self.model = create_model(name)
+ self.model = create_model(
+ name,
+ use_prices_block=self.use_prices_block,
+ node_price_model=self.node_price_model
+ )
# *************************************************************************
# *************************************************************************
@@ -1883,19 +1882,6 @@ class InfrastructurePlanningProblem(EnergySystem):
.number_segments()
)
)
- if not self.networks[g].nodes[l][Network.KEY_NODE_PRICES_TIME_INVARIANT]
- else tuple(
- s
- for s in range(
- self.networks[g]
- .nodes[l][Network.KEY_NODE_PRICES][(q, p, k)]
- .number_segments()
- )
- )
- # for g in self.networks.keys()
- # for l in self.networks[g].nodes
- # if (l in self.networks[g].import_nodes or
- # l in self.networks[g].export_nodes)
for (g, l) in set_GL_exp_imp
for (q, p, k) in set_QPK
}
@@ -2467,7 +2453,7 @@ class InfrastructurePlanningProblem(EnergySystem):
# set of arc groups relying on SOS1
- set_T_sos1 = tuple(t for t in set_T if self.groups_arc_sos1[t])
+ set_T_sos1 = tuple(t for t in set_T if t in self.groups_arc_sos1)
# set of arg groups relying on non-negative real variables
@@ -2561,7 +2547,7 @@ class InfrastructurePlanningProblem(EnergySystem):
}
# maximum resource volume per segment (infinity is the default)
-
+
param_v_max_glqpks = {
(g, l, q, p, k, s): self.networks[g]
.nodes[l][Network.KEY_NODE_PRICES][(q, p, k)]
@@ -3145,12 +3131,6 @@ class InfrastructurePlanningProblem(EnergySystem):
set_GLLJH_arc_inv_sos1 = tuple(param_arc_inv_sos1_weights_glljh.keys())
- set_GLLJH_arc_inv_sos1_gllj = {
- (g, u, v, j): tuple((g, u, v, j, h) for h in set_H_gllj[(g, u, v, j)])
- for (g, u, v) in set_J_arc_sos1
- for j in set_J_arc_sos1[(g, u, v)]
- }
-
# sos1 weights for flow sense determination
param_arc_sns_sos1_weights_glljqk = {
@@ -3214,7 +3194,7 @@ class InfrastructurePlanningProblem(EnergySystem):
}
param_arc_inv_sos1_weights_th = {
- (t, h): h
+ (t, h): self.groups_arc_sos1[t][h]
# (t, h): mean(
# (self.use_sos1_arc_inv[(g,u,v,j)][h]
# if self.use_sos1_arc_inv[(g,u,v,j)] is not None else h)
@@ -3309,6 +3289,8 @@ class InfrastructurePlanningProblem(EnergySystem):
# *********************************************************************
# produce a dictionary with the data for the problem
+
+ # TODO: built the dict as a function of the price submodel
data_dict = {
None: {
@@ -3433,7 +3415,6 @@ class InfrastructurePlanningProblem(EnergySystem):
"set_GLLJ_pre_fin_red": set_GLLJ_pre_fin_red,
"set_GLLJ_arc_inv_sos1": set_GLLJ_arc_inv_sos1,
"set_GLLJH_arc_inv_sos1": set_GLLJH_arc_inv_sos1,
- "set_GLLJH_arc_inv_sos1_gllj": set_GLLJH_arc_inv_sos1_gllj,
"set_GLLJQK_und_sns_sos1_red": set_GLLJQK_und_sns_sos1_red,
"set_GLLJ_int": set_GLLJ_int,
"set_GLLJ_static": set_GLLJ_static,
@@ -3524,6 +3505,16 @@ class InfrastructurePlanningProblem(EnergySystem):
"param_arc_sns_sos1_weights_glljqk": param_arc_sns_sos1_weights_glljqk,
# *****************************************************************
# *****************************************************************
+ "block_prices": {
+ (*gl,*qpk): {
+ 'param_price_function_is_convex': {None: param_price_function_is_convex[(*gl,*qpk)]},
+ 'set_S': {None: set_S[(*gl,*qpk)]},
+ 'param_p_s': {s: param_p_glqpks[(*gl,*qpk,s)] for s in set_S[(*gl,*qpk)]},
+ 'param_v_max_s': {s: param_v_max_glqpks[(*gl,*qpk,s)] for s in set_S[(*gl,*qpk)] if (*gl,*qpk,s) in param_v_max_glqpks},
+ }
+ for gl in set_GL_exp_imp
+ for qpk in set_QPK
+ }
}
}
diff --git a/src/topupopt/problems/esipp/utils.py b/src/topupopt/problems/esipp/utils.py
index 4047696c1311ed28b21307510000cd5c8638cbf9..9c5cdbdf4102ae37ff2af1dd0b74f1274a076b6d 100644
--- a/src/topupopt/problems/esipp/utils.py
+++ b/src/topupopt/problems/esipp/utils.py
@@ -13,6 +13,7 @@ from matplotlib import pyplot as plt
# local, internal
from .problem import InfrastructurePlanningProblem
from .network import Network
+from .blocks.prices import NODE_PRICE_DELTA, NODE_PRICE_LAMBDA #, NODE_PRICE_OTHER
# *****************************************************************************
# *****************************************************************************
@@ -69,6 +70,7 @@ def statistics(ipp: InfrastructurePlanningProblem,
other_node_keys: tuple = None):
"Returns flow statistics using the optimisation results."
+ prices_in_block = ipp.use_prices_block
if type(import_node_keys) == type(None):
# pick all import nodes
@@ -94,36 +96,116 @@ def statistics(ipp: InfrastructurePlanningProblem,
for node_key in net.nodes()
if Network.KEY_NODE_BASE_FLOW in net.nodes[node_key]
)
-
- # imports
- imports_qpk = {
- qpk: pyo.value(
- sum(
- ipp.instance.var_trans_flows_glqpks[(g,l_imp,*qpk, s)]
- for g, l_imp in import_node_keys
- # for g in ipp.networks
- # for l_imp in ipp.networks[g].import_nodes
- for s in ipp.instance.set_S[(g,l_imp,*qpk)]
- )
- *ipp.instance.param_c_time_qpk[qpk]
- )
- for qpk in ipp.time_frame.qpk()
- }
-
- # exports
- exports_qpk = {
- qpk: pyo.value(
- sum(
- ipp.instance.var_trans_flows_glqpks[(g,l_exp,*qpk, s)]
- for g, l_exp in export_node_keys
- # for g in ipp.networks
- # for l_exp in ipp.networks[g].export_nodes
- for s in ipp.instance.set_S[(g,l_exp,*qpk)]
- )
- *ipp.instance.param_c_time_qpk[qpk]
- )
- for qpk in ipp.time_frame.qpk()
- }
+ if prices_in_block:
+ # imports
+ if ipp.node_price_model == NODE_PRICE_DELTA or ipp.node_price_model == NODE_PRICE_LAMBDA:
+ # imports
+ imports_qpk = {
+ qpk: pyo.value(
+ sum(
+ ipp.instance.block_prices[(g,l_imp,*qpk)].var_trans_flows
+ for g, l_imp in import_node_keys
+ )
+ *ipp.instance.param_c_time_qpk[qpk]
+ )
+ for qpk in ipp.time_frame.qpk()
+ }
+ # exports
+ exports_qpk = {
+ qpk: pyo.value(
+ sum(
+ ipp.instance.block_prices[(g,l_exp,*qpk)].var_trans_flows
+ for g, l_exp in export_node_keys
+ )
+ *ipp.instance.param_c_time_qpk[qpk]
+ )
+ for qpk in ipp.time_frame.qpk()
+ }
+ else:
+ # imports
+ imports_qpk = {
+ qpk: pyo.value(
+ sum(
+ ipp.instance.block_prices[(g,l_imp,*qpk)].var_trans_flows_s[s]
+ for g, l_imp in import_node_keys
+ # for g in ipp.networks
+ # for l_imp in ipp.networks[g].import_nodes
+ for s in ipp.instance.block_prices[(g,l_imp,*qpk)].set_S
+ )
+ *ipp.instance.param_c_time_qpk[qpk]
+ )
+ for qpk in ipp.time_frame.qpk()
+ }
+ # exports
+ exports_qpk = {
+ qpk: pyo.value(
+ sum(
+ ipp.instance.block_prices[(g,l_exp,*qpk)].var_trans_flows_s[s]
+ for g, l_exp in export_node_keys
+ # for g in ipp.networks
+ # for l_exp in ipp.networks[g].export_nodes
+ for s in ipp.instance.block_prices[(g,l_exp,*qpk)].set_S
+ )
+ *ipp.instance.param_c_time_qpk[qpk]
+ )
+ for qpk in ipp.time_frame.qpk()
+ }
+ else:
+ # not in a block
+ if ipp.node_price_model == NODE_PRICE_DELTA or ipp.node_price_model == NODE_PRICE_LAMBDA:
+ # imports
+ imports_qpk = {
+ qpk: pyo.value(
+ sum(
+ ipp.instance.var_trans_flows_glqpk[(g,l_imp,*qpk)]
+ for g, l_imp in import_node_keys
+ )
+ *ipp.instance.param_c_time_qpk[qpk]
+ )
+ for qpk in ipp.time_frame.qpk()
+ }
+
+ # exports
+ exports_qpk = {
+ qpk: pyo.value(
+ sum(
+ ipp.instance.var_trans_flows_glqpk[(g,l_exp,*qpk)]
+ for g, l_exp in export_node_keys
+ )
+ *ipp.instance.param_c_time_qpk[qpk]
+ )
+ for qpk in ipp.time_frame.qpk()
+ }
+ else:
+ # imports
+ imports_qpk = {
+ qpk: pyo.value(
+ sum(
+ ipp.instance.var_trans_flows_glqpks[(g,l_imp,*qpk, s)]
+ for g, l_imp in import_node_keys
+ # for g in ipp.networks
+ # for l_imp in ipp.networks[g].import_nodes
+ for s in ipp.instance.set_S[(g,l_imp,*qpk)]
+ )
+ *ipp.instance.param_c_time_qpk[qpk]
+ )
+ for qpk in ipp.time_frame.qpk()
+ }
+
+ # exports
+ exports_qpk = {
+ qpk: pyo.value(
+ sum(
+ ipp.instance.var_trans_flows_glqpks[(g,l_exp,*qpk, s)]
+ for g, l_exp in export_node_keys
+ # for g in ipp.networks
+ # for l_exp in ipp.networks[g].export_nodes
+ for s in ipp.instance.set_S[(g,l_exp,*qpk)]
+ )
+ *ipp.instance.param_c_time_qpk[qpk]
+ )
+ for qpk in ipp.time_frame.qpk()
+ }
# balance
balance_qpk = {
qpk: imports_qpk[qpk]-exports_qpk[qpk]
diff --git a/tests/examples_signal.py b/tests/examples_signal.py
index dc481e4c618a094a1690431a10e6dc7f34e3fc30..867a2ad58ba42775dbbbefc292d2afec3b310523 100644
--- a/tests/examples_signal.py
+++ b/tests/examples_signal.py
@@ -122,18 +122,18 @@ def example_amplitude_constrained_nnr_signals():
# by providing a non-numeric nr. of samples without specific lower bounds
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.AmplitudeConstrainedNNRSignal(
number_samples=(number_intervals,), max_pos_amp_limit=10
)
except TypeError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# by providing negative lower bounds
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.AmplitudeConstrainedNNRSignal(
number_samples=number_intervals,
@@ -141,8 +141,8 @@ def example_amplitude_constrained_nnr_signals():
lower_bounds=[-1 for i in range(number_intervals)],
)
except ValueError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# ******************************************************************************
@@ -378,7 +378,7 @@ def example_amplitude_constrained_signals():
# by providing negative 'positive' amplitude limits
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.AmplitudeConstrainedSignal(
number_samples=number_intervals,
@@ -388,10 +388,10 @@ def example_amplitude_constrained_signals():
min_neg_amp_limit=None,
)
except ValueError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.AmplitudeConstrainedSignal(
number_samples=number_intervals,
@@ -401,12 +401,12 @@ def example_amplitude_constrained_signals():
min_neg_amp_limit=None,
)
except ValueError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# by providing negative 'negative' amplitude limits
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.AmplitudeConstrainedSignal(
number_samples=number_intervals,
@@ -416,10 +416,10 @@ def example_amplitude_constrained_signals():
min_neg_amp_limit=4,
)
except ValueError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.AmplitudeConstrainedSignal(
number_samples=number_intervals,
@@ -429,12 +429,12 @@ def example_amplitude_constrained_signals():
min_neg_amp_limit=-4,
)
except ValueError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# by providing non-numeric or not None amplitude limits (e.g. tuple)
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.AmplitudeConstrainedSignal(
number_samples=number_intervals,
@@ -444,10 +444,10 @@ def example_amplitude_constrained_signals():
min_neg_amp_limit=None,
)
except TypeError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.AmplitudeConstrainedSignal(
number_samples=number_intervals,
@@ -457,10 +457,10 @@ def example_amplitude_constrained_signals():
min_neg_amp_limit=None,
)
except TypeError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.AmplitudeConstrainedSignal(
number_samples=number_intervals,
@@ -470,10 +470,10 @@ def example_amplitude_constrained_signals():
min_neg_amp_limit=None,
)
except TypeError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.AmplitudeConstrainedSignal(
number_samples=number_intervals,
@@ -483,12 +483,12 @@ def example_amplitude_constrained_signals():
min_neg_amp_limit=(3,),
)
except TypeError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# by providing bounds incompatible with positive limits
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.AmplitudeConstrainedSignal(
number_samples=number_intervals,
@@ -500,12 +500,12 @@ def example_amplitude_constrained_signals():
lower_bounds=[10 for i in range(number_intervals)],
)
except ValueError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# by providing bounds incompatible with negative limits
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.AmplitudeConstrainedSignal(
number_samples=number_intervals,
@@ -517,12 +517,12 @@ def example_amplitude_constrained_signals():
lower_bounds=None,
)
except ValueError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# by providing incompatible maximum and minimum positive limits
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.AmplitudeConstrainedSignal(
number_samples=number_intervals,
@@ -532,12 +532,12 @@ def example_amplitude_constrained_signals():
min_neg_amp_limit=None,
)
except ValueError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# by providing incompatible maximum and minimum negative limits
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.AmplitudeConstrainedSignal(
number_samples=number_intervals,
@@ -547,12 +547,12 @@ def example_amplitude_constrained_signals():
min_neg_amp_limit=11,
)
except ValueError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# by providing non-numeric or not None amplitude limits (e.g. tuple)
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.AmplitudeConstrainedSignal(
number_samples=number_intervals,
@@ -563,12 +563,12 @@ def example_amplitude_constrained_signals():
)
sig.set_positive_amplitude(positive_amplitude=(5,))
except TypeError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# by providing non-numeric or not None amplitude limits (e.g. tuple)
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.AmplitudeConstrainedSignal(
number_samples=number_intervals,
@@ -579,12 +579,12 @@ def example_amplitude_constrained_signals():
)
sig.set_negative_amplitude(negative_amplitude=(5,))
except TypeError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# by checking if bounds have been violated without there being samples
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.AmplitudeConstrainedSignal(
number_samples=number_intervals,
@@ -602,13 +602,13 @@ def example_amplitude_constrained_signals():
assert not sig.is_signal_fixed() # signal is not set
assert not sig.violates_amplitude_limits() # since the sig is not set
except ValueError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# by seeking to validate a positive amplitude when there are no positive
# amplitude limits
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.AmplitudeConstrainedSignal(
number_samples=number_intervals,
@@ -619,13 +619,13 @@ def example_amplitude_constrained_signals():
)
sig.validate_negative_amplitude()
except ValueError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# by seeking to validate a negative amplitude when there are no negative
# amplitude limits
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.AmplitudeConstrainedSignal(
number_samples=number_intervals,
@@ -636,13 +636,13 @@ def example_amplitude_constrained_signals():
)
sig.validate_positive_amplitude()
except ValueError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# by seeking to validate a positive amplitude that exceeds its tolerated
# maximum, using the internal positive amplitude
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.AmplitudeConstrainedSignal(
number_samples=number_intervals,
@@ -654,13 +654,13 @@ def example_amplitude_constrained_signals():
sig.set_positive_amplitude(12)
sig.validate_positive_amplitude()
except ValueError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# by seeking to validate a positive amplitude that exceeds its tolerated
# maximum, using an externally supplied amplitude
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.AmplitudeConstrainedSignal(
number_samples=number_intervals,
@@ -671,13 +671,13 @@ def example_amplitude_constrained_signals():
)
sig.validate_positive_amplitude(12)
except ValueError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# by seeking to validate a positive amplitude that is below its tolerated
# minimum, using the internal positive amplitude
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.AmplitudeConstrainedSignal(
number_samples=number_intervals,
@@ -689,13 +689,13 @@ def example_amplitude_constrained_signals():
sig.set_positive_amplitude(2)
sig.validate_positive_amplitude()
except ValueError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# by seeking to validate a positive amplitude that is below its tolerated
# minimum, using an externally supplied amplitude
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.AmplitudeConstrainedSignal(
number_samples=number_intervals,
@@ -706,13 +706,13 @@ def example_amplitude_constrained_signals():
)
sig.validate_positive_amplitude(2)
except ValueError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# by seeking to validate a negative amplitude that exceeds its tolerated
# maximum, using the internal negative amplitude
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.AmplitudeConstrainedSignal(
number_samples=number_intervals,
@@ -724,13 +724,13 @@ def example_amplitude_constrained_signals():
sig.set_negative_amplitude(12)
sig.validate_negative_amplitude()
except ValueError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# by seeking to validate a negative amplitude that exceeds its tolerated
# maximum, using an externally supplied amplitude
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.AmplitudeConstrainedSignal(
number_samples=number_intervals,
@@ -741,13 +741,13 @@ def example_amplitude_constrained_signals():
)
sig.validate_negative_amplitude(12)
except ValueError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# by seeking to validate a negative amplitude that is below its tolerated
# minimum, using the internal negative amplitude
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.AmplitudeConstrainedSignal(
number_samples=number_intervals,
@@ -759,13 +759,13 @@ def example_amplitude_constrained_signals():
sig.set_negative_amplitude(2)
sig.validate_negative_amplitude()
except ValueError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# by seeking to validate a negative amplitude that is below its tolerated
# minimum, using an externally supplied amplitude
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.AmplitudeConstrainedSignal(
number_samples=number_intervals,
@@ -776,8 +776,8 @@ def example_amplitude_constrained_signals():
)
sig.validate_negative_amplitude(2)
except ValueError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# ******************************************************************************
@@ -793,7 +793,7 @@ def example_peculiar_errors():
# by providing samples as something other than a list, e.g. tuples
- error_was_triggered = False
+ error_was_raised = False
try:
_ = signal.Signal(
number_samples=number_intervals,
@@ -802,12 +802,12 @@ def example_peculiar_errors():
upper_bounds=None,
)
except TypeError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# by providing an incorrect number of samples
- error_was_triggered = False
+ error_was_raised = False
try:
_ = signal.Signal(
number_samples=number_intervals,
@@ -816,8 +816,8 @@ def example_peculiar_errors():
upper_bounds=None,
)
except ValueError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# **************************************************************************
# **************************************************************************
@@ -830,7 +830,7 @@ def example_peculiar_errors():
upper_bounds = [7 for i in range(number_intervals)]
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.Signal(
number_samples=number_intervals,
@@ -841,12 +841,12 @@ def example_peculiar_errors():
sig.lower_bounds = [random.random() for i in range(number_intervals + 1)]
sig.has_lower_bounds()
except ValueError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# by providing an incorrect number of upper bounds
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.Signal(
number_samples=number_intervals,
@@ -857,12 +857,12 @@ def example_peculiar_errors():
sig.upper_bounds = [random.random() for i in range(number_intervals - 1)]
sig.has_upper_bounds()
except ValueError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# by providing an incorrect number of samples
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.Signal(
number_samples=number_intervals,
@@ -873,12 +873,12 @@ def example_peculiar_errors():
sig.samples = [random.random() for i in range(number_intervals - 1)]
sig.is_signal_fixed()
except ValueError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# by deleting the lower bounds after creating the object
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.NonNegativeRealSignal(number_samples=number_intervals)
sig.lower_bounds = None
@@ -886,12 +886,12 @@ def example_peculiar_errors():
if not sig.are_bounds_nnr():
raise ValueError()
except ValueError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# by providing negative upper bounds (requires even lower lower bounds)
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.NonNegativeRealSignal(number_samples=number_intervals)
sig.is_upper_bounded = True
@@ -899,8 +899,8 @@ def example_peculiar_errors():
if not sig.are_bounds_nnr():
raise ValueError()
except ValueError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# ******************************************************************************
@@ -1016,48 +1016,48 @@ def example_binary_signals():
# by specifying an integrality tolerance greater than or equal to 0.5
- error_was_triggered = False
+ error_was_raised = False
try:
sig.is_signal_binary_only(integrality_tolerance=0.5)
except ValueError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# by specifying an integrality tolerance greater than or equal to 0.5
- error_was_triggered = False
+ error_was_raised = False
try:
sig.is_signal_integer_only(integrality_tolerance=0.5)
except ValueError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# by specifying an integrality tolerance as a tuple
- error_was_triggered = False
+ error_was_raised = False
try:
sig.is_signal_binary_only(integrality_tolerance=(0.5,))
except TypeError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# by specifying an integrality tolerance as a tuple
- error_was_triggered = False
+ error_was_raised = False
try:
sig.is_signal_integer_only(integrality_tolerance=(0.5,))
except TypeError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# by specifying the number of samples as a float
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.BinarySignal(number_samples=float(number_intervals))
except TypeError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# ******************************************************************************
@@ -1159,24 +1159,24 @@ def example_nnr_signals():
# by providing a float as the number of intervals
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.NonNegativeRealSignal(number_samples=float(number_intervals))
except TypeError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# by providing negative lower bounds
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.NonNegativeRealSignal(
number_samples=number_intervals,
lower_bounds=[-1 for i in range(number_intervals)],
)
except ValueError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# by providing samples that are not nnr
@@ -1184,23 +1184,23 @@ def example_nnr_signals():
samples[-1] = -1
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.FixedNonNegativeRealSignal(samples=samples)
except ValueError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# by providing samples as tuples
samples = (random.random() for i in range(number_intervals))
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.FixedNonNegativeRealSignal(samples=samples)
except TypeError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# ******************************************************************************
@@ -1254,21 +1254,21 @@ def example_set_signal():
# by providing an integer instead of a list
- error_was_triggered = False
+ error_was_raised = False
try:
sig.set_signal(samples=3)
except TypeError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# by providing an incorrectly sized list
- error_was_triggered = False
+ error_was_raised = False
try:
sig.set_signal(samples=[2 for i in range(number_intervals + 1)])
except ValueError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# **************************************************************************
@@ -1413,7 +1413,7 @@ def example_bounded_signals():
# by providing upper bounds with an inconsistent number of samples
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.Signal(
number_samples=number_intervals,
@@ -1422,12 +1422,12 @@ def example_bounded_signals():
upper_bounds=[10 for i in range(number_intervals - 1)], # one too few
)
except ValueError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# by providing lower bounds with an inconsistent number of samples
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.Signal(
number_samples=number_intervals,
@@ -1436,12 +1436,12 @@ def example_bounded_signals():
upper_bounds=None,
)
except ValueError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# by providing upper bounds not as a list but as a numeric type
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.Signal(
number_samples=number_intervals,
@@ -1450,12 +1450,12 @@ def example_bounded_signals():
upper_bounds=6,
)
except TypeError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# by providing lower bounds not as a list but as a numeric type
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.Signal(
number_samples=number_intervals,
@@ -1464,8 +1464,8 @@ def example_bounded_signals():
upper_bounds=[5 for i in range(number_intervals)],
)
except TypeError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# by providing upper bounds lower than the lower bounds
@@ -1475,7 +1475,7 @@ def example_bounded_signals():
upper_bounds[-1] = 3
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.Signal(
number_samples=number_intervals,
@@ -1484,8 +1484,8 @@ def example_bounded_signals():
upper_bounds=upper_bounds,
)
except ValueError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# by providing lower bounds higher than the uppper bounds
@@ -1495,7 +1495,7 @@ def example_bounded_signals():
lower_bounds[-1] = 9
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.Signal(
number_samples=number_intervals,
@@ -1504,8 +1504,8 @@ def example_bounded_signals():
upper_bounds=upper_bounds,
)
except ValueError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# ******************************************************************************
@@ -1562,7 +1562,7 @@ def example_free_signals():
# by providing a float as the number of intervals
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.Signal(
number_samples=float(number_intervals),
@@ -1571,8 +1571,8 @@ def example_free_signals():
upper_bounds=None,
)
except TypeError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# ******************************************************************************
@@ -1619,25 +1619,25 @@ def example_fixed_signals():
# by providing a None when creating a FixedSignal
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.FixedSignal(samples=None)
except TypeError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# by providing an empty list
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.FixedSignal(samples=[])
except ValueError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# by providing the number of samples as a float
- error_was_triggered = False
+ error_was_raised = False
try:
sig = signal.Signal(
number_samples=float(number_intervals),
@@ -1646,8 +1646,8 @@ def example_fixed_signals():
upper_bounds=None,
)
except TypeError:
- error_was_triggered = True
- assert error_was_triggered
+ error_was_raised = True
+ assert error_was_raised
# ******************************************************************************
diff --git a/tests/test_data_finance.py b/tests/test_data_finance.py
index 051f3c28bae2631123265ccbd42e3f06c5cd3bb4..0e5b36153c4dcf9200f65b41e26243cb5b31e09e 100644
--- a/tests/test_data_finance.py
+++ b/tests/test_data_finance.py
@@ -651,7 +651,7 @@ class TestDataFinance:
# trigger ValueError
- error_triggered = False
+ error_raised = False
investment_period = analysis_period_span + 1
try:
npv_salvage = present_salvage_value_annuity(
@@ -662,8 +662,8 @@ class TestDataFinance:
analysis_period_span=analysis_period_span,
)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# *********************************************************************
@@ -1197,7 +1197,7 @@ class TestDataFinance:
investment_period = analysis_period_span + 1
- error_triggered = False
+ error_raised = False
try:
residual_value = salvage_value_linear_depreciation(
investment=investment,
@@ -1206,8 +1206,8 @@ class TestDataFinance:
analysis_period_span=analysis_period_span,
)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# *************************************************************************
# *************************************************************************
@@ -1318,78 +1318,78 @@ class TestDataFinance:
# TypeError('The discount rates must be provided as a tuple.')
- error_triggered = False
+ error_raised = False
try:
my_inv = Investment(list(i_t), R_t)
except TypeError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# *********************************************************************
# ValueError('The duration of the period under analysis must be positive.')
- error_triggered = False
+ error_raised = False
try:
my_inv = Investment(tuple())
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# *********************************************************************
# TypeError('The discount rate must be provided as a float.')
- error_triggered = False
+ error_raised = False
try:
my_inv = Investment(None, None, 5, 10)
except TypeError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# *********************************************************************
# ValueError('The discount rate must be in the open interval between 0 and 1.)
- error_triggered = False
+ error_raised = False
try:
my_inv = Investment(None, None, 1.35, 10)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# *********************************************************************
# TypeError('The duration of the period under consideration must be provided as an integer.')
- error_triggered = False
+ error_raised = False
try:
my_inv = Investment(None, None, 0.35, 10.0)
except TypeError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# *********************************************************************
# ValueError('The duration of the period under analysis must be positive.)
- error_triggered = False
+ error_raised = False
try:
my_inv = Investment(None, None, 0.35, 0)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# *********************************************************************
# TypeError('The net cash flows must be provided as a list.')
- error_triggered = False
+ error_raised = False
try:
my_inv = Investment(i_t, tuple(R_t))
except TypeError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# *********************************************************************
diff --git a/tests/test_data_utils.py b/tests/test_data_utils.py
index d653fe46c327ec833a8bae0b3f50ceab8b7cd2a2..27781c31e05273a8b62aaa911e4e7ceabe9318b7 100644
--- a/tests/test_data_utils.py
+++ b/tests/test_data_utils.py
@@ -140,7 +140,7 @@ class TestDataUtils:
# raise exception
- error_triggered = False
+ error_raised = False
time_interval_durations.pop(0)
try:
new_profile = utils.create_profile_using_time_weighted_state(
@@ -151,8 +151,8 @@ class TestDataUtils:
states_correlate_profile=True,
)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# *********************************************************************
# *********************************************************************
@@ -333,14 +333,14 @@ class TestDataUtils:
# use zero iterations to force an error
- error_triggered = False
+ error_raised = False
try:
new_key = utils.generate_pseudo_unique_key(
key_list=key_list, max_iterations=0
)
except Exception:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# use a seed number to trigger more iterations
diff --git a/tests/test_dhn.py b/tests/test_dhn.py
index 11a9382ca3ad2e1b8061f7529016262144b85e13..e44b3781f232780fd53f112fb3fb610ad78b1971 100644
--- a/tests/test_dhn.py
+++ b/tests/test_dhn.py
@@ -654,7 +654,7 @@ class TestDistrictHeatingNetwork:
# # single pipe, external cost, offset
-# error_triggered = False
+# error_raised = False
# try:
# pipe_trench_obj = PipeTrench(name='hello',
# trenches={0: trench_tech},
@@ -665,12 +665,12 @@ class TestDistrictHeatingNetwork:
# minimum_cost_offset=external_cost,
# validate=True)
# except TypeError:
-# error_triggered = True
-# assert error_triggered
+# error_raised = True
+# assert error_raised
# # use list as minimum cost offset
-# error_triggered = False
+# error_raised = False
# try:
# pipe_trench_obj = PipeTrench(name='hello',
# trenches={0: trench_tech},
@@ -684,8 +684,8 @@ class TestDistrictHeatingNetwork:
# ),
# validate=True)
# except TypeError:
-# error_triggered = True
-# assert error_triggered
+# error_raised = True
+# assert error_raised
# #**************************************************************************
# #**************************************************************************
@@ -754,7 +754,7 @@ class TestDistrictHeatingNetwork:
# # single pipe, external cost, offset
-# error_triggered = False
+# error_raised = False
# try:
# pipe_trench_obj = PipeTrench(name='hello',
# trenches={0: trench_tech},
@@ -765,12 +765,12 @@ class TestDistrictHeatingNetwork:
# minimum_cost_offset=external_cost,
# validate=True)
# except TypeError:
-# error_triggered = True
-# assert error_triggered
+# error_raised = True
+# assert error_raised
# # use list as minimum cost offset
-# error_triggered = False
+# error_raised = False
# try:
# pipe_trench_obj = PipeTrench(name='hello',
# trenches={0: trench_tech},
@@ -784,8 +784,8 @@ class TestDistrictHeatingNetwork:
# ),
# validate=True)
# except TypeError:
-# error_triggered = True
-# assert error_triggered
+# error_raised = True
+# assert error_raised
# #**************************************************************************
# #**************************************************************************
diff --git a/tests/test_dhn_utils.py b/tests/test_dhn_utils.py
index 0b75ff08ed0a380f8a7e10b5d13f76183b224039..e5be17ccb79d37080013a511c977696a2181e8ab 100644
--- a/tests/test_dhn_utils.py
+++ b/tests/test_dhn_utils.py
@@ -20,7 +20,6 @@ from topupheat.common.fluids import FluidDatabase # , Fluid
# *****************************************************************************
# *****************************************************************************
-
class TestDistrictHeatingNetworkUtils:
# *************************************************************************
# *************************************************************************
@@ -528,7 +527,7 @@ class TestDistrictHeatingNetworkUtils:
# update the nodes
network.add_node(0, x=55, y=12)
network.add_node(2, x=55.01, y=12.01)
-
+
# *********************************************************************
utils.summarise_network_by_pipe_technology(network, False)
diff --git a/tests/test_esipp.py b/tests/test_esipp.py
new file mode 100644
index 0000000000000000000000000000000000000000..570c6edb5b1ecc2efbf51ea64aba2037b00f8f97
--- /dev/null
+++ b/tests/test_esipp.py
@@ -0,0 +1,241 @@
+# imports
+
+# local
+# import numpy as np
+# import networkx as nx
+from src.topupopt.problems.esipp.problem import InfrastructurePlanningProblem
+from src.topupopt.problems.esipp.network import Network
+from src.topupopt.problems.esipp.time import EconomicTimeFrame
+from src.topupopt.problems.esipp.blocks.prices import NODE_PRICE_OTHER
+
+# *****************************************************************************
+# *****************************************************************************
+
+def check_problem_size(ipp: InfrastructurePlanningProblem, nc, nv, nnz):
+
+ assert ipp.results["Problem"][0]["Number of constraints"] == nc # should be 80
+ assert ipp.results["Problem"][0]["Number of variables"] == nv # should be 84
+ assert ipp.results["Problem"][0]["Number of nonzeros"] == nnz
+
+# *****************************************************************************
+# *****************************************************************************
+
+def build_solve_ipp(
+ solver: str = 'glpk',
+ solver_options: dict = None,
+ use_sos_arcs: bool = False,
+ use_sos_arc_groups: bool = False,
+ arc_sos_weight_key: str = InfrastructurePlanningProblem.SOS1_ARC_WEIGHTS_NONE,
+ arc_use_real_variables_if_possible: bool = False,
+ use_sos_sense: bool = False,
+ sense_sos_weight_key: int = (
+ InfrastructurePlanningProblem.SOS1_SENSE_WEIGHT_NOMINAL_HIGHER
+ ),
+ sense_use_real_variables_if_possible: bool = False,
+ sense_use_arc_interfaces: bool = False,
+ perform_analysis: bool = False,
+ plot_results: bool = False,
+ print_solver_output: bool = False,
+ time_frame: EconomicTimeFrame = None,
+ networks: dict = None,
+ converters: dict = None,
+ static_losses_mode=None,
+ mandatory_arcs: list = None,
+ max_number_parallel_arcs: dict = None,
+ arc_groups_dict: dict = None,
+ init_aux_sets: bool = False,
+ # discount_rates: dict = None,
+ assessment_weights: dict = None,
+ simplify_problem: bool = False,
+ use_prices_block: bool = False,
+ node_price_model: int = NODE_PRICE_OTHER
+):
+
+ if type(assessment_weights) != dict:
+ assessment_weights = {} # default
+
+ if type(converters) != dict:
+ converters = {}
+
+ # time weights
+
+ # relative weight of time period
+
+ # one interval twice as long as the average is worth twice
+ # one interval half as long as the average is worth half
+
+ # time_weights = [
+ # [time_period_duration/average_time_interval_duration
+ # for time_period_duration in intraperiod_time_interval_duration]
+ # for p in range(number_periods)]
+
+ time_weights = None # nothing yet
+
+ normalised_time_interval_duration = None # nothing yet
+
+ # create problem object
+
+ ipp = InfrastructurePlanningProblem(
+ # discount_rates=discount_rates,
+ time_frame=time_frame,
+ # reporting_periods=time_frame.reporting_periods,
+ # time_intervals=time_frame.time_interval_durations,
+ time_weights=time_weights,
+ normalised_time_interval_duration=normalised_time_interval_duration,
+ assessment_weights=assessment_weights,
+ use_prices_block=use_prices_block,
+ node_price_model=node_price_model
+ )
+
+ # add networks and systems
+
+ for netkey, net in networks.items():
+ ipp.add_network(network_key=netkey, network=net)
+
+ # add converters
+
+ for cvtkey, cvt in converters.items():
+ ipp.add_converter(converter_key=cvtkey, converter=cvt)
+
+ # define arcs as mandatory
+
+ if type(mandatory_arcs) == list:
+ for full_arc_key in mandatory_arcs:
+ ipp.make_arc_mandatory(full_arc_key[0], full_arc_key[1:])
+
+ # if make_all_arcs_mandatory:
+
+ # for network_key in ipp.networks:
+
+ # for arc_key in ipp.networks[network_key].edges(keys=True):
+
+ # # preexisting arcs are no good
+
+ # if ipp.networks[network_key].edges[arc_key][
+ # Network.KEY_ARC_TECH].has_been_selected():
+
+ # continue
+
+ # ipp.make_arc_mandatory(network_key, arc_key)
+
+ # set up the use of sos for arc selection
+
+ if use_sos_arcs:
+ for network_key in ipp.networks:
+ for arc_key in ipp.networks[network_key].edges(keys=True):
+ if (
+ ipp.networks[network_key]
+ .edges[arc_key][Network.KEY_ARC_TECH]
+ .has_been_selected()
+ ):
+ # skip arcs that have already been selected (pre-existing)
+ continue
+
+ ipp.use_sos1_for_arc_selection(
+ network_key,
+ arc_key,
+ use_real_variables_if_possible=(
+ arc_use_real_variables_if_possible
+ ),
+ sos1_weight_method=arc_sos_weight_key,
+ )
+
+ # set up the use of sos for flow sense determination
+
+ if use_sos_sense:
+ for network_key in ipp.networks:
+ for arc_key in ipp.networks[network_key].edges(keys=True):
+ if not ipp.networks[network_key].edges[arc_key][
+ Network.KEY_ARC_UND
+ ]:
+ continue
+
+ ipp.use_sos1_for_flow_senses(
+ network_key,
+ arc_key,
+ use_real_variables_if_possible=(
+ sense_use_real_variables_if_possible
+ ),
+ use_interface_variables=sense_use_arc_interfaces,
+ sos1_weight_method=sense_sos_weight_key,
+ )
+
+ elif sense_use_arc_interfaces: # set up the use of arc interfaces w/o sos1
+ for network_key in ipp.networks:
+ for arc_key in ipp.networks[network_key].edges(keys=True):
+ if (
+ ipp.networks[network_key]
+ .edges[arc_key][Network.KEY_ARC_TECH]
+ .has_been_selected()
+ ):
+ continue
+
+ ipp.use_interface_variables_for_arc_selection(network_key, arc_key)
+
+ # static losses
+
+ if static_losses_mode == ipp.STATIC_LOSS_MODE_ARR:
+ ipp.place_static_losses_arrival_node()
+
+ elif static_losses_mode == ipp.STATIC_LOSS_MODE_DEP:
+ ipp.place_static_losses_departure_node()
+
+ elif static_losses_mode == ipp.STATIC_LOSS_MODE_US:
+ ipp.place_static_losses_upstream()
+
+ elif static_losses_mode == ipp.STATIC_LOSS_MODE_DS:
+ ipp.place_static_losses_downstream()
+
+ else:
+ raise ValueError("Unknown static loss modelling mode.")
+
+ # *********************************************************************
+
+ # groups
+
+ if type(arc_groups_dict) != type(None):
+ for key in arc_groups_dict:
+ ipp.create_arc_group(
+ arc_groups_dict[key],
+ use_sos1=use_sos_arc_groups,
+ sos1_weight_method=arc_sos_weight_key
+ )
+
+ # *********************************************************************
+
+ # maximum number of parallel arcs
+
+ for key in max_number_parallel_arcs:
+ ipp.set_maximum_number_parallel_arcs(
+ network_key=key[0],
+ node_a=key[1],
+ node_b=key[2],
+ limit=max_number_parallel_arcs[key],
+ )
+
+ # *********************************************************************
+
+ if simplify_problem:
+ ipp.simplify_peak_total_assessments()
+
+ # *********************************************************************
+
+ # instantiate (disable the default case v-a-v fixed losses)
+
+ # ipp.instantiate(place_fixed_losses_upstream_if_possible=False)
+
+ ipp.instantiate(initialise_ancillary_sets=init_aux_sets)
+
+ # optimise
+ ipp.optimise(
+ solver_name=solver,
+ solver_options=solver_options,
+ output_options={},
+ print_solver_output=print_solver_output,
+ )
+ # ipp.instance.pprint()
+ # return the problem object
+ return ipp
+
+# *****************************************************************************
+# *****************************************************************************
\ No newline at end of file
diff --git a/tests/test_esipp_network.py b/tests/test_esipp_network.py
index d731bb963f73bd24d1cd08fac3ff5f34a065f24e..fca1dad0fb2ad1f23d5758878f615024f1760cef 100644
--- a/tests/test_esipp_network.py
+++ b/tests/test_esipp_network.py
@@ -1,23 +1,16 @@
# imports
# standard
-
+import pytest
import random
-
from networkx import binomial_tree, MultiDiGraph
# local
-
from src.topupopt.problems.esipp.network import Arcs, Network
-
from src.topupopt.problems.esipp.network import ArcsWithoutLosses
-
from src.topupopt.problems.esipp.network import ArcsWithoutProportionalLosses
-
from src.topupopt.problems.esipp.network import ArcsWithoutStaticLosses
-
from src.topupopt.problems.esipp.resource import ResourcePrice
-
from src.topupopt.data.misc.utils import generate_pseudo_unique_key
# *****************************************************************************
@@ -168,7 +161,7 @@ class TestNetwork:
# TypeError: The static losses should be given as a dict or None.
- error_triggered = False
+ error_raised = False
try:
_ = Arcs(
name="any",
@@ -185,13 +178,13 @@ class TestNetwork:
validate=True,
)
except TypeError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# ValueError('The static losses should be specified for each arc
# option.')
- error_triggered = False
+ error_raised = False
try:
_ = Arcs(
name="any",
@@ -212,12 +205,12 @@ class TestNetwork:
validate=True,
)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# TypeError('The static losses must be specified via a list of lists.')
- error_triggered = False
+ error_raised = False
try:
_ = Arcs(
name="any",
@@ -234,13 +227,13 @@ class TestNetwork:
validate=True,
)
except TypeError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# ValueError('The static loss values are inconsistent with the number '
# 'of options, scenarios and intervals.')
- error_triggered = False
+ error_raised = False
try:
arc_tech = Arcs(
name="any",
@@ -267,12 +260,12 @@ class TestNetwork:
],
)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# TypeError('The static losses were not provided as numbers.')
- error_triggered = False
+ error_raised = False
try:
_ = Arcs(
name="any",
@@ -291,12 +284,12 @@ class TestNetwork:
validate=True,
)
except TypeError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# ValueError('The static losses must be positive or zero.')
- error_triggered = False
+ error_raised = False
try:
_ = Arcs(
name="any",
@@ -315,12 +308,12 @@ class TestNetwork:
validate=True,
)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# TypeError: The static loss dict keys must be tuples
- error_triggered = False
+ error_raised = False
try:
_ = Arcs(
name="hey",
@@ -334,12 +327,12 @@ class TestNetwork:
validate=True,
)
except TypeError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# ValueError( 'The static loss dict keys must be tuples of size 3.')
- error_triggered = False
+ error_raised = False
try:
_ = Arcs(
name="hey",
@@ -353,12 +346,12 @@ class TestNetwork:
validate=True,
)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# TypeError(The staticl osses should be given as a dict or None.')
- error_triggered = False
+ error_raised = False
try:
_ = Arcs(
name="hey",
@@ -372,14 +365,14 @@ class TestNetwork:
validate=True,
)
except TypeError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# ValueError(
# 'No static loss values were provided. There should be one'+
# ' value per option, scenario and time interval.')
- error_triggered = False
+ error_raised = False
try:
_ = Arcs(
name="hey",
@@ -393,8 +386,8 @@ class TestNetwork:
validate=True,
)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# *************************************************************************
# *************************************************************************
@@ -616,7 +609,7 @@ class TestNetwork:
# TypeError('The name attribute is not hashable.')
- error_triggered = False
+ error_raised = False
try:
_ = Arcs(
name=[1, 2, 3],
@@ -630,12 +623,12 @@ class TestNetwork:
validate=True,
)
except TypeError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# TypeError:The efficiency dict keys must be (scenario, interval) tuples
- error_triggered = False
+ error_raised = False
try:
_ = Arcs(
name="hey",
@@ -649,12 +642,12 @@ class TestNetwork:
validate=True,
)
except TypeError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# ValueError( 'The efficiency dict keys must be tuples of size 2.')
- error_triggered = False
+ error_raised = False
try:
_ = Arcs(
name="hey",
@@ -668,12 +661,12 @@ class TestNetwork:
validate=True,
)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# TypeError(The efficiency should be given as a dict or None.')
- error_triggered = False
+ error_raised = False
try:
_ = Arcs(
name="hey",
@@ -687,13 +680,13 @@ class TestNetwork:
validate=True,
)
except TypeError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# TypeError('The reverse efficiency has to match the nominal'+
# ' one when there are no proportional losses.')
- error_triggered = False
+ error_raised = False
try:
_ = Arcs(
name="hey",
@@ -707,12 +700,12 @@ class TestNetwork:
validate=True,
)
except TypeError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# TypeError:'The reverse efficiency should be given as a dict or None.'
- error_triggered = False
+ error_raised = False
try:
_ = Arcs(
name="hey",
@@ -726,14 +719,14 @@ class TestNetwork:
validate=True,
)
except TypeError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# ValueError(
# 'No efficiency values were provided. There should be '+
# 'one value per scenario and time interval.')
- error_triggered = False
+ error_raised = False
try:
_ = Arcs(
name="hey",
@@ -747,12 +740,12 @@ class TestNetwork:
validate=True,
)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# ValueError: The keys for the efficiency dicts do not match.
- error_triggered = False
+ error_raised = False
try:
_ = Arcs(
name="hey",
@@ -769,12 +762,12 @@ class TestNetwork:
validate=True,
)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# TypeError: Efficiency values must be provided as numeric types.
- error_triggered = False
+ error_raised = False
try:
_ = Arcs(
name="hey",
@@ -791,12 +784,12 @@ class TestNetwork:
validate=True,
)
except TypeError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# ValueError('Efficiency values must be positive.')
- error_triggered = False
+ error_raised = False
try:
_ = Arcs(
name="hey",
@@ -812,12 +805,12 @@ class TestNetwork:
validate=True,
)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# TypeError('The capacity should be given as a list or tuple.')
- error_triggered = False
+ error_raised = False
try:
_ = Arcs(
name="hey",
@@ -831,12 +824,12 @@ class TestNetwork:
validate=True,
)
except TypeError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# TypeError: The minimum cost values should be given as a list or tuple
- error_triggered = False
+ error_raised = False
try:
_ = Arcs(
name="hey",
@@ -850,12 +843,12 @@ class TestNetwork:
validate=True,
)
except TypeError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# TypeError: The specific capacity cost was not given as a numeric type
- error_triggered = False
+ error_raised = False
try:
_ = Arcs(
name="hey",
@@ -869,12 +862,12 @@ class TestNetwork:
validate=True,
)
except TypeError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# ValueError:The number of capacity and minimum cost entries must match
- error_triggered = False
+ error_raised = False
try:
_ = Arcs(
name="hey",
@@ -888,13 +881,13 @@ class TestNetwork:
validate=True,
)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# ValueError: No entries for capacity and minimum cost were provided.
# At least one option should be provided.
- error_triggered = False
+ error_raised = False
try:
_ = Arcs(
name="hey",
@@ -908,13 +901,13 @@ class TestNetwork:
validate=True,
)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# ValueError: No entries for efficiency were provided. There should be
# one entry per time interval.
- error_triggered = False
+ error_raised = False
try:
_ = Arcs(
name="hey",
@@ -928,8 +921,8 @@ class TestNetwork:
validate=True,
)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# ValueError('The number of efficiency values must match the number of
# time intervals.')
@@ -950,7 +943,7 @@ class TestNetwork:
validate=True,
)
- error_triggered = False
+ error_raised = False
try:
arc_tech.validate_sizes(
number_options=number_options,
@@ -960,13 +953,13 @@ class TestNetwork:
],
)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# ValueError('The number of efficiency values must match the number of
# time intervals.')
- error_triggered = False
+ error_raised = False
try:
arc_tech = Arcs(
name="hey",
@@ -995,8 +988,8 @@ class TestNetwork:
],
)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# ValueError('The number of capacity values must match the number of
# options.')
@@ -1013,7 +1006,7 @@ class TestNetwork:
validate=True,
)
- error_triggered = False
+ error_raised = False
try:
arc_tech.validate_sizes(
number_options=number_options,
@@ -1023,8 +1016,8 @@ class TestNetwork:
],
)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# ValueError: The minimum cost values are inconsistent with the number
# of options.
@@ -1041,7 +1034,7 @@ class TestNetwork:
validate=True,
)
- error_triggered = False
+ error_raised = False
try:
arc_tech.validate_sizes(
number_options=number_options,
@@ -1051,12 +1044,12 @@ class TestNetwork:
],
)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# TypeError('Efficiency values must be provided as numeric types.')
- error_triggered = False
+ error_raised = False
try:
_ = Arcs(
name="hey",
@@ -1072,12 +1065,12 @@ class TestNetwork:
validate=True,
)
except TypeError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# ValueError('Efficiency values must be positive.')
- error_triggered = False
+ error_raised = False
try:
_ = Arcs(
name="hey",
@@ -1094,12 +1087,12 @@ class TestNetwork:
validate=True,
)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# TypeError('Capacity values must be provided as numeric types.')
- error_triggered = False
+ error_raised = False
try:
_ = Arcs(
name="hey",
@@ -1113,12 +1106,12 @@ class TestNetwork:
validate=True,
)
except TypeError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# ValueError('Capacity values must be positive.')
- error_triggered = False
+ error_raised = False
try:
_ = Arcs(
name="hey",
@@ -1134,12 +1127,12 @@ class TestNetwork:
validate=True,
)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# TypeError('Minimum cost values must be provided as numeric types.')
- error_triggered = False
+ error_raised = False
try:
_ = Arcs(
name="hey",
@@ -1153,12 +1146,12 @@ class TestNetwork:
validate=True,
)
except TypeError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# ValueError('Minimum cost values must be positive or zero.')
- error_triggered = False
+ error_raised = False
try:
_ = Arcs(
name="hey",
@@ -1172,13 +1165,13 @@ class TestNetwork:
validate=True,
)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# TypeError('The information about capacities being instantaneous or not
# should be given as a boolean variable.')
- error_triggered = False
+ error_raised = False
try:
_ = Arcs(
name="hey",
@@ -1192,8 +1185,8 @@ class TestNetwork:
validate=True,
)
except TypeError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# *********************************************************************
# *********************************************************************
@@ -1278,7 +1271,7 @@ class TestNetwork:
],
)
- net.add_import_node(node_key="G", prices={(0, 0, 0): imp_resource_price})
+ net.add_import_node("G", prices={(0, 0, 0): imp_resource_price})
# add export node
@@ -1290,21 +1283,17 @@ class TestNetwork:
],
)
- net.add_export_node(node_key="H", prices={(0, 0, 0): exp_resource_price})
+ net.add_export_node("H", prices={(0, 0, 0): exp_resource_price})
- net.add_waypoint_node(node_key="Z")
+ net.add_waypoint_node("Z")
base_flow = {(i, j): random.random() for i in range(3) for j in range(4)}
- net.add_source_sink_node(node_key="Y", base_flow=base_flow)
+ net.add_source_sink_node("Y", base_flow=base_flow)
base_flow[(2, 3)] = random.random()
- net.modify_network_node(
- node_key="Y", node_data={net.KEY_NODE_BASE_FLOW: base_flow}
- )
-
- net.identify_node_types()
+ net.modify_node("Y", **{net.KEY_NODE_BASE_FLOW: base_flow})
assert "Z" in net.waypoint_nodes
@@ -1415,35 +1404,35 @@ class TestNetwork:
# add isolated import node
- net.add_import_node(node_key="I_iso", prices={(0, 0, 0): resource_price})
+ net.add_import_node("I_iso", prices={(0, 0, 0): resource_price})
# add import node with outgoing arcs
- net.add_import_node(node_key="I", prices={(0, 0, 0): resource_price})
+ net.add_import_node("I", prices={(0, 0, 0): resource_price})
# add isolated export node
- net.add_import_node(node_key="E_iso", prices={(0, 0, 0): resource_price})
+ net.add_import_node("E_iso", prices={(0, 0, 0): resource_price})
# add export node with incoming arcs
- net.add_export_node(node_key="E", prices={(0, 0, 0): resource_price})
+ net.add_export_node("E", prices={(0, 0, 0): resource_price})
# add isolated normal node
- net.add_source_sink_node(node_key="A_iso", base_flow=base_flow)
+ net.add_source_sink_node("A_iso", base_flow=base_flow)
# add normal node with incoming arcs
- net.add_source_sink_node(node_key="A_in", base_flow=base_flow)
+ net.add_source_sink_node("A_in", base_flow=base_flow)
# add normal node with outgoing arcs
- net.add_source_sink_node(node_key="A_out", base_flow=base_flow)
+ net.add_source_sink_node("A_out", base_flow=base_flow)
# add normal node with incoming and outgoing arcs
- net.add_source_sink_node(node_key="A", base_flow=base_flow)
+ net.add_source_sink_node("A", base_flow=base_flow)
# *********************************************************************
@@ -1461,19 +1450,18 @@ class TestNetwork:
# change I_iso to regular: okay
- net.modify_network_node(
- node_key="I_iso",
- node_data={
- net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_SOURCE_SINK,
+ net.modify_node(
+ "I_iso",
+ **{
net.KEY_NODE_BASE_FLOW: base_flow,
},
)
# reverse: okay
- net.modify_network_node(
- node_key="I_iso",
- node_data={
+ net.modify_node(
+ "I_iso",
+ **{
net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_IMP,
net.KEY_NODE_PRICES: resource_price,
},
@@ -1481,9 +1469,9 @@ class TestNetwork:
# change I_iso to export: okay
- net.modify_network_node(
- node_key="I_iso",
- node_data={
+ net.modify_node(
+ "I_iso",
+ **{
net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_EXP,
net.KEY_NODE_PRICES: resource_price,
},
@@ -1491,9 +1479,9 @@ class TestNetwork:
# reverse: okay
- net.modify_network_node(
- node_key="I_iso",
- node_data={
+ net.modify_node(
+ "I_iso",
+ **{
net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_IMP,
net.KEY_NODE_PRICES: resource_price,
},
@@ -1501,15 +1489,15 @@ class TestNetwork:
# change I_iso to waypoint: okay
- net.modify_network_node(
- node_key="I_iso", node_data={net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_WAY}
+ net.modify_node(
+ "I_iso"
)
# reverse: okay
- net.modify_network_node(
- node_key="I_iso",
- node_data={
+ net.modify_node(
+ "I_iso",
+ **{
net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_IMP,
net.KEY_NODE_PRICES: resource_price,
},
@@ -1519,19 +1507,18 @@ class TestNetwork:
# change E_iso to regular: okay
- net.modify_network_node(
- node_key="E_iso",
- node_data={
- net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_SOURCE_SINK,
+ net.modify_node(
+ "E_iso",
+ **{
net.KEY_NODE_BASE_FLOW: base_flow,
},
)
# reverse: okay
- net.modify_network_node(
- node_key="E_iso",
- node_data={
+ net.modify_node(
+ "E_iso",
+ **{
net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_EXP,
net.KEY_NODE_PRICES: resource_price,
},
@@ -1539,9 +1526,9 @@ class TestNetwork:
# change E_iso to import: okay
- net.modify_network_node(
- node_key="E_iso",
- node_data={
+ net.modify_node(
+ "E_iso",
+ **{
net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_IMP,
net.KEY_NODE_PRICES: resource_price,
},
@@ -1549,9 +1536,9 @@ class TestNetwork:
# reverse: okay
- net.modify_network_node(
- node_key="E_iso",
- node_data={
+ net.modify_node(
+ "E_iso",
+ **{
net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_EXP,
net.KEY_NODE_PRICES: resource_price,
},
@@ -1559,15 +1546,15 @@ class TestNetwork:
# change E_iso to waypoint: okay
- net.modify_network_node(
- node_key="E_iso", node_data={net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_WAY}
+ net.modify_node(
+ "E_iso"
)
# reverse: okay
- net.modify_network_node(
- node_key="E_iso",
- node_data={
+ net.modify_node(
+ "E_iso",
+ **{
net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_EXP,
net.KEY_NODE_PRICES: resource_price,
},
@@ -1577,9 +1564,9 @@ class TestNetwork:
# change A_iso to export: okay
- net.modify_network_node(
- node_key="A_iso",
- node_data={
+ net.modify_node(
+ "A_iso",
+ **{
net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_EXP,
net.KEY_NODE_PRICES: resource_price,
},
@@ -1587,19 +1574,18 @@ class TestNetwork:
# reverse: okay
- net.modify_network_node(
- node_key="A_iso",
- node_data={
- net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_SOURCE_SINK,
+ net.modify_node(
+ "A_iso",
+ **{
net.KEY_NODE_BASE_FLOW: base_flow,
},
)
# change A_iso to import: okay
- net.modify_network_node(
- node_key="A_iso",
- node_data={
+ net.modify_node(
+ "A_iso",
+ **{
net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_IMP,
net.KEY_NODE_PRICES: resource_price,
},
@@ -1607,26 +1593,24 @@ class TestNetwork:
# reverse: okay
- net.modify_network_node(
- node_key="A_iso",
- node_data={
- net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_SOURCE_SINK,
+ net.modify_node(
+ "A_iso",
+ **{
net.KEY_NODE_BASE_FLOW: base_flow,
},
)
# change A_iso to waypoint: okay
- net.modify_network_node(
- node_key="A_iso", node_data={net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_WAY}
+ net.modify_node(
+ "A_iso"
)
# reverse: okay
- net.modify_network_node(
- node_key="A_iso",
- node_data={
- net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_SOURCE_SINK,
+ net.modify_node(
+ "A_iso",
+ **{
net.KEY_NODE_BASE_FLOW: base_flow,
},
)
@@ -1635,19 +1619,18 @@ class TestNetwork:
# change I to regular: okay
- net.modify_network_node(
- node_key="I",
- node_data={
- net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_SOURCE_SINK,
+ net.modify_node(
+ "I",
+ **{
net.KEY_NODE_BASE_FLOW: base_flow,
},
)
# reverse: okay
- net.modify_network_node(
- node_key="I",
- node_data={
+ net.modify_node(
+ "I",
+ **{
net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_IMP,
net.KEY_NODE_PRICES: resource_price,
},
@@ -1655,15 +1638,15 @@ class TestNetwork:
# change I to waypoint: okay
- net.modify_network_node(
- node_key="I", node_data={net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_WAY}
+ net.modify_node(
+ "I"
)
# reverse: okay
- net.modify_network_node(
- node_key="I",
- node_data={
+ net.modify_node(
+ "I",
+ **{
net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_IMP,
net.KEY_NODE_PRICES: resource_price,
},
@@ -1673,19 +1656,18 @@ class TestNetwork:
# change E to regular: okay
- net.modify_network_node(
- node_key="E",
- node_data={
- net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_SOURCE_SINK,
+ net.modify_node(
+ "E",
+ **{
net.KEY_NODE_BASE_FLOW: base_flow,
},
)
# reverse: okay
- net.modify_network_node(
- node_key="E",
- node_data={
+ net.modify_node(
+ "E",
+ **{
net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_EXP,
net.KEY_NODE_PRICES: resource_price,
},
@@ -1693,15 +1675,15 @@ class TestNetwork:
# change E to waypoint: okay
- net.modify_network_node(
- node_key="E", node_data={net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_WAY}
+ net.modify_node(
+ "E"
)
# reverse: okay
- net.modify_network_node(
- node_key="E",
- node_data={
+ net.modify_node(
+ "E",
+ **{
net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_EXP,
net.KEY_NODE_PRICES: resource_price,
},
@@ -1711,9 +1693,9 @@ class TestNetwork:
# change A_in to export: okay
- net.modify_network_node(
- node_key="A_in",
- node_data={
+ net.modify_node(
+ "A_in",
+ **{
net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_EXP,
net.KEY_NODE_PRICES: resource_price,
},
@@ -1721,26 +1703,24 @@ class TestNetwork:
# reverse: okay
- net.modify_network_node(
- node_key="A_in",
- node_data={
- net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_SOURCE_SINK,
+ net.modify_node(
+ "A_in",
+ **{
net.KEY_NODE_BASE_FLOW: base_flow,
},
)
# change A_in to waypoint: okay
- net.modify_network_node(
- node_key="A_in", node_data={net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_WAY}
+ net.modify_node(
+ "A_in", **{net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_WAY}
)
# reverse: okay
- net.modify_network_node(
- node_key="A_in",
- node_data={
- net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_SOURCE_SINK,
+ net.modify_node(
+ "A_in",
+ **{
net.KEY_NODE_BASE_FLOW: base_flow,
},
)
@@ -1749,9 +1729,9 @@ class TestNetwork:
# change A_out to import: okay
- net.modify_network_node(
- node_key="A_out",
- node_data={
+ net.modify_node(
+ "A_out",
+ **{
net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_IMP,
net.KEY_NODE_PRICES: resource_price,
},
@@ -1759,26 +1739,24 @@ class TestNetwork:
# reverse: okay
- net.modify_network_node(
- node_key="A_out",
- node_data={
- net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_SOURCE_SINK,
+ net.modify_node(
+ "A_out",
+ **{
net.KEY_NODE_BASE_FLOW: base_flow,
},
)
# change A_out to waypoint: okay
- net.modify_network_node(
- node_key="A_out", node_data={net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_WAY}
+ net.modify_node(
+ "A_out", **{net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_WAY}
)
# reverse: okay
- net.modify_network_node(
- node_key="A_out",
- node_data={
- net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_SOURCE_SINK,
+ net.modify_node(
+ "A_out",
+ **{
net.KEY_NODE_BASE_FLOW: base_flow,
},
)
@@ -1787,106 +1765,104 @@ class TestNetwork:
# change I to export: fail
- error_triggered = False
+ error_raised = False
try:
- net.modify_network_node(
- node_key="I",
- node_data={
+ net.modify_node(
+ "I",
+ **{
net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_EXP,
net.KEY_NODE_PRICES: resource_price,
},
)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# change E to import: fail
- error_triggered = False
+ error_raised = False
try:
- net.modify_network_node(
- node_key="E",
- node_data={
+ net.modify_node(
+ "E",
+ **{
net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_IMP,
net.KEY_NODE_PRICES: resource_price,
},
)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# change A_out to export: fail
- error_triggered = False
+ error_raised = False
try:
- net.modify_network_node(
- node_key="A_out",
- node_data={
+ net.modify_node(
+ "A_out",
+ **{
net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_EXP,
net.KEY_NODE_PRICES: resource_price,
},
)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# change A_in to import: fail
- error_triggered = False
+ error_raised = False
try:
- net.modify_network_node(
- node_key="A_in",
- node_data={
+ net.modify_node(
+ "A_in",
+ **{
net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_IMP,
net.KEY_NODE_PRICES: resource_price,
},
)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# change A to export: fail
- error_triggered = False
+ error_raised = False
try:
- net.modify_network_node(
- node_key="A",
- node_data={
+ net.modify_node(
+ "A",
+ **{
net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_EXP,
net.KEY_NODE_PRICES: resource_price,
},
)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# change A to import: fail
- error_triggered = False
+ error_raised = False
try:
- net.modify_network_node(
- node_key="A",
- node_data={
+ net.modify_node(
+ "A",
+ **{
net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_IMP,
net.KEY_NODE_PRICES: resource_price,
},
)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# *********************************************************************
# try to modify a non-existent node
- error_triggered = False
+ error_raised = False
try:
- net.modify_network_node(
- node_key="ABCD", node_data={net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_WAY}
- )
+ net.modify_node("ABCD")
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# *********************************************************************
@@ -1925,28 +1901,24 @@ class TestNetwork:
# add import node I
- net.add_import_node(node_key="I", prices={(0, 0, 0): resource_price})
+ net.add_import_node("I", prices={(0, 0, 0): resource_price})
# add export node E
- net.add_export_node(node_key="E", prices={(0, 0, 0): resource_price})
+ net.add_export_node("E", prices={(0, 0, 0): resource_price})
# add regular node A
- net.add_source_sink_node(node_key="A", base_flow=base_flow)
+ net.add_source_sink_node("A", base_flow=base_flow)
# add regular node B
- net.add_source_sink_node(node_key="B", base_flow=base_flow)
+ net.add_source_sink_node("B", base_flow=base_flow)
# add a valid import-export arc
net.add_directed_arc(node_key_a="I", node_key_b="E", arcs=lossless_arcs)
- # identify the nodes and validate
-
- net.identify_node_types()
-
# *********************************************************************
# *********************************************************************
@@ -1954,57 +1926,57 @@ class TestNetwork:
# directed arcs cannot start in an export node: E -> B
- error_triggered = False
+ error_raised = False
try:
net.add_directed_arc(node_key_a="E", node_key_b="B", arcs=lossless_arcs)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# directed arcs cannot end on an import node: A -> I
- error_triggered = False
+ error_raised = False
try:
net.add_directed_arc(node_key_a="A", node_key_b="I", arcs=lossless_arcs)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# import-export nodes cannot have static losses
- error_triggered = False
+ error_raised = False
try:
net.add_directed_arc(node_key_a="I", node_key_b="E", arcs=lossy_arcs)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# undirected arcs cannot involve import nor export nodes
- error_triggered = False
+ error_raised = False
try:
net.add_undirected_arc(node_key_a="I", node_key_b="A", arcs=lossless_arcs)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# undirected arcs cannot involve import nor export nodes
- error_triggered = False
+ error_raised = False
try:
net.add_undirected_arc(node_key_a="B", node_key_b="E", arcs=lossless_arcs)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# undirected arcs cannot involve import nor export nodes
- error_triggered = False
+ error_raised = False
try:
net.add_undirected_arc(node_key_a="I", node_key_b="E", arcs=lossy_arcs)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# *********************************************************************
@@ -2014,46 +1986,41 @@ class TestNetwork:
# create a new export node
- net.add_export_node(node_key="E1", prices={(0, 0, 0): resource_price})
+ net.add_export_node("E1", prices={(0, 0, 0): resource_price})
# create an arc starting in that export node
- error_triggered = False
+ error_raised = False
try:
net.add_directed_arc(node_key_a="E1", node_key_b="B", arcs=lossless_arcs)
- net.identify_node_types()
except ValueError:
- error_triggered = True
- assert error_triggered
-
- # remove the troublesome arc
+ error_raised = True
+ assert error_raised
- net.remove_edge(u="E1", v="B")
+ # # remove the troublesome arc
+ # net.remove_edge(u="E1", v="B")
# *********************************************************************
# create a new import node
- net.add_import_node(node_key="I1", prices={(0, 0, 0): resource_price})
+ net.add_import_node("I1", prices={(0, 0, 0): resource_price})
# create an arc ending in that import node
- error_triggered = False
+ error_raised = False
try:
net.add_directed_arc(node_key_a="A", node_key_b="I1", arcs=lossless_arcs)
- net.identify_node_types()
except ValueError:
- error_triggered = True
- assert error_triggered
-
- # remove the troublesome arc
+ error_raised = True
+ assert error_raised
- net.remove_edge(u="A", v="I1")
+ # # remove the troublesome arc
+ # net.remove_edge(u="A", v="I1")
# *********************************************************************
# check non-existent arc
-
net.arc_is_undirected(("X", "Y", 1))
# *************************************************************************
@@ -2067,7 +2034,7 @@ class TestNetwork:
# import node
imp_node_key = generate_pseudo_unique_key(mynet.nodes())
mynet.add_import_node(
- node_key=imp_node_key,
+ imp_node_key,
prices={
(0, 0, 0): ResourcePrice(prices=1+0.05, volumes=None)
},
@@ -2076,13 +2043,13 @@ class TestNetwork:
# other nodes
node_A = generate_pseudo_unique_key(mynet.nodes())
mynet.add_source_sink_node(
- node_key=node_A,
+ node_A,
# base_flow=[1, -1, 0.5, -0.5]
base_flow={(0, 0): 1, (0, 1): -1, (0, 2): 0.5, (0, 3): -0.5},
)
node_B = generate_pseudo_unique_key(mynet.nodes())
mynet.add_source_sink_node(
- node_key=node_B,
+ node_B,
# base_flow=[-1, 1, -0.5, 0.5]
base_flow={(0, 0): -1, (0, 1): 1, (0, 2): -0.5, (0, 3): 0.5},
)
@@ -2102,14 +2069,13 @@ class TestNetwork:
static_loss=None,
validate=False,
)
- mynet.add_undirected_arc(
- node_key_a=imp_node_key, node_key_b=node_A, arcs=arc_tech_IA
- )
-
+
error_raised = False
try:
- # identify node types
- mynet.identify_node_types()
+ # ValueError: Undirected arcs cannot involve import or export nodes.
+ mynet.add_undirected_arc(
+ node_key_a=imp_node_key, node_key_b=node_A, arcs=arc_tech_IA
+ )
except ValueError:
error_raised = True
assert error_raised
@@ -2128,7 +2094,7 @@ class TestNetwork:
# export node
exp_node_key = generate_pseudo_unique_key(mynet.nodes())
mynet.add_export_node(
- node_key=exp_node_key,
+ exp_node_key,
prices={
(0, 0, 0): ResourcePrice(prices=0.1+0.05, volumes=None)
},
@@ -2137,7 +2103,7 @@ class TestNetwork:
# other nodes
node_B = generate_pseudo_unique_key(mynet.nodes())
mynet.add_source_sink_node(
- node_key=node_B,
+ node_B,
# base_flow=[-1, 1, -0.5, 0.5]
base_flow={(0, 0): -1, (0, 1): 1, (0, 2): -0.5, (0, 3): 0.5},
)
@@ -2154,14 +2120,13 @@ class TestNetwork:
static_loss=None,
validate=False,
)
- mynet.add_undirected_arc(
- node_key_a=node_B, node_key_b=exp_node_key, arcs=arc_tech_BE
- )
error_raised = False
try:
- # identify node types
- mynet.identify_node_types()
+ # ValueError: Undirected arcs cannot involve import or export nodes.
+ mynet.add_undirected_arc(
+ node_key_a=node_B, node_key_b=exp_node_key, arcs=arc_tech_BE
+ )
except ValueError:
error_raised = True
assert error_raised
@@ -2173,7 +2138,7 @@ class TestNetwork:
# create a network object with a tree topology
tree_network = binomial_tree(3, create_using=MultiDiGraph)
- network = Network(incoming_graph_data=tree_network)
+ network = Network(network_type=Network.NET_TYPE_TREE, incoming_graph_data=tree_network)
for edge_key in network.edges(keys=True):
arc = ArcsWithoutLosses(
name=str(edge_key),
@@ -2184,6 +2149,9 @@ class TestNetwork:
)
network.add_edge(*edge_key, **{Network.KEY_ARC_TECH: arc})
+ # assert that it should have a tree topology
+ assert network.should_be_tree_network()
+
# assert that it does not have a tree topology
assert not network.has_tree_topology()
@@ -2193,6 +2161,8 @@ class TestNetwork:
# assert that it has a tree topology
assert network.has_tree_topology()
+
+
# *************************************************************************
# *************************************************************************
@@ -2202,14 +2172,8 @@ class TestNetwork:
# create network
network = Network()
- # add node A
- network.add_waypoint_node(node_key="A")
-
- # add node B
- network.add_waypoint_node(node_key="B")
-
- # identify nodes
- network.identify_node_types()
+ # add nodes A and B
+ network.add_nodes_from(['A','B'])
# add arcs
key_list = [
@@ -2236,14 +2200,14 @@ class TestNetwork:
rand.seed(360)
uuid.uuid4 = lambda: uuid.UUID(int=rand.getrandbits(128), version=4)
- error_triggered = False
+ error_raised = False
try:
_ = network.get_pseudo_unique_arc_key(
node_key_start="A", node_key_end="B", max_iterations=len(key_list) - 1
)
except Exception:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# *************************************************************************
# *************************************************************************
@@ -2265,7 +2229,7 @@ class TestNetwork:
for qpk in [(0,0,0),(0,0,1),(0,1,0),(0,1,1)]
}
mynet.add_import_node(
- node_key=imp_node_key,
+ imp_node_key,
prices=imp_prices
)
@@ -2279,7 +2243,7 @@ class TestNetwork:
for qpk in [(0,0,0),(0,0,1),(0,1,0),(0,1,1)]
}
mynet.add_export_node(
- node_key=exp_node_key,
+ exp_node_key,
prices=exp_prices,
)
@@ -2308,15 +2272,13 @@ class TestNetwork:
(2, q, 1): 0.25,
},
)
-
- mynet.add_directed_arc(
- node_key_a=imp_node_key, node_key_b=exp_node_key, arcs=arc_tech_IE_fix
- )
error_raised = False
try:
- # identify node types
- mynet.identify_node_types()
+ # ValueError: Arcs between import and export nodes cannot have static losses.
+ mynet.add_directed_arc(
+ node_key_a=imp_node_key, node_key_b=exp_node_key, arcs=arc_tech_IE_fix
+ )
except ValueError:
error_raised = True
assert error_raised
@@ -2331,11 +2293,12 @@ class TestNetwork:
# add nodes
node_a = 'A'
- net.add_waypoint_node(node_a)
+ # net.add_waypoint_node(node_a)
node_b = 'B'
- net.add_waypoint_node(node_b)
+ # net.add_waypoint_node(node_b)
node_c = 'C'
- net.add_waypoint_node(node_c)
+ # net.add_waypoint_node(node_c)
+ net.add_nodes_from([node_a,node_b,node_c])
# add arcs
node_pairs = ((node_a, node_b), (node_b, node_a),)
@@ -2349,8 +2312,6 @@ class TestNetwork:
capacity=1,
capacity_is_instantaneous=False
)
- # identify the node types
- net.identify_node_types()
# assert that it can detected the selected antiparallel arcs
assert net.has_selected_antiparallel_arcs()
@@ -2361,6 +2322,96 @@ class TestNetwork:
# *************************************************************************
# *************************************************************************
+
+ def test_add_nodes(self):
+
+ # create network
+ net = Network()
+
+ # add nodes
+ node_a = 'A'
+ net.add_node(node_a)
+ assert net.is_waypoint_node(node_a)
+ # source
+ node_b = 'B'
+ net.add_node(node_b, **{net.KEY_NODE_BASE_FLOW: {(0,0):-1}})
+ assert net.is_source_sink_node(node_b)
+ # sink
+ node_c = 'C'
+ net.add_node(node_c, **{net.KEY_NODE_BASE_FLOW: {(0,0):1}})
+ assert net.is_source_sink_node(node_c)
+ # import node
+ node_d = 'D'
+ net.add_node(node_d, **{net.KEY_NODE_PRICES: {(0,0): ResourcePrice(prices=[1, 2], volumes=[1,None])}, net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_IMP})
+ assert net.is_import_node(node_d)
+ # export node
+ node_e = 'E'
+ net.add_node(node_e, **{net.KEY_NODE_PRICES: {(0,0): ResourcePrice(prices=[2, 3], volumes=[4,None])}, net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_EXP})
+ assert net.is_export_node(node_e)
+
+ # modify nodes
+ # from waypoint to source/sink
+ net.modify_node(node_a, **{net.KEY_NODE_BASE_FLOW: {(0,0):-2}})
+ assert not net.is_waypoint_node(node_a)
+ assert net.is_source_sink_node(node_a)
+ # from source/sink to waypoint
+ net.modify_node(node_a)
+ assert not net.is_source_sink_node(node_a)
+ assert net.is_waypoint_node(node_a)
+ # from waypoint to import node
+ net.modify_node(node_a, **{net.KEY_NODE_PRICES: {(0,0): ResourcePrice(prices=[5, 3.5], volumes=[2,4])}, net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_IMP})
+ assert not net.is_waypoint_node(node_a)
+ assert net.is_import_node(node_a)
+ # from import node to waypoint
+ net.modify_node(node_a)
+ assert not net.is_import_node(node_a)
+ assert net.is_waypoint_node(node_a)
+ # from waypoint node to export node
+ net.modify_node(node_a, **{net.KEY_NODE_PRICES: {(0,0): ResourcePrice(prices=[4, 1], volumes=[3,6])}, net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_EXP})
+ assert not net.is_waypoint_node(node_a)
+ assert net.is_export_node(node_a)
+ # from export node to sink/source
+ net.modify_node(node_a, **{net.KEY_NODE_BASE_FLOW: {(0,0):-1}})
+ assert not net.is_export_node(node_a)
+ assert net.is_source_sink_node(node_a)
+ # from sink/source node to import node
+ net.modify_node(node_a, **{net.KEY_NODE_PRICES: {(0,0): ResourcePrice(prices=[5, 3.5], volumes=[2,4])}, net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_IMP})
+ assert not net.is_source_sink_node(node_a)
+ assert net.is_import_node(node_a)
+ # from import node to export node
+ net.modify_node(node_a, **{net.KEY_NODE_PRICES: {(0,0): ResourcePrice(prices=[4, 1], volumes=[3,6])}, net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_EXP})
+ assert not net.is_import_node(node_a)
+ assert net.is_export_node(node_a)
+ # from export node to waypoint node
+ net.modify_node(node_a)
+ assert not net.is_export_node(node_a)
+ assert net.is_waypoint_node(node_a)
+
+ # *********************************************************************
+
+ # test modifying nodes with preexisting arcs
+
+ # add arcs
+ # add arc between two waypoint nodes
+ net.add_preexisting_directed_arc(
+ node_key_a=node_a,
+ node_key_b=node_b,
+ efficiency=None,
+ static_loss=None,
+ capacity=3,
+ capacity_is_instantaneous=False
+ )
+
+ # modify nodes
+ # try to change the start node to an export node
+ with pytest.raises(ValueError):
+ net.modify_node(node_a, **{net.KEY_NODE_PRICES: {(0,0): ResourcePrice(prices=[4, 1], volumes=[3,6])}, net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_EXP})
+ # try to change the end node to an import node
+ with pytest.raises(ValueError):
+ net.modify_node(node_b, **{net.KEY_NODE_PRICES: {(0,0): ResourcePrice(prices=[4, 1], volumes=[3,6])}, net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_IMP})
+
+ # *************************************************************************
+ # *************************************************************************
# *****************************************************************************
# *****************************************************************************
diff --git a/tests/test_esipp_prices.py b/tests/test_esipp_prices.py
index 783304755c4d764ac00cd70e0ac0da3deb620f71..813fc0eb311b712ef6b4b85f62869e6e1cc45f74 100644
--- a/tests/test_esipp_prices.py
+++ b/tests/test_esipp_prices.py
@@ -2,12 +2,14 @@
# standard
import math
+import pytest
# local
# import numpy as np
# import networkx as nx
import pyomo.environ as pyo
+
# import src.topupopt.problems.esipp.utils as utils
from src.topupopt.data.misc.utils import generate_pseudo_unique_key
from src.topupopt.problems.esipp.problem import InfrastructurePlanningProblem
@@ -17,233 +19,162 @@ from src.topupopt.problems.esipp.resource import ResourcePrice
from src.topupopt.problems.esipp.utils import statistics
from src.topupopt.problems.esipp.time import EconomicTimeFrame
# from src.topupopt.problems.esipp.converter import Converter
+from test_esipp import build_solve_ipp
+from src.topupopt.problems.esipp.blocks.prices import NODE_PRICE_OTHER, NODE_PRICE_DELTA, NODE_PRICE_LAMBDA
# *****************************************************************************
# *****************************************************************************
-class TestESIPPProblem:
-
- solver = 'glpk'
- # solver = 'scip'
- # solver = 'cbc'
-
- def build_solve_ipp(
- self,
- solver: str = None,
- solver_options: dict = None,
- use_sos_arcs: bool = False,
- arc_sos_weight_key: str = (InfrastructurePlanningProblem.SOS1_ARC_WEIGHTS_NONE),
- arc_use_real_variables_if_possible: bool = False,
- use_sos_sense: bool = False,
- sense_sos_weight_key: int = (
- InfrastructurePlanningProblem.SOS1_SENSE_WEIGHT_NOMINAL_HIGHER
- ),
- sense_use_real_variables_if_possible: bool = False,
- sense_use_arc_interfaces: bool = False,
- perform_analysis: bool = False,
- plot_results: bool = False,
- print_solver_output: bool = False,
- time_frame: EconomicTimeFrame = None,
- networks: dict = None,
- converters: dict = None,
- static_losses_mode=None,
- mandatory_arcs: list = None,
- max_number_parallel_arcs: dict = None,
- arc_groups_dict: dict = None,
- init_aux_sets: bool = False,
- # discount_rates: dict = None,
- assessment_weights: dict = None,
- simplify_problem: bool = False,
- ):
- if type(solver) == type(None):
- solver = self.solver
-
- if type(assessment_weights) != dict:
- assessment_weights = {} # default
-
- if type(converters) != dict:
- converters = {}
-
- # time weights
-
- # relative weight of time period
-
- # one interval twice as long as the average is worth twice
- # one interval half as long as the average is worth half
-
- # time_weights = [
- # [time_period_duration/average_time_interval_duration
- # for time_period_duration in intraperiod_time_interval_duration]
- # for p in range(number_periods)]
-
- time_weights = None # nothing yet
+# TODO: test time-varying tariffs (convex/non-convex)
+# TODO: check problem sizes
- normalised_time_interval_duration = None # nothing yet
+class TestESIPPProblem:
- # create problem object
+ # *************************************************************************
+ # *************************************************************************
- ipp = InfrastructurePlanningProblem(
- # discount_rates=discount_rates,
- time_frame=time_frame,
- # reporting_periods=time_frame.reporting_periods,
- # time_intervals=time_frame.time_interval_durations,
- time_weights=time_weights,
- normalised_time_interval_duration=normalised_time_interval_duration,
- assessment_weights=assessment_weights,
+ @pytest.mark.parametrize(
+ "use_prices_block, node_price_model",
+ [(True, NODE_PRICE_OTHER),
+ (True, NODE_PRICE_DELTA),
+ (True, NODE_PRICE_LAMBDA),
+ (False, NODE_PRICE_OTHER),
+ (False, NODE_PRICE_DELTA),
+ (False, NODE_PRICE_LAMBDA)]
)
+ def test_problem_increasing_imp_prices(self, use_prices_block, node_price_model):
+
+ # assessment
+ q = 0
- # add networks and systems
-
- for netkey, net in networks.items():
- ipp.add_network(network_key=netkey, network=net)
-
- # add converters
-
- for cvtkey, cvt in converters.items():
- ipp.add_converter(converter_key=cvtkey, converter=cvt)
-
- # define arcs as mandatory
-
- if type(mandatory_arcs) == list:
- for full_arc_key in mandatory_arcs:
- ipp.make_arc_mandatory(full_arc_key[0], full_arc_key[1:])
-
- # if make_all_arcs_mandatory:
-
- # for network_key in ipp.networks:
-
- # for arc_key in ipp.networks[network_key].edges(keys=True):
-
- # # preexisting arcs are no good
-
- # if ipp.networks[network_key].edges[arc_key][
- # Network.KEY_ARC_TECH].has_been_selected():
-
- # continue
-
- # ipp.make_arc_mandatory(network_key, arc_key)
-
- # set up the use of sos for arc selection
-
- if use_sos_arcs:
- for network_key in ipp.networks:
- for arc_key in ipp.networks[network_key].edges(keys=True):
- if (
- ipp.networks[network_key]
- .edges[arc_key][Network.KEY_ARC_TECH]
- .has_been_selected()
- ):
- continue
-
- ipp.use_sos1_for_arc_selection(
- network_key,
- arc_key,
- use_real_variables_if_possible=(
- arc_use_real_variables_if_possible
- ),
- sos1_weight_method=arc_sos_weight_key,
- )
-
- # set up the use of sos for flow sense determination
-
- if use_sos_sense:
- for network_key in ipp.networks:
- for arc_key in ipp.networks[network_key].edges(keys=True):
- if not ipp.networks[network_key].edges[arc_key][
- Network.KEY_ARC_UND
- ]:
- continue
-
- ipp.use_sos1_for_flow_senses(
- network_key,
- arc_key,
- use_real_variables_if_possible=(
- sense_use_real_variables_if_possible
- ),
- use_interface_variables=sense_use_arc_interfaces,
- sos1_weight_method=sense_sos_weight_key,
- )
-
- elif sense_use_arc_interfaces: # set up the use of arc interfaces w/o sos1
- for network_key in ipp.networks:
- for arc_key in ipp.networks[network_key].edges(keys=True):
- if (
- ipp.networks[network_key]
- .edges[arc_key][Network.KEY_ARC_TECH]
- .has_been_selected()
- ):
- continue
-
- ipp.use_interface_variables_for_arc_selection(network_key, arc_key)
-
- # static losses
-
- if static_losses_mode == ipp.STATIC_LOSS_MODE_ARR:
- ipp.place_static_losses_arrival_node()
-
- elif static_losses_mode == ipp.STATIC_LOSS_MODE_DEP:
- ipp.place_static_losses_departure_node()
+ tf = EconomicTimeFrame(
+ discount_rate=0.0,
+ reporting_periods={q: (0,)},
+ reporting_period_durations={q: (365 * 24 * 3600,)},
+ time_intervals={q: (0,)},
+ time_interval_durations={q: (1,)},
+ )
- elif static_losses_mode == ipp.STATIC_LOSS_MODE_US:
- ipp.place_static_losses_upstream()
+ # 2 nodes: one import, one regular
+ mynet = Network()
- elif static_losses_mode == ipp.STATIC_LOSS_MODE_DS:
- ipp.place_static_losses_downstream()
+ # import node
+ node_IMP = 'I'
+ prices = [1.0, 2.0]
+ volumes = [0.5, None] if node_price_model == NODE_PRICE_OTHER else [0.5, 1e5]
+ mynet.add_import_node(
+ node_key=node_IMP,
+ prices={
+ qpk: ResourcePrice(prices=prices, volumes=volumes)
+ for qpk in tf.qpk()
+ },
+ )
- else:
- raise ValueError("Unknown static loss modelling mode.")
+ # other nodes
+ node_A = 'A'
+ mynet.add_source_sink_node(node_key=node_A, base_flow={(q, 0): 1.0})
- # *********************************************************************
+ # arc IA
+ arc_tech_IA = Arcs(
+ name="any",
+ efficiency={(q, 0): 0.5},
+ efficiency_reverse=None,
+ static_loss=None,
+ capacity=[3],
+ minimum_cost=[2],
+ specific_capacity_cost=1,
+ capacity_is_instantaneous=False,
+ validate=False,
+ )
+ mynet.add_directed_arc(node_key_a=node_IMP, node_key_b=node_A, arcs=arc_tech_IA)
- # groups
+ # no sos, regular time intervals
+ ipp = build_solve_ipp(
+ solver_options={},
+ perform_analysis=False,
+ plot_results=False, # True,
+ print_solver_output=False,
+ time_frame=tf,
+ networks={"mynet": mynet},
+ static_losses_mode=True, # just to reach a line,
+ mandatory_arcs=[],
+ max_number_parallel_arcs={},
+ simplify_problem=False,
+ use_prices_block=use_prices_block,
+ node_price_model=node_price_model
+ )
- if type(arc_groups_dict) != type(None):
- for key in arc_groups_dict:
- ipp.create_arc_group(arc_groups_dict[key])
+ assert not ipp.has_peak_total_assessments()
+ # print('hey')
+ # print((use_prices_block, node_price_model))
+ # print(ipp.results["Problem"][0])
+ if (use_prices_block, node_price_model) == (True, NODE_PRICE_OTHER):
+ assert ipp.results["Problem"][0]["Number of constraints"] == 10
+ assert ipp.results["Problem"][0]["Number of variables"] == 11
+ assert ipp.results["Problem"][0]["Number of nonzeros"] == 20
+ elif (use_prices_block, node_price_model) == (False, NODE_PRICE_OTHER):
+ assert ipp.results["Problem"][0]["Number of constraints"] == 10
+ assert ipp.results["Problem"][0]["Number of variables"] == 11
+ assert ipp.results["Problem"][0]["Number of nonzeros"] == 20
+ elif (use_prices_block, node_price_model) == (True, NODE_PRICE_DELTA):
+ assert ipp.results["Problem"][0]["Number of constraints"] == 11
+ assert ipp.results["Problem"][0]["Number of variables"] == 12
+ assert ipp.results["Problem"][0]["Number of nonzeros"] == 22
+ elif (use_prices_block, node_price_model) == (False, NODE_PRICE_DELTA):
+ assert ipp.results["Problem"][0]["Number of constraints"] == 15
+ assert ipp.results["Problem"][0]["Number of variables"] == 14
+ assert ipp.results["Problem"][0]["Number of nonzeros"] == 30
# *********************************************************************
-
- # maximum number of parallel arcs
-
- for key in max_number_parallel_arcs:
- ipp.set_maximum_number_parallel_arcs(
- network_key=key[0],
- node_a=key[1],
- node_b=key[2],
- limit=max_number_parallel_arcs[key],
- )
-
# *********************************************************************
- if simplify_problem:
- ipp.simplify_peak_total_assessments()
+ # validation
- # *********************************************************************
-
- # instantiate (disable the default case v-a-v fixed losses)
+ # the arc should be installed since it is required for feasibility
+ assert (
+ True
+ in ipp.networks["mynet"]
+ .edges[(node_IMP, node_A, 0)][Network.KEY_ARC_TECH]
+ .options_selected
+ )
- # ipp.instantiate(place_fixed_losses_upstream_if_possible=False)
+ # the flows should be 1.0, 0.0 and 2.0
+ assert math.isclose(
+ pyo.value(ipp.instance.var_v_glljqk[("mynet", node_IMP, node_A, 0, q, 0)]),
+ 2.0,
+ abs_tol=1e-6,
+ )
- ipp.instantiate(initialise_ancillary_sets=init_aux_sets)
- # ipp.instance.pprint()
- # optimise
- ipp.optimise(
- solver_name=solver,
- solver_options=solver_options,
- output_options={},
- print_solver_output=print_solver_output,
+ # arc amplitude should be two
+ assert math.isclose(
+ pyo.value(ipp.instance.var_v_amp_gllj[("mynet", node_IMP, node_A, 0)]),
+ 2.0,
+ abs_tol=0.01,
)
- # ipp.instance.pprint()
- # return the problem object
- return ipp
- # *********************************************************************
- # *********************************************************************
+ # capex should be four
+ assert math.isclose(pyo.value(ipp.instance.var_capex), 4.0, abs_tol=1e-3)
+
+ # sdncf should be -3.5
+ assert math.isclose(pyo.value(ipp.instance.var_sdncf_q[q]), -3.5, abs_tol=1e-3)
+ # the objective function should be -7.5
+ assert math.isclose(pyo.value(ipp.instance.obj_f), -7.5, abs_tol=1e-3)
+
# *************************************************************************
# *************************************************************************
-
- def test_problem_increasing_imp_prices(self):
+
+ @pytest.mark.parametrize(
+ "use_prices_block, node_price_model",
+ [(True, NODE_PRICE_OTHER),
+ (True, NODE_PRICE_DELTA),
+ (True, NODE_PRICE_LAMBDA),
+ (False, NODE_PRICE_OTHER),
+ (False, NODE_PRICE_DELTA),
+ (False, NODE_PRICE_LAMBDA)
+ ]
+ )
+ def test_problem_decreasing_imp_prices(self, use_prices_block, node_price_model):
# assessment
q = 0
@@ -264,7 +195,7 @@ class TestESIPPProblem:
mynet.add_import_node(
node_key=node_IMP,
prices={
- qpk: ResourcePrice(prices=[1.0, 2.0], volumes=[0.5, None])
+ qpk: ResourcePrice(prices=[2.0, 1.0], volumes=[0.5, 3.0])
for qpk in tf.qpk()
},
)
@@ -287,28 +218,44 @@ class TestESIPPProblem:
)
mynet.add_directed_arc(node_key_a=node_IMP, node_key_b=node_A, arcs=arc_tech_IA)
- # identify node types
- mynet.identify_node_types()
-
# no sos, regular time intervals
- ipp = self.build_solve_ipp(
+ ipp = build_solve_ipp(
+ solver='scip' if node_price_model == NODE_PRICE_LAMBDA else 'glpk',
solver_options={},
perform_analysis=False,
plot_results=False, # True,
- print_solver_output=False,
+ print_solver_output=False,
time_frame=tf,
networks={"mynet": mynet},
static_losses_mode=True, # just to reach a line,
mandatory_arcs=[],
max_number_parallel_arcs={},
- simplify_problem=False
+ simplify_problem=False,
+ use_prices_block=use_prices_block,
+ node_price_model=node_price_model
)
assert not ipp.has_peak_total_assessments()
- assert ipp.results["Problem"][0]["Number of constraints"] == 10
- assert ipp.results["Problem"][0]["Number of variables"] == 11
- assert ipp.results["Problem"][0]["Number of nonzeros"] == 20
-
+ # print('hey')
+ # print((use_prices_block, node_price_model))
+ # print(ipp.results["Problem"][0])
+ if (use_prices_block, node_price_model) == (True, NODE_PRICE_OTHER):
+ assert ipp.results["Problem"][0]["Number of constraints"] == 14
+ assert ipp.results["Problem"][0]["Number of variables"] == 13
+ assert ipp.results["Problem"][0]["Number of nonzeros"] == 28
+ elif (use_prices_block, node_price_model) == (False, NODE_PRICE_OTHER):
+ assert ipp.results["Problem"][0]["Number of constraints"] == 14
+ assert ipp.results["Problem"][0]["Number of variables"] == 13
+ assert ipp.results["Problem"][0]["Number of nonzeros"] == 28
+ elif (use_prices_block, node_price_model) == (True, NODE_PRICE_DELTA):
+ assert ipp.results["Problem"][0]["Number of constraints"] == 15
+ assert ipp.results["Problem"][0]["Number of variables"] == 14
+ assert ipp.results["Problem"][0]["Number of nonzeros"] == 30
+ elif (use_prices_block, node_price_model) == (False, NODE_PRICE_DELTA):
+ assert ipp.results["Problem"][0]["Number of constraints"] == 15
+ assert ipp.results["Problem"][0]["Number of variables"] == 14
+ assert ipp.results["Problem"][0]["Number of nonzeros"] == 30
+
# *********************************************************************
# *********************************************************************
@@ -339,16 +286,26 @@ class TestESIPPProblem:
# capex should be four
assert math.isclose(pyo.value(ipp.instance.var_capex), 4.0, abs_tol=1e-3)
- # sdncf should be -3.5
- assert math.isclose(pyo.value(ipp.instance.var_sdncf_q[q]), -3.5, abs_tol=1e-3)
+ # sdncf should be -2.5
+ assert math.isclose(pyo.value(ipp.instance.var_sdncf_q[q]), -2.5, abs_tol=1e-3)
# the objective function should be -7.5
- assert math.isclose(pyo.value(ipp.instance.obj_f), -7.5, abs_tol=1e-3)
+ assert math.isclose(pyo.value(ipp.instance.obj_f), -6.5, abs_tol=1e-3)
# *************************************************************************
# *************************************************************************
-
- def test_problem_decreasing_imp_prices(self):
+
+ @pytest.mark.parametrize(
+ "use_prices_block, node_price_model",
+ [(True, NODE_PRICE_OTHER),
+ (True, NODE_PRICE_DELTA),
+ (True, NODE_PRICE_LAMBDA),
+ (False, NODE_PRICE_OTHER),
+ (False, NODE_PRICE_DELTA),
+ (False, NODE_PRICE_LAMBDA)
+ ]
+ )
+ def test_problem_decreasing_imp_prices2(self, use_prices_block, node_price_model):
# assessment
q = 0
@@ -376,7 +333,7 @@ class TestESIPPProblem:
# other nodes
node_A = 'A'
- mynet.add_source_sink_node(node_key=node_A, base_flow={(q, 0): 1.0})
+ mynet.add_source_sink_node(node_key=node_A, base_flow={(q, 0): 0.25})
# arc IA
arc_tech_IA = Arcs(
@@ -392,11 +349,9 @@ class TestESIPPProblem:
)
mynet.add_directed_arc(node_key_a=node_IMP, node_key_b=node_A, arcs=arc_tech_IA)
- # identify node types
- mynet.identify_node_types()
-
# no sos, regular time intervals
- ipp = self.build_solve_ipp(
+ ipp = build_solve_ipp(
+ solver='scip' if node_price_model == NODE_PRICE_LAMBDA else 'glpk',
solver_options={},
perform_analysis=False,
plot_results=False, # True,
@@ -406,14 +361,36 @@ class TestESIPPProblem:
static_losses_mode=True, # just to reach a line,
mandatory_arcs=[],
max_number_parallel_arcs={},
- simplify_problem=False
+ simplify_problem=False,
+ use_prices_block=use_prices_block,
+ node_price_model=node_price_model
)
assert not ipp.has_peak_total_assessments()
- assert ipp.results["Problem"][0]["Number of constraints"] == 14 # 10 prior to nonconvex block
- assert ipp.results["Problem"][0]["Number of variables"] == 13 # 11 prior to nonconvex block
- assert ipp.results["Problem"][0]["Number of nonzeros"] == 28 # 20 prior to nonconvex block
-
+ # print('hey')
+ # # print((use_prices_block, node_price_model))
+ # print(ipp.results["Problem"][0])
+ # # capex should be four
+ # print(pyo.value(ipp.instance.var_capex))
+ # print(pyo.value(ipp.instance.var_sdncf_q[q]))
+ # print(pyo.value(ipp.instance.obj_f))
+ if (use_prices_block, node_price_model) == (True, NODE_PRICE_OTHER):
+ assert ipp.results["Problem"][0]["Number of constraints"] == 14
+ assert ipp.results["Problem"][0]["Number of variables"] == 13
+ assert ipp.results["Problem"][0]["Number of nonzeros"] == 28
+ elif (use_prices_block, node_price_model) == (False, NODE_PRICE_OTHER):
+ assert ipp.results["Problem"][0]["Number of constraints"] == 14
+ assert ipp.results["Problem"][0]["Number of variables"] == 13
+ assert ipp.results["Problem"][0]["Number of nonzeros"] == 28
+ elif (use_prices_block, node_price_model) == (True, NODE_PRICE_DELTA):
+ assert ipp.results["Problem"][0]["Number of constraints"] == 15
+ assert ipp.results["Problem"][0]["Number of variables"] == 14
+ assert ipp.results["Problem"][0]["Number of nonzeros"] == 30
+ elif (use_prices_block, node_price_model) == (False, NODE_PRICE_DELTA):
+ assert ipp.results["Problem"][0]["Number of constraints"] == 15
+ assert ipp.results["Problem"][0]["Number of variables"] == 14
+ assert ipp.results["Problem"][0]["Number of nonzeros"] == 30
+
# *********************************************************************
# *********************************************************************
@@ -427,33 +404,42 @@ class TestESIPPProblem:
.options_selected
)
- # the flows should be 1.0, 0.0 and 2.0
+ # the flows should be 0.5
assert math.isclose(
pyo.value(ipp.instance.var_v_glljqk[("mynet", node_IMP, node_A, 0, q, 0)]),
- 2.0,
+ 0.5,
abs_tol=1e-6,
)
- # arc amplitude should be two
+ # arc amplitude should be 0.5
assert math.isclose(
pyo.value(ipp.instance.var_v_amp_gllj[("mynet", node_IMP, node_A, 0)]),
- 2.0,
+ 0.5,
abs_tol=0.01,
)
# capex should be four
- assert math.isclose(pyo.value(ipp.instance.var_capex), 4.0, abs_tol=1e-3)
+ assert math.isclose(pyo.value(ipp.instance.var_capex), 2.5, abs_tol=1e-3)
# sdncf should be -2.5
- assert math.isclose(pyo.value(ipp.instance.var_sdncf_q[q]), -2.5, abs_tol=1e-3)
+ assert math.isclose(pyo.value(ipp.instance.var_sdncf_q[q]), -1.0, abs_tol=1e-3)
# the objective function should be -7.5
- assert math.isclose(pyo.value(ipp.instance.obj_f), -6.5, abs_tol=1e-3)
+ assert math.isclose(pyo.value(ipp.instance.obj_f), -3.5, abs_tol=1e-3)
# *************************************************************************
# *************************************************************************
- def test_problem_decreasing_imp_prices_infinite_capacity(self):
+ @pytest.mark.parametrize(
+ "use_prices_block, node_price_model",
+ [(True, NODE_PRICE_OTHER),
+ (True, NODE_PRICE_DELTA),
+ (True, NODE_PRICE_LAMBDA),
+ (False, NODE_PRICE_OTHER),
+ (False, NODE_PRICE_DELTA),
+ (False, NODE_PRICE_LAMBDA)]
+ )
+ def test_problem_decreasing_imp_prices_infinite_capacity(self, use_prices_block, node_price_model):
# assessment
q = 0
@@ -496,15 +482,12 @@ class TestESIPPProblem:
validate=False,
)
mynet.add_directed_arc(node_key_a=node_IMP, node_key_b=node_A, arcs=arc_tech_IA)
-
- # identify node types
- mynet.identify_node_types()
# trigger the error
error_raised = False
try:
# no sos, regular time intervals
- self.build_solve_ipp(
+ build_solve_ipp(
solver_options={},
perform_analysis=False,
plot_results=False, # True,
@@ -523,7 +506,16 @@ class TestESIPPProblem:
# *************************************************************************
# *************************************************************************
- def test_problem_decreasing_exp_prices(self):
+ @pytest.mark.parametrize(
+ "use_prices_block, node_price_model",
+ [(True, NODE_PRICE_OTHER),
+ (True, NODE_PRICE_DELTA),
+ (True, NODE_PRICE_LAMBDA),
+ (False, NODE_PRICE_OTHER),
+ (False, NODE_PRICE_DELTA),
+ (False, NODE_PRICE_LAMBDA)]
+ )
+ def test_problem_decreasing_exp_prices(self, use_prices_block, node_price_model):
# assessment
q = 0
# time
@@ -544,10 +536,12 @@ class TestESIPPProblem:
# import node
node_EXP = generate_pseudo_unique_key(mynet.nodes())
+ prices = [2.0, 1.0]
+ volumes = [0.5, None] if node_price_model == NODE_PRICE_OTHER else [0.5, 1e5]
mynet.add_export_node(
node_key=node_EXP,
prices={
- (q, p, k): ResourcePrice(prices=[2.0, 1.0], volumes=[0.5, None])
+ (q, p, k): ResourcePrice(prices=prices, volumes=volumes)
for p in range(number_periods)
for k in range(number_intervals)
},
@@ -571,11 +565,8 @@ class TestESIPPProblem:
)
mynet.add_directed_arc(node_key_a=node_A, node_key_b=node_EXP, arcs=arc_tech_IA)
- # identify node types
- mynet.identify_node_types()
-
# no sos, regular time intervals
- ipp = self.build_solve_ipp(
+ ipp = build_solve_ipp(
solver_options={},
perform_analysis=False,
plot_results=False, # True,
@@ -586,12 +577,11 @@ class TestESIPPProblem:
mandatory_arcs=[],
max_number_parallel_arcs={},
simplify_problem=False,
+ use_prices_block=use_prices_block,
+ node_price_model=node_price_model
)
assert not ipp.has_peak_total_assessments()
- assert ipp.results["Problem"][0]["Number of constraints"] == 10
- assert ipp.results["Problem"][0]["Number of variables"] == 11
- assert ipp.results["Problem"][0]["Number of nonzeros"] == 20
# *********************************************************************
# *********************************************************************
@@ -632,7 +622,16 @@ class TestESIPPProblem:
# *************************************************************************
# *************************************************************************
- def test_problem_increasing_exp_prices(self):
+ @pytest.mark.parametrize(
+ "use_prices_block, node_price_model",
+ [(True, NODE_PRICE_OTHER),
+ (True, NODE_PRICE_DELTA),
+ (True, NODE_PRICE_LAMBDA),
+ (False, NODE_PRICE_OTHER),
+ (False, NODE_PRICE_DELTA),
+ (False, NODE_PRICE_LAMBDA)]
+ )
+ def test_problem_increasing_exp_prices(self, use_prices_block, node_price_model):
# assessment
q = 0
# time
@@ -680,11 +679,9 @@ class TestESIPPProblem:
)
mynet.add_directed_arc(node_key_a=node_A, node_key_b=node_EXP, arcs=arc_tech_IA)
- # identify node types
- mynet.identify_node_types()
-
# no sos, regular time intervals
- ipp = self.build_solve_ipp(
+ ipp = build_solve_ipp(
+ solver='scip' if node_price_model == NODE_PRICE_LAMBDA else 'glpk',
solver_options={},
perform_analysis=False,
plot_results=False, # True,
@@ -695,12 +692,11 @@ class TestESIPPProblem:
mandatory_arcs=[],
max_number_parallel_arcs={},
simplify_problem=False,
+ use_prices_block=use_prices_block,
+ node_price_model=node_price_model
)
-
+
assert not ipp.has_peak_total_assessments()
- assert ipp.results["Problem"][0]["Number of constraints"] == 14 # 10 before nonconvex block
- assert ipp.results["Problem"][0]["Number of variables"] == 13 # 11 before nonconvex block
- assert ipp.results["Problem"][0]["Number of nonzeros"] == 28 # 20 before nonconvex block
# *********************************************************************
# *********************************************************************
@@ -741,7 +737,16 @@ class TestESIPPProblem:
# *************************************************************************
# *************************************************************************
- def test_problem_increasing_exp_prices_infinite_capacity(self):
+ @pytest.mark.parametrize(
+ "use_prices_block, node_price_model",
+ [(True, NODE_PRICE_OTHER),
+ (True, NODE_PRICE_DELTA),
+ (True, NODE_PRICE_LAMBDA),
+ (False, NODE_PRICE_OTHER),
+ (False, NODE_PRICE_DELTA),
+ (False, NODE_PRICE_LAMBDA)]
+ )
+ def test_problem_increasing_exp_prices_infinite_capacity(self, use_prices_block, node_price_model):
# assessment
q = 0
# time
@@ -788,15 +793,12 @@ class TestESIPPProblem:
validate=False,
)
mynet.add_directed_arc(node_key_a=node_A, node_key_b=node_EXP, arcs=arc_tech_IA)
-
- # identify node types
- mynet.identify_node_types()
# trigger the error
error_raised = False
try:
# no sos, regular time intervals
- self.build_solve_ipp(
+ build_solve_ipp(
solver_options={},
perform_analysis=False,
plot_results=False, # True,
@@ -807,6 +809,8 @@ class TestESIPPProblem:
mandatory_arcs=[],
max_number_parallel_arcs={},
simplify_problem=False,
+ use_prices_block=use_prices_block,
+ node_price_model=node_price_model
)
except Exception:
error_raised = True
@@ -815,7 +819,16 @@ class TestESIPPProblem:
# *************************************************************************
# *************************************************************************
- def test_problem_increasing_imp_decreasing_exp_prices(self):
+ @pytest.mark.parametrize(
+ "use_prices_block, node_price_model",
+ [(True, NODE_PRICE_OTHER),
+ (True, NODE_PRICE_DELTA),
+ (True, NODE_PRICE_LAMBDA),
+ (False, NODE_PRICE_OTHER),
+ (False, NODE_PRICE_DELTA),
+ (False, NODE_PRICE_LAMBDA)]
+ )
+ def test_problem_increasing_imp_decreasing_exp_prices(self, use_prices_block, node_price_model):
# scenario
q = 0
# time
@@ -836,10 +849,12 @@ class TestESIPPProblem:
# import node
node_IMP = 'I'
+ prices = [1.0, 2.0]
+ volumes = [0.5, None] if node_price_model == NODE_PRICE_OTHER else [0.5, 1e5]
mynet.add_import_node(
node_key=node_IMP,
prices={
- (q, p, k): ResourcePrice(prices=[1.0, 2.0], volumes=[0.5, None])
+ (q, p, k): ResourcePrice(prices=prices, volumes=volumes)
for p in range(number_periods)
for k in range(number_intervals)
},
@@ -847,10 +862,12 @@ class TestESIPPProblem:
# export node
node_EXP = generate_pseudo_unique_key(mynet.nodes())
+ prices = [2.0, 1.0]
+ volumes = [0.5, None] if node_price_model == NODE_PRICE_OTHER else [0.5, 1e5]
mynet.add_export_node(
node_key=node_EXP,
prices={
- (q, p, k): ResourcePrice(prices=[2.0, 1.0], volumes=[0.5, None])
+ (q, p, k): ResourcePrice(prices=prices, volumes=volumes)
for p in range(number_periods)
for k in range(number_intervals)
},
@@ -890,11 +907,8 @@ class TestESIPPProblem:
)
mynet.add_directed_arc(node_key_a=node_A, node_key_b=node_EXP, arcs=arc_tech_AE)
- # identify node types
- mynet.identify_node_types()
-
# no sos, regular time intervals
- ipp = self.build_solve_ipp(
+ ipp = build_solve_ipp(
solver_options={},
perform_analysis=False,
plot_results=False, # True,
@@ -906,12 +920,11 @@ class TestESIPPProblem:
max_number_parallel_arcs={},
simplify_problem=False,
# discount_rates={0: (0.0,)},
+ use_prices_block=use_prices_block,
+ node_price_model=node_price_model
)
assert not ipp.has_peak_total_assessments()
- assert ipp.results["Problem"][0]["Number of constraints"] == 23
- assert ipp.results["Problem"][0]["Number of variables"] == 26
- assert ipp.results["Problem"][0]["Number of nonzeros"] == 57
# *********************************************************************
# *********************************************************************
@@ -981,8 +994,17 @@ class TestESIPPProblem:
# *************************************************************************
# *************************************************************************
-
- def test_direct_imp_exp_network_higher_exp_prices(self):
+
+ @pytest.mark.parametrize(
+ "use_prices_block, node_price_model",
+ [(True, NODE_PRICE_OTHER),
+ (True, NODE_PRICE_DELTA),
+ (True, NODE_PRICE_LAMBDA),
+ (False, NODE_PRICE_OTHER),
+ (False, NODE_PRICE_DELTA),
+ (False, NODE_PRICE_LAMBDA)]
+ )
+ def test_direct_imp_exp_network_higher_exp_prices(self, use_prices_block, node_price_model):
# time frame
q = 0
@@ -1002,7 +1024,7 @@ class TestESIPPProblem:
imp_prices = {
qpk: ResourcePrice(
prices=0.5,
- volumes=None,
+ volumes=None if node_price_model == NODE_PRICE_OTHER else 1e4,
)
for qpk in tf.qpk()
}
@@ -1016,7 +1038,7 @@ class TestESIPPProblem:
exp_prices = {
qpk: ResourcePrice(
prices=1.5,
- volumes=None,
+ volumes=None if node_price_model == NODE_PRICE_OTHER else 1e4,
)
for qpk in tf.qpk()
}
@@ -1042,11 +1064,8 @@ class TestESIPPProblem:
node_key_a=imp_node_key, node_key_b=exp_node_key, arcs=arc_tech_IE
)
- # identify node types
- mynet.identify_node_types()
-
# no sos, regular time intervals
- ipp = self.build_solve_ipp(
+ ipp = build_solve_ipp(
solver_options={},
perform_analysis=False,
plot_results=False, # True,
@@ -1055,7 +1074,9 @@ class TestESIPPProblem:
time_frame=tf,
static_losses_mode=InfrastructurePlanningProblem.STATIC_LOSS_MODE_DEP,
mandatory_arcs=[],
- max_number_parallel_arcs={}
+ max_number_parallel_arcs={},
+ use_prices_block=use_prices_block,
+ node_price_model=node_price_model
)
# export prices are higher: it makes sense to install the arc since the
@@ -1067,7 +1088,7 @@ class TestESIPPProblem:
.edges[(imp_node_key, exp_node_key, 0)][Network.KEY_ARC_TECH]
.options_selected
)
-
+
# overview
(imports_qpk,
exports_qpk,
diff --git a/tests/test_esipp_problem.py b/tests/test_esipp_problem.py
index 3f69ee09d398608ebd37a34d7d1801926353ecf8..d1005617716abd3a8fd761b88d469d462dfdd291 100644
--- a/tests/test_esipp_problem.py
+++ b/tests/test_esipp_problem.py
@@ -4,8 +4,7 @@
import math
# local
-# import numpy as np
-# import networkx as nx
+import pytest
import pyomo.environ as pyo
# import src.topupopt.problems.esipp.utils as utils
@@ -18,234 +17,22 @@ from src.topupopt.problems.esipp.resource import ResourcePrice
from src.topupopt.problems.esipp.utils import statistics
from src.topupopt.problems.esipp.time import EconomicTimeFrame
# from src.topupopt.problems.esipp.converter import Converter
+from test_esipp import build_solve_ipp, check_problem_size
# *****************************************************************************
# *****************************************************************************
class TestESIPPProblem:
-
- solver = 'glpk'
- # solver = 'scip'
- # solver = 'cbc'
-
- def build_solve_ipp(
- self,
- solver: str = None,
- solver_options: dict = None,
- use_sos_arcs: bool = False,
- arc_sos_weight_key: str = (InfrastructurePlanningProblem.SOS1_ARC_WEIGHTS_NONE),
- arc_use_real_variables_if_possible: bool = False,
- use_sos_sense: bool = False,
- sense_sos_weight_key: int = (
- InfrastructurePlanningProblem.SOS1_SENSE_WEIGHT_NOMINAL_HIGHER
- ),
- sense_use_real_variables_if_possible: bool = False,
- sense_use_arc_interfaces: bool = False,
- perform_analysis: bool = False,
- plot_results: bool = False,
- print_solver_output: bool = False,
- time_frame: EconomicTimeFrame = None,
- networks: dict = None,
- converters: dict = None,
- static_losses_mode=None,
- mandatory_arcs: list = None,
- max_number_parallel_arcs: dict = None,
- arc_groups_dict: dict = None,
- init_aux_sets: bool = False,
- # discount_rates: dict = None,
- assessment_weights: dict = None,
- simplify_problem: bool = False,
- ):
- if type(solver) == type(None):
- solver = self.solver
-
- if type(assessment_weights) != dict:
- assessment_weights = {} # default
-
- if type(converters) != dict:
- converters = {}
-
- # time weights
-
- # relative weight of time period
-
- # one interval twice as long as the average is worth twice
- # one interval half as long as the average is worth half
-
- # time_weights = [
- # [time_period_duration/average_time_interval_duration
- # for time_period_duration in intraperiod_time_interval_duration]
- # for p in range(number_periods)]
-
- time_weights = None # nothing yet
-
- normalised_time_interval_duration = None # nothing yet
-
- # create problem object
-
- ipp = InfrastructurePlanningProblem(
- # discount_rates=discount_rates,
- time_frame=time_frame,
- # reporting_periods=time_frame.reporting_periods,
- # time_intervals=time_frame.time_interval_durations,
- time_weights=time_weights,
- normalised_time_interval_duration=normalised_time_interval_duration,
- assessment_weights=assessment_weights,
- )
-
- # add networks and systems
-
- for netkey, net in networks.items():
- ipp.add_network(network_key=netkey, network=net)
-
- # add converters
-
- for cvtkey, cvt in converters.items():
- ipp.add_converter(converter_key=cvtkey, converter=cvt)
-
- # define arcs as mandatory
-
- if type(mandatory_arcs) == list:
- for full_arc_key in mandatory_arcs:
- ipp.make_arc_mandatory(full_arc_key[0], full_arc_key[1:])
-
- # if make_all_arcs_mandatory:
-
- # for network_key in ipp.networks:
-
- # for arc_key in ipp.networks[network_key].edges(keys=True):
-
- # # preexisting arcs are no good
-
- # if ipp.networks[network_key].edges[arc_key][
- # Network.KEY_ARC_TECH].has_been_selected():
-
- # continue
-
- # ipp.make_arc_mandatory(network_key, arc_key)
-
- # set up the use of sos for arc selection
-
- if use_sos_arcs:
- for network_key in ipp.networks:
- for arc_key in ipp.networks[network_key].edges(keys=True):
- if (
- ipp.networks[network_key]
- .edges[arc_key][Network.KEY_ARC_TECH]
- .has_been_selected()
- ):
- continue
-
- ipp.use_sos1_for_arc_selection(
- network_key,
- arc_key,
- use_real_variables_if_possible=(
- arc_use_real_variables_if_possible
- ),
- sos1_weight_method=arc_sos_weight_key,
- )
-
- # set up the use of sos for flow sense determination
-
- if use_sos_sense:
- for network_key in ipp.networks:
- for arc_key in ipp.networks[network_key].edges(keys=True):
- if not ipp.networks[network_key].edges[arc_key][
- Network.KEY_ARC_UND
- ]:
- continue
-
- ipp.use_sos1_for_flow_senses(
- network_key,
- arc_key,
- use_real_variables_if_possible=(
- sense_use_real_variables_if_possible
- ),
- use_interface_variables=sense_use_arc_interfaces,
- sos1_weight_method=sense_sos_weight_key,
- )
-
- elif sense_use_arc_interfaces: # set up the use of arc interfaces w/o sos1
- for network_key in ipp.networks:
- for arc_key in ipp.networks[network_key].edges(keys=True):
- if (
- ipp.networks[network_key]
- .edges[arc_key][Network.KEY_ARC_TECH]
- .has_been_selected()
- ):
- continue
-
- ipp.use_interface_variables_for_arc_selection(network_key, arc_key)
-
- # static losses
-
- if static_losses_mode == ipp.STATIC_LOSS_MODE_ARR:
- ipp.place_static_losses_arrival_node()
-
- elif static_losses_mode == ipp.STATIC_LOSS_MODE_DEP:
- ipp.place_static_losses_departure_node()
-
- elif static_losses_mode == ipp.STATIC_LOSS_MODE_US:
- ipp.place_static_losses_upstream()
-
- elif static_losses_mode == ipp.STATIC_LOSS_MODE_DS:
- ipp.place_static_losses_downstream()
-
- else:
- raise ValueError("Unknown static loss modelling mode.")
-
- # *********************************************************************
-
- # groups
-
- if type(arc_groups_dict) != type(None):
- for key in arc_groups_dict:
- ipp.create_arc_group(arc_groups_dict[key])
-
- # *********************************************************************
-
- # maximum number of parallel arcs
-
- for key in max_number_parallel_arcs:
- ipp.set_maximum_number_parallel_arcs(
- network_key=key[0],
- node_a=key[1],
- node_b=key[2],
- limit=max_number_parallel_arcs[key],
- )
-
- # *********************************************************************
-
- if simplify_problem:
- ipp.simplify_peak_total_assessments()
-
- # *********************************************************************
-
- # instantiate (disable the default case v-a-v fixed losses)
-
- # ipp.instantiate(place_fixed_losses_upstream_if_possible=False)
-
- ipp.instantiate(initialise_ancillary_sets=init_aux_sets)
-
- # optimise
- ipp.optimise(
- solver_name=solver,
- solver_options=solver_options,
- output_options={},
- print_solver_output=print_solver_output,
- )
-
- # return the problem object
-
- return ipp
-
- # *********************************************************************
- # *********************************************************************
# *************************************************************************
# *************************************************************************
-
- def test_single_network_single_arc_problem(self):
+
+ @pytest.mark.parametrize(
+ "solver, use_sos_arcs, arc_sos_weight_key",
+ [('scip', True, InfrastructurePlanningProblem.SOS1_ARC_WEIGHTS_CAP),
+ ('scip', False, None)]
+ )
+ def test_single_network_single_arc_problem(self, solver, use_sos_arcs, arc_sos_weight_key):
# assessment
q = 0
@@ -291,12 +78,12 @@ class TestESIPPProblem:
)
mynet.add_directed_arc(node_key_a=node_IMP, node_key_b=node_A, arcs=arc_tech_IA)
- # identify node types
- mynet.identify_node_types()
-
# no sos, regular time intervals
- ipp = self.build_solve_ipp(
+ ipp = build_solve_ipp(
+ solver=solver,
solver_options={},
+ use_sos_arcs=use_sos_arcs,
+ arc_sos_weight_key=arc_sos_weight_key,
perform_analysis=False,
plot_results=False, # True,
print_solver_output=False,
@@ -312,11 +99,12 @@ class TestESIPPProblem:
# *********************************************************************
# validation
-
+ assert len(ipp.instance.constr_arc_sos1) == 0
assert ipp.has_peak_total_assessments()
- assert ipp.results["Problem"][0]["Number of constraints"] == 24
- assert ipp.results["Problem"][0]["Number of variables"] == 22
- assert ipp.results["Problem"][0]["Number of nonzeros"] == 49
+ # assert ipp.results["Problem"][0]["Number of constraints"] == 24
+ # assert ipp.results["Problem"][0]["Number of variables"] == 22
+ # assert ipp.results["Problem"][0]["Number of nonzeros"] == 49
+ # check_problem_size(ipp, 24, 22, 49)
# the arc should be installed since it is required for feasibility
assert (
@@ -361,7 +149,7 @@ class TestESIPPProblem:
# *************************************************************************
# *************************************************************************
-
+
def test_single_network_two_arcs_problem(self):
# TODO: test simplifying this problem
@@ -434,13 +222,12 @@ class TestESIPPProblem:
validate=False,
)
mynet.add_directed_arc(node_key_a=node_A, node_key_b=node_EXP, arcs=arc_tech_AE)
-
- # identify node types
- mynet.identify_node_types()
# no sos, regular time intervals
- ipp = self.build_solve_ipp(
+ ipp = build_solve_ipp(
solver_options={},
+ # use_sos_arcs=use_sos_arcs,
+ # arc_sos_weight_key=arc_sos_weight_key,
perform_analysis=False,
plot_results=False, # True,
print_solver_output=False,
@@ -507,7 +294,12 @@ class TestESIPPProblem:
# *************************************************************************
# *************************************************************************
- def test_single_network_single_arc_problem_simpler(self):
+ @pytest.mark.parametrize(
+ "solver, use_sos_arcs, arc_sos_weight_key",
+ [('scip', True, InfrastructurePlanningProblem.SOS1_ARC_WEIGHTS_COST),
+ ('scip', False, None)]
+ )
+ def test_single_network_single_arc_problem_simpler(self, solver, use_sos_arcs, arc_sos_weight_key):
# assessment
q = 0
@@ -554,11 +346,9 @@ class TestESIPPProblem:
)
mynet.add_directed_arc(node_key_a=node_IMP, node_key_b=node_A, arcs=arc_tech_IA)
- # identify node types
- mynet.identify_node_types()
-
# no sos, regular time intervals
- ipp = self.build_solve_ipp(
+ ipp = build_solve_ipp(
+ solver=solver,
solver_options={},
perform_analysis=False,
plot_results=False, # True,
@@ -570,11 +360,13 @@ class TestESIPPProblem:
max_number_parallel_arcs={},
simplify_problem=True,
)
-
+ # validation
+ assert len(ipp.instance.constr_arc_sos1) == 0
assert ipp.has_peak_total_assessments()
- assert ipp.results["Problem"][0]["Number of constraints"] == 16 # 20
- assert ipp.results["Problem"][0]["Number of variables"] == 15 # 19
- assert ipp.results["Problem"][0]["Number of nonzeros"] == 28 # 36
+ # assert ipp.results["Problem"][0]["Number of constraints"] == 16 # 20
+ # assert ipp.results["Problem"][0]["Number of variables"] == 15 # 19
+ # assert ipp.results["Problem"][0]["Number of nonzeros"] == 28 # 36
+ # check_problem_size(ipp, 16, 15, 28)
# *********************************************************************
# *********************************************************************
@@ -660,13 +452,9 @@ class TestESIPPProblem:
mynet.add_directed_arc(node_key_a=node_IMP, node_key_b=node_A, arcs=arc_tech_IA)
- # identify node types
-
- mynet.identify_node_types()
-
# no sos, regular time intervals
- ipp = self.build_solve_ipp(
+ ipp = build_solve_ipp(
solver_options={},
perform_analysis=False,
plot_results=False, # True,
@@ -785,11 +573,8 @@ class TestESIPPProblem:
)
mynet.add_directed_arc(node_key_a=node_IMP, node_key_b=node_A, arcs=arc_tech_IA)
- # identify node types
- mynet.identify_node_types()
-
# no sos, regular time intervals
- ipp = self.build_solve_ipp(
+ ipp = build_solve_ipp(
solver_options={},
perform_analysis=False,
plot_results=False, # True,
@@ -871,11 +656,8 @@ class TestESIPPProblem:
)
mynet.add_directed_arc(node_key_a=node_IMP, node_key_b=node_A, arcs=arc_tech_IA)
- # identify node types
- mynet.identify_node_types()
-
# no sos, regular time intervals
- ipp = self.build_solve_ipp(
+ ipp = build_solve_ipp(
solver_options={},
perform_analysis=False,
plot_results=False, # True,
@@ -997,11 +779,8 @@ class TestESIPPProblem:
)
mynet.add_directed_arc(node_key_a=node_IMP, node_key_b=node_A, arcs=arc_tech_IA)
- # identify node types
- mynet.identify_node_types()
-
# no sos, regular time intervals
- ipp = self.build_solve_ipp(
+ ipp = build_solve_ipp(
solver_options={},
perform_analysis=False,
plot_results=False, # True,
@@ -1045,8 +824,17 @@ class TestESIPPProblem:
# problem with symmetrical nodes and one undirected arc, irregular steps
# same problem as the previous one, except with interface variables
# problem with two symmetrical nodes and one undirected arc, w/ simple sos1
-
- def test_isolated_undirected_network(self):
+
+ @pytest.mark.parametrize(
+ "solver, use_sos_arcs, arc_sos_weight_key",
+ [('scip', True, InfrastructurePlanningProblem.SOS1_ARC_WEIGHTS_NONE),
+ # ('scip', True, InfrastructurePlanningProblem.SOS1_ARC_WEIGHTS_CAP),
+ # ('scip', True, InfrastructurePlanningProblem.SOS1_ARC_WEIGHTS_COST),
+ # ('scip', True, InfrastructurePlanningProblem.SOS1_ARC_WEIGHTS_SPEC_CAP),
+ # ('scip', True, InfrastructurePlanningProblem.SOS1_ARC_WEIGHTS_SPEC_COST),
+ ('scip', False, None)]
+ )
+ def test_isolated_undirected_network(self, solver, use_sos_arcs, arc_sos_weight_key):
q = 0
tf = EconomicTimeFrame(
@@ -1090,11 +878,12 @@ class TestESIPPProblem:
node_key_a=node_A, node_key_b=node_B, arcs=arc_tech_AB
)
- # identify node types
- mynet.identify_node_types()
-
# no sos, regular time intervals
- ipp = self.build_solve_ipp(
+ solver = 'scip'
+ ipp = build_solve_ipp(
+ solver=solver,
+ use_sos_arcs=use_sos_arcs,
+ arc_sos_weight_key=arc_sos_weight_key,
solver_options={},
perform_analysis=False,
plot_results=False, # True,
@@ -1106,10 +895,15 @@ class TestESIPPProblem:
max_number_parallel_arcs={}
)
+ if use_sos_arcs:
+ assert len(ipp.instance.constr_arc_sos1) != 0
+ else:
+ assert len(ipp.instance.constr_arc_sos1) == 0
+
assert ipp.has_peak_total_assessments() # TODO: make sure this is true
- assert ipp.results["Problem"][0]["Number of constraints"] == 34
- assert ipp.results["Problem"][0]["Number of variables"] == 28
- assert ipp.results["Problem"][0]["Number of nonzeros"] == 105
+ # assert ipp.results["Problem"][0]["Number of constraints"] == 34
+ # assert ipp.results["Problem"][0]["Number of variables"] == 28
+ # assert ipp.results["Problem"][0]["Number of nonzeros"] == 105
# *********************************************************************
# *********************************************************************
@@ -1183,11 +977,10 @@ class TestESIPPProblem:
node_key_a=node_A, node_key_b=node_B, arcs=arc_tech_AB
)
- # identify node types
- mynet.identify_node_types()
-
# no sos, regular time intervals
- ipp = self.build_solve_ipp(
+ solver = 'scip'
+ ipp = build_solve_ipp(
+ solver=solver,
solver_options={},
perform_analysis=False,
plot_results=False,
@@ -1199,10 +992,18 @@ class TestESIPPProblem:
max_number_parallel_arcs={}
)
- assert ipp.has_peak_total_assessments()
- assert ipp.results["Problem"][0]["Number of constraints"] == 34
- assert ipp.results["Problem"][0]["Number of variables"] == 24
- assert ipp.results["Problem"][0]["Number of nonzeros"] == 77
+ if solver == 'scip':
+ assert len(ipp.instance.constr_arc_sos1) == 0
+ assert ipp.has_peak_total_assessments() # TODO: make sure this is true
+ assert ipp.results["Problem"][0]["Number of constraints"] == 0 # 34
+ assert ipp.results["Problem"][0]["Number of variables"] == 23 # 24
+ # assert ipp.results["Problem"][0]["Number of nonzeros"] == 77
+ else:
+ assert len(ipp.instance.constr_arc_sos1) == 0
+ assert ipp.has_peak_total_assessments() # TODO: make sure this is true
+ assert ipp.results["Problem"][0]["Number of constraints"] == 34
+ assert ipp.results["Problem"][0]["Number of variables"] == 24
+ assert ipp.results["Problem"][0]["Number of nonzeros"] == 77
# *********************************************************************
# *********************************************************************
@@ -1287,11 +1088,9 @@ class TestESIPPProblem:
capacity_is_instantaneous=capacity_is_instantaneous,
)
- # identify node types
- mynet.identify_node_types()
-
# no sos, regular time intervals
- ipp = self.build_solve_ipp(
+ ipp = build_solve_ipp(
+ solver='scip',
solver_options={},
perform_analysis=False,
plot_results=False, # True,
@@ -1357,11 +1156,9 @@ class TestESIPPProblem:
static_loss=None,
)
- # identify node types
- mynet.identify_node_types()
-
# no sos, regular time intervals
- ipp = self.build_solve_ipp(
+ ipp = build_solve_ipp(
+ solver='scip',
solver_options={},
perform_analysis=False,
plot_results=False, # True,
@@ -1380,8 +1177,17 @@ class TestESIPPProblem:
# *************************************************************************
# *************************************************************************
-
- def test_nonisolated_undirected_network(self):
+
+ @pytest.mark.parametrize(
+ "solver, use_sos_arcs, arc_sos_weight_key",
+ [('scip', True, InfrastructurePlanningProblem.SOS1_ARC_WEIGHTS_NONE),
+ ('scip', True, InfrastructurePlanningProblem.SOS1_ARC_WEIGHTS_CAP),
+ ('scip', True, InfrastructurePlanningProblem.SOS1_ARC_WEIGHTS_COST),
+ ('scip', True, InfrastructurePlanningProblem.SOS1_ARC_WEIGHTS_SPEC_CAP),
+ ('scip', True, InfrastructurePlanningProblem.SOS1_ARC_WEIGHTS_SPEC_COST),
+ ('scip', False, None)]
+ )
+ def test_nonisolated_undirected_network(self, solver, use_sos_arcs, arc_sos_weight_key):
# scenario
q = 0
@@ -1485,12 +1291,12 @@ class TestESIPPProblem:
node_key_a=node_A, node_key_b=node_B, arcs=arc_tech_AB
)
- # identify node types
- mynet.identify_node_types()
-
# no sos, regular time intervals
- ipp = self.build_solve_ipp(
+ ipp = build_solve_ipp(
+ solver=solver,
solver_options={},
+ use_sos_arcs=use_sos_arcs,
+ arc_sos_weight_key=arc_sos_weight_key,
perform_analysis=False,
plot_results=False, # True,
print_solver_output=False,
@@ -1501,10 +1307,19 @@ class TestESIPPProblem:
max_number_parallel_arcs={}
)
- assert ipp.has_peak_total_assessments()
- assert ipp.results["Problem"][0]["Number of constraints"] == 80
- assert ipp.results["Problem"][0]["Number of variables"] == 84
- assert ipp.results["Problem"][0]["Number of nonzeros"] == 253
+ # validation
+ if use_sos_arcs:
+ assert len(ipp.instance.constr_arc_sos1) == 3
+ assert ipp.has_peak_total_assessments()
+ # assert ipp.results["Problem"][0]["Number of constraints"] == 0 # 80
+ # assert ipp.results["Problem"][0]["Number of variables"] == 83 # 84
+ # # assert ipp.results["Problem"][0]["Number of nonzeros"] == 253
+ else:
+ assert len(ipp.instance.constr_arc_sos1) == 0
+ assert ipp.has_peak_total_assessments()
+ # assert ipp.results["Problem"][0]["Number of constraints"] == 0 # 80
+ # assert ipp.results["Problem"][0]["Number of variables"] == 83 # 84
+ # # assert ipp.results["Problem"][0]["Number of nonzeros"] == 253
# **************************************************************************
@@ -1551,8 +1366,17 @@ class TestESIPPProblem:
# *************************************************************************
# *************************************************************************
-
- def test_nonisolated_undirected_network_diff_tech(self):
+
+ @pytest.mark.parametrize(
+ "solver, use_sos_arcs, arc_sos_weight_key",
+ [('scip', True, InfrastructurePlanningProblem.SOS1_ARC_WEIGHTS_NONE),
+ # ('scip', True, InfrastructurePlanningProblem.SOS1_ARC_WEIGHTS_CAP),
+ # ('scip', True, InfrastructurePlanningProblem.SOS1_ARC_WEIGHTS_COST),
+ # ('scip', True, InfrastructurePlanningProblem.SOS1_ARC_WEIGHTS_SPEC_CAP),
+ # ('scip', True, InfrastructurePlanningProblem.SOS1_ARC_WEIGHTS_SPEC_COST),
+ ('scip', False, None)]
+ )
+ def test_nonisolated_undirected_network_diff_tech(self, solver, use_sos_arcs, arc_sos_weight_key):
# scenario
q = 0
@@ -1655,12 +1479,12 @@ class TestESIPPProblem:
node_key_a=node_A, node_key_b=node_B, arcs=arc_tech_AB
)
- # identify node types
- mynet.identify_node_types()
-
# no sos, regular time intervals
- ipp = self.build_solve_ipp(
+ ipp = build_solve_ipp(
+ solver=solver,
solver_options={},
+ use_sos_arcs=use_sos_arcs,
+ arc_sos_weight_key=arc_sos_weight_key,
perform_analysis=False,
plot_results=False, # True,
print_solver_output=False,
@@ -1671,10 +1495,25 @@ class TestESIPPProblem:
max_number_parallel_arcs={}
)
- assert ipp.has_peak_total_assessments()
- assert ipp.results["Problem"][0]["Number of constraints"] == 80
- assert ipp.results["Problem"][0]["Number of variables"] == 84
- assert ipp.results["Problem"][0]["Number of nonzeros"] == 253
+ # validation
+ # ipp.instance.constr_arc_sos1.pprint()
+ # print(ipp.results["Problem"][0])
+ if use_sos_arcs:
+ # print(ipp.results["Problem"][0])
+ assert len(ipp.instance.constr_arc_sos1) == 3
+ assert ipp.has_peak_total_assessments()
+ # assert ipp.results["Problem"][0]["Number of constraints"] == 0 # should be 80
+ # assert ipp.results["Problem"][0]["Number of variables"] == 83 # should be 84
+ # assert ipp.results["Problem"][0]["Number of nonzeros"] == 253
+ # check_problem_size(ipp, 0, 83, 253)
+ else:
+ # print(ipp.results["Problem"][0])
+ assert len(ipp.instance.constr_arc_sos1) == 0
+ assert ipp.has_peak_total_assessments()
+ # assert ipp.results["Problem"][0]["Number of constraints"] == 0 # should be 80
+ # assert ipp.results["Problem"][0]["Number of variables"] == 83 # should be 84
+ # assert ipp.results["Problem"][0]["Number of nonzeros"] == 253
+ # check_problem_size(ipp, 0, 83, 253)
# *********************************************************************
# *********************************************************************
@@ -1720,7 +1559,13 @@ class TestESIPPProblem:
# *************************************************************************
# *************************************************************************
- def test_nonisolated_network_preexisting_directed_arcs(self):
+ @pytest.mark.parametrize(
+ "solver, use_sos_arcs, arc_sos_weight_key",
+ [('scip', True, InfrastructurePlanningProblem.SOS1_ARC_WEIGHTS_NONE),
+ ('scip', True, InfrastructurePlanningProblem.SOS1_ARC_WEIGHTS_CAP),
+ ('scip', False, None)]
+ )
+ def test_nonisolated_network_preexisting_directed_arcs(self, solver, use_sos_arcs, arc_sos_weight_key):
# time frame
q = 0
@@ -1820,12 +1665,12 @@ class TestESIPPProblem:
node_key_a=node_A, node_key_b=node_B, arcs=arc_tech_AB
)
- # identify node types
- mynet.identify_node_types()
-
# no sos, regular time intervals
- ipp = self.build_solve_ipp(
+ ipp = build_solve_ipp(
+ solver=solver,
solver_options={},
+ use_sos_arcs=use_sos_arcs,
+ arc_sos_weight_key=arc_sos_weight_key,
perform_analysis=False,
plot_results=False, # True,
print_solver_output=False,
@@ -1839,6 +1684,10 @@ class TestESIPPProblem:
# *********************************************************************
# validation
+ if use_sos_arcs:
+ assert len(ipp.instance.constr_arc_sos1) != 0
+ else:
+ assert len(ipp.instance.constr_arc_sos1) == 0
# network is still isolated
# the undirected arc was installed
assert (
@@ -1860,7 +1709,21 @@ class TestESIPPProblem:
# *************************************************************************
# *************************************************************************
- def test_nonisolated_network_preexisting_directed_arcs_diff_tech(self):
+ @pytest.mark.parametrize(
+ "solver, use_sos_arcs, arc_sos_weight_key",
+ [('scip', True, InfrastructurePlanningProblem.SOS1_ARC_WEIGHTS_NONE),
+ ('scip', True, InfrastructurePlanningProblem.SOS1_ARC_WEIGHTS_CAP),
+ ('scip', True, InfrastructurePlanningProblem.SOS1_ARC_WEIGHTS_COST),
+ ('scip', True, InfrastructurePlanningProblem.SOS1_ARC_WEIGHTS_SPEC_CAP),
+ ('scip', True, InfrastructurePlanningProblem.SOS1_ARC_WEIGHTS_SPEC_COST),
+ ('scip', False, None)]
+ )
+ def test_nonisolated_network_preexisting_directed_arcs_diff_tech(
+ self,
+ solver,
+ use_sos_arcs,
+ arc_sos_weight_key
+ ):
# time frame
q = 0
@@ -1961,12 +1824,12 @@ class TestESIPPProblem:
node_key_a=node_A, node_key_b=node_B, arcs=arc_tech_AB
)
- # identify node types
- mynet.identify_node_types()
-
# no sos, regular time intervals
- ipp = self.build_solve_ipp(
- solver_options={},solver='scip',
+ ipp = build_solve_ipp(
+ solver=solver,
+ solver_options={},
+ use_sos_arcs=use_sos_arcs,
+ arc_sos_weight_key=arc_sos_weight_key,
perform_analysis=False,
plot_results=False, # True,
print_solver_output=False,
@@ -1980,6 +1843,10 @@ class TestESIPPProblem:
# **************************************************************************
# validation
+ if use_sos_arcs:
+ assert len(ipp.instance.constr_arc_sos1) != 0
+ else:
+ assert len(ipp.instance.constr_arc_sos1) == 0
# the undirected arc should be installed since it is cheaper tham imp.
assert (
True
@@ -2187,15 +2054,13 @@ class TestESIPPProblem:
)
}
- # identify node types
- mynet.identify_node_types()
-
# no sos, regular time intervals
solver_options = {}
solver_options["relative_mip_gap"] = 0
solver_options["absolute_mip_gap"] = 1e-4
- ipp = self.build_solve_ipp(
+ ipp = build_solve_ipp(
+ solver='scip',
solver_options=solver_options,
use_sos_arcs=False,
arc_sos_weight_key=None,
@@ -2218,6 +2083,7 @@ class TestESIPPProblem:
# *********************************************************************
# overview
+ assert len(ipp.instance.constr_arc_sos1) == 0
(imports_qpk,
exports_qpk,
@@ -2524,18 +2390,16 @@ class TestESIPPProblem:
# do not use arc groups
arc_groups_dict = {}
- # identify node types
-
- mynet.identify_node_types()
-
# no sos, regular time intervals
solver_options = {}
solver_options["relative_mip_gap"] = 0
solver_options["absolute_mip_gap"] = 1e-4
- ipp = self.build_solve_ipp(
+ ipp = build_solve_ipp(
+ solver='glpk',
solver_options=solver_options,
use_sos_arcs=False,
+ use_sos_arc_groups=False,
arc_sos_weight_key=None,
arc_use_real_variables_if_possible=False,
use_sos_sense=False,
@@ -2553,7 +2417,10 @@ class TestESIPPProblem:
arc_groups_dict=arc_groups_dict
)
- # **************************************************************************
+ # *********************************************************************
+
+ # validation
+ assert len(ipp.instance.constr_arc_group_sos1) == 0
# overview
(imports_qpk,
@@ -2660,7 +2527,12 @@ class TestESIPPProblem:
# *************************************************************************
# *************************************************************************
- def test_arc_groups_individual_undirected(self):
+ @pytest.mark.parametrize(
+ "solver, use_sos_arc_groups, arc_sos_weight_key",
+ [('scip', True, InfrastructurePlanningProblem.SOS1_ARC_WEIGHTS_CAP),
+ ('scip', False, None)]
+ )
+ def test_arc_groups_individual_undirected(self, solver, use_sos_arc_groups, arc_sos_weight_key):
# time frame
q = 0
@@ -2796,9 +2668,6 @@ class TestESIPPProblem:
)
}
- # identify node types
- mynet.identify_node_types()
-
# solver settings
solver_options = {}
solver_options["relative_mip_gap"] = 0
@@ -2821,10 +2690,12 @@ class TestESIPPProblem:
Network.KEY_ARC_TECH].options_selected.index(True)
] = False
- ipp = self.build_solve_ipp(
+ ipp = build_solve_ipp(
+ solver=solver,
solver_options=solver_options,
use_sos_arcs=False,
- arc_sos_weight_key=None,
+ use_sos_arc_groups=use_sos_arc_groups,
+ arc_sos_weight_key=arc_sos_weight_key,
arc_use_real_variables_if_possible=False,
use_sos_sense=False,
sense_sos_weight_key=None,
@@ -2841,6 +2712,11 @@ class TestESIPPProblem:
arc_groups_dict=arc_groups_dict
)
+ if use_sos_arc_groups:
+ assert len(ipp.instance.constr_arc_group_sos1) != 0
+ else:
+ assert len(ipp.instance.constr_arc_group_sos1) == 0
+
# overview
(imports_qpk,
exports_qpk,
@@ -3107,9 +2983,6 @@ class TestESIPPProblem:
# arc groups
arc_groups_dict = {}
- # identify node types
- mynet.identify_node_types()
-
# solver settings
solver_options = {}
solver_options["relative_mip_gap"] = 0
@@ -3132,7 +3005,8 @@ class TestESIPPProblem:
Network.KEY_ARC_TECH].options_selected.index(True)
] = False
- ipp = self.build_solve_ipp(
+ ipp = build_solve_ipp(
+ solver='scip',
solver_options=solver_options,
perform_analysis=False,
plot_results=False, # True,
@@ -3299,11 +3173,9 @@ class TestESIPPProblem:
node_key_a=imp_node_key, node_key_b=exp_node_key, arcs=arc_tech_IE
)
- # identify node types
- mynet.identify_node_types()
-
# no sos, regular time intervals
- ipp = self.build_solve_ipp(
+ ipp = build_solve_ipp(
+ solver='scip',
solver_options={},
perform_analysis=False,
plot_results=False, # True,
@@ -3462,11 +3334,6 @@ class TestESIPPProblem:
arc_key_AB_und = mynet.add_undirected_arc(
node_key_a=node_A, node_key_b=node_B, arcs=arcs_ab
)
-
-
- # identify node types
-
- mynet.identify_node_types()
# no sos, regular time intervals
@@ -3492,7 +3359,8 @@ class TestESIPPProblem:
Network.KEY_ARC_TECH].options_selected.index(True)
] = False
- ipp = self.build_solve_ipp(
+ ipp = build_solve_ipp(
+ solver='scip',
solver_options={},
use_sos_arcs=False,
arc_sos_weight_key=None,
@@ -3855,10 +3723,6 @@ class TestESIPPProblem:
capacity_is_instantaneous=False,
)
- # identify node types
-
- mynet.identify_node_types()
-
# no sos, regular time intervals
for static_losses_mode in InfrastructurePlanningProblem.STATIC_LOSS_MODES:
@@ -3883,7 +3747,8 @@ class TestESIPPProblem:
Network.KEY_ARC_TECH].options_selected.index(True)
] = False
- ipp = self.build_solve_ipp(
+ ipp = build_solve_ipp(
+ solver='scip',
solver_options={},
use_sos_arcs=False,
arc_sos_weight_key=None,
@@ -4270,14 +4135,12 @@ class TestESIPPProblem:
node_key_a=node_A, node_key_b=node_B, arcs=arcs_ab
)
- # identify node types
- mynet.identify_node_types()
-
# no sos, regular time intervals
for static_losses_mode in InfrastructurePlanningProblem.STATIC_LOSS_MODES:
- ipp = self.build_solve_ipp(
+ ipp = build_solve_ipp(
+ solver='scip',
solver_options={},
perform_analysis=False,
plot_results=False, # True,
@@ -4895,14 +4758,12 @@ class TestESIPPProblem:
capacity_is_instantaneous=False,
)
- # identify node types
- mynet.identify_node_types()
-
# no sos, regular time intervals
for static_losses_mode in InfrastructurePlanningProblem.STATIC_LOSS_MODES:
- ipp = self.build_solve_ipp(
+ ipp = build_solve_ipp(
+ solver='scip',
solver_options={},
perform_analysis=False,
plot_results=False, # True,
@@ -5457,9 +5318,6 @@ class TestESIPPProblem:
)
mynet.add_directed_arc(node_key_a=node_A, node_key_b=node_B, arcs=arc_tech_AB)
- # identify node types
- mynet.identify_node_types()
-
# no sos, regular time intervals
for static_losses_mode in [
InfrastructurePlanningProblem.STATIC_LOSS_MODE_ARR,
@@ -5474,7 +5332,8 @@ class TestESIPPProblem:
Network.KEY_ARC_TECH].options_selected.index(True)
] = False
- ipp = self.build_solve_ipp(
+ ipp = build_solve_ipp(
+ solver='scip',
solver_options={},
perform_analysis=False,
plot_results=False,
@@ -5615,17 +5474,14 @@ class TestESIPPProblem:
# arc_tech_AB.options_selected[0] = True
# mynet.add_directed_arc(node_key_a=node_A, node_key_b=node_B, arcs=arc_tech_AB)
- # identify node types
- mynet.identify_node_types()
-
# no sos, regular time intervals
for static_losses_mode in [
InfrastructurePlanningProblem.STATIC_LOSS_MODE_ARR,
InfrastructurePlanningProblem.STATIC_LOSS_MODE_DEP
]:
# TODO: make this work with GLPK and SCIP
- ipp = self.build_solve_ipp(
- solver='cbc', # does not work with GLPK nor SCIP
+ ipp = build_solve_ipp(
+ solver='scip', # does not work with GLPK nor SCIP
solver_options={},
perform_analysis=False,
plot_results=False, # True,
@@ -5761,9 +5617,6 @@ class TestESIPPProblem:
arc_key_AB_und = mynet.add_undirected_arc(
node_key_a=node_A, node_key_b=node_B, arcs=arc_tech_AB
)
-
- # identify node types
- mynet.identify_node_types()
# no sos, regular time intervals
for static_losses_mode in InfrastructurePlanningProblem.STATIC_LOSS_MODES:
@@ -5776,7 +5629,8 @@ class TestESIPPProblem:
Network.KEY_ARC_TECH].options_selected.index(True)
] = False
- ipp = self.build_solve_ipp(
+ ipp = build_solve_ipp(
+ solver='scip',
solver_options={},
perform_analysis=False,
plot_results=False, # True,
@@ -6038,9 +5892,6 @@ class TestESIPPProblem:
capacity=1.0,
capacity_is_instantaneous=False,
)
-
- # identify node types
- mynet.identify_node_types()
# no sos, regular time intervals
for static_losses_mode in InfrastructurePlanningProblem.STATIC_LOSS_MODES:
@@ -6053,7 +5904,8 @@ class TestESIPPProblem:
Network.KEY_ARC_TECH].options_selected.index(True)
] = False
- ipp = self.build_solve_ipp(
+ ipp = build_solve_ipp(
+ solver='scip',
solver_options={},
perform_analysis=False,
plot_results=False, # True,
@@ -6321,9 +6173,6 @@ class TestESIPPProblem:
arc_key_AB_und = mynet.add_undirected_arc(
node_key_a=node_B, node_key_b=node_A, arcs=arc_tech_AB
)
-
- # identify node types
- mynet.identify_node_types()
# no sos, regular time intervals
for static_losses_mode in InfrastructurePlanningProblem.STATIC_LOSS_MODES:
@@ -6336,7 +6185,8 @@ class TestESIPPProblem:
Network.KEY_ARC_TECH].options_selected.index(True)
] = False
- ipp = self.build_solve_ipp(
+ ipp = build_solve_ipp(
+ solver='scip',
solver_options={},
perform_analysis=False,
plot_results=False, # True,
@@ -6599,9 +6449,6 @@ class TestESIPPProblem:
capacity=1.0,
capacity_is_instantaneous=False,
)
-
- # identify node types
- mynet.identify_node_types()
# no sos, regular time intervals
for static_losses_mode in InfrastructurePlanningProblem.STATIC_LOSS_MODES:
@@ -6614,7 +6461,8 @@ class TestESIPPProblem:
# Network.KEY_ARC_TECH].options_selected.index(True)
# ] = False
- ipp = self.build_solve_ipp(
+ ipp = build_solve_ipp(
+ solver='scip',
solver_options={},
perform_analysis=False,
plot_results=False, # True,
@@ -6917,12 +6765,10 @@ class TestESIPPProblem:
)
mynet.add_directed_arc(node_key_a=node_A, node_key_b=node_B, arcs=arcs_ab)
- # identify node types
- mynet.identify_node_types()
-
# no sos, regular time intervals
- ipp = self.build_solve_ipp(
+ ipp = build_solve_ipp(
+ solver='scip',
solver_options={},
plot_results=False, # True,
print_solver_output=False,
@@ -7085,13 +6931,10 @@ class TestESIPPProblem:
capacity_is_instantaneous=False,
)
- # identify node types
- mynet.identify_node_types()
-
# no sos, regular time intervals
- ipp = self.build_solve_ipp(
- solver='cbc', # TODO: make this work with other solvers
+ ipp = build_solve_ipp(
+ solver='scip', # TODO: make this work with other solvers
solver_options={},
plot_results=False, # True,
print_solver_output=False,
@@ -7229,12 +7072,9 @@ class TestESIPPProblem:
)
mynet.add_directed_arc(node_key_a=imp_node_key, node_key_b=node_A, arcs=arcs_ia2)
- # identify node types
- mynet.identify_node_types()
-
# no sos, regular time intervals
- ipp = self.build_solve_ipp(
- solver='cbc', # TODO: make this work with other solvers
+ ipp = build_solve_ipp(
+ solver='scip', # TODO: make this work with other solvers
solver_options={},
plot_results=False, # True,
print_solver_output=False,
@@ -7359,12 +7199,9 @@ class TestESIPPProblem:
capacity_is_instantaneous=False,
)
- # identify node types
- mynet.identify_node_types()
-
# no sos, regular time intervals
- ipp = self.build_solve_ipp(
- solver='cbc', # TODO: make this work with other solvers
+ ipp = build_solve_ipp(
+ solver='scip', # TODO: make this work with other solvers
solver_options={},
plot_results=False, # True,
print_solver_output=False,
@@ -7524,7 +7361,7 @@ class TestESIPPProblem:
# # no sos, regular time intervals
- # ipp = self.build_solve_ipp(
+ # ipp = build_solve_ipp(
# solver_options={},
# perform_analysis=False,
# plot_results=False, # True,
@@ -7592,7 +7429,6 @@ class TestESIPPProblem:
# TODO: test non-simplifiable problems with time varying prices on select assessments
# TODO: test non-simplifiable problems with volume varying prices on select assessments
-
# *************************************************************************
# *************************************************************************
@@ -7687,11 +7523,9 @@ class TestESIPPProblem:
)
mynet.add_directed_arc(*node_pair, arcs=new_arc_tech)
- # identify node types
- mynet.identify_node_types()
-
# no sos, regular time intervals
- ipp = self.build_solve_ipp(
+ ipp = build_solve_ipp(
+ solver='scip',
solver_options={},
perform_analysis=False,
plot_results=False, # True,
@@ -7704,9 +7538,6 @@ class TestESIPPProblem:
simplify_problem=True,
)
assert ipp.has_peak_total_assessments()
- assert ipp.results["Problem"][0]["Number of constraints"] == 61
- assert ipp.results["Problem"][0]["Number of variables"] == 53
- assert ipp.results["Problem"][0]["Number of nonzeros"] == 143
# *********************************************************************
# *********************************************************************
@@ -7833,11 +7664,9 @@ class TestESIPPProblem:
)
mynet.add_directed_arc(*node_pair, arcs=new_arc_tech)
- # identify node types
- mynet.identify_node_types()
-
# no sos, regular time intervals
- ipp = self.build_solve_ipp(
+ ipp = build_solve_ipp(
+ solver='scip',
solver_options={},
perform_analysis=False,
plot_results=False, # True,
@@ -7850,9 +7679,6 @@ class TestESIPPProblem:
simplify_problem=True,
)
assert ipp.has_peak_total_assessments()
- assert ipp.results["Problem"][0]["Number of constraints"] == 61
- assert ipp.results["Problem"][0]["Number of variables"] == 53
- assert ipp.results["Problem"][0]["Number of nonzeros"] == 143 #
# *********************************************************************
# *********************************************************************
diff --git a/tests/test_esipp_resource.py b/tests/test_esipp_resource.py
index 0fc4a96bbdfb4984c05adfba2b83bb617251a8dc..b58976257b1b71db2c34455bfbcb84ed487df50e 100644
--- a/tests/test_esipp_resource.py
+++ b/tests/test_esipp_resource.py
@@ -598,145 +598,145 @@ class TestResourcePrice:
# create object without prices
- error_triggered = False
+ error_raised = False
try:
_ = ResourcePrice(prices=None, volumes=volumes)
except TypeError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# *********************************************************************
# create object with negative prices in lists
- error_triggered = False
+ error_raised = False
try:
_ = ResourcePrice(prices=[7, -3, 2], volumes=[3, 4, 5])
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# *********************************************************************
# create object where an intermediate segment has no volume limit
- error_triggered = False
+ error_raised = False
try:
_ = ResourcePrice(prices=[7, 4, 2], volumes=[3, None, 5])
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# *********************************************************************
# create object with negative volumes in lists
- error_triggered = False
+ error_raised = False
try:
_ = ResourcePrice(prices=[7, 3, 2], volumes=[4, -1, 2])
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# *********************************************************************
# create object with non-numeric prices in lists
- error_triggered = False
+ error_raised = False
try:
_ = ResourcePrice(prices=[7, "4", 2], volumes=[3, 4, 5])
except TypeError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# *********************************************************************
# create object with non-numeric volumes in lists
- error_triggered = False
+ error_raised = False
try:
_ = ResourcePrice(prices=[7, 3, 2], volumes=[4, "3", 2])
except TypeError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# *********************************************************************
# create object with mismatched price and volume lists
- error_triggered = False
+ error_raised = False
try:
_ = ResourcePrice(prices=[7, 3, 2], volumes=[5, 7])
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# *********************************************************************
# create object with a price list as an input and an unsupported type
- error_triggered = False
+ error_raised = False
try:
_ = ResourcePrice(prices=[7, 3, 2], volumes="hello")
except TypeError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# *********************************************************************
# create object with negative prices in lists (no volumes are provided)
- error_triggered = False
+ error_raised = False
try:
_ = ResourcePrice(prices=[7, 3, -2], volumes=None)
except TypeError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# *********************************************************************
# create object with non-numeric prices in lists (no volumes are provided)
- error_triggered = False
+ error_raised = False
try:
_ = ResourcePrice(prices=[7, 3, "a"], volumes=None)
except TypeError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# *********************************************************************
# create object with non-numeric prices in lists (no volumes are provided)
- error_triggered = False
+ error_raised = False
try:
_ = ResourcePrice(prices=5, volumes=[7, 3, 4])
except TypeError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# *********************************************************************
# create object with negative prices
- error_triggered = False
+ error_raised = False
try:
_ = ResourcePrice(prices=-3, volumes=None)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# *********************************************************************
diff --git a/tests/test_gis_calculate.py b/tests/test_gis_calculate.py
index 5c2ee6339686a5c5648c2d3b51c6ab39f92ce2ee..fda713bc26c9c9561956a481a5ac474bb77390bf 100644
--- a/tests/test_gis_calculate.py
+++ b/tests/test_gis_calculate.py
@@ -321,12 +321,12 @@ class TestGisCalculate:
true_length_3_points = true_length_2_points_a + true_length_2_points_b
# make sure the function fails with a single point (sanity check)
- error_triggered = False
+ error_raised = False
try:
line = LineString(list_1_points)
except Exception:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# make sure it works with 2 points
diff --git a/tests/test_gis_identify.py b/tests/test_gis_identify.py
index 9eef616d0d27d2dcb993ba370002286719448a6e..383bb75ed4d6c7dbb5151da9d7c21287029458fc 100644
--- a/tests/test_gis_identify.py
+++ b/tests/test_gis_identify.py
@@ -4215,7 +4215,7 @@ class TestGisIdentify:
# not allowed
- error_triggered = False
+ error_raised = False
try:
# inconsistent edge key format
gis_iden.is_edge_path(
@@ -4224,8 +4224,8 @@ class TestGisIdentify:
allow_multiple_formats=False,
)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# *********************************************************************
# *********************************************************************
@@ -4294,15 +4294,15 @@ class TestGisIdentify:
# not allowed
- error_triggered = False
+ error_raised = False
try:
# inconsistent edge key format
gis_iden.is_edge_path(
network, path=[(10, 8, 0), (8, 9)], allow_multiple_formats=False
)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# inconsistent edge key format
@@ -4314,15 +4314,15 @@ class TestGisIdentify:
# not allowed
- error_triggered = False
+ error_raised = False
try:
# inconsistent edge key format
gis_iden.is_edge_path(
network, path=[(6, 5), (5, 4, 0), (4, 3)], allow_multiple_formats=False
)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# *********************************************************************
# *********************************************************************
diff --git a/tests/test_gis_utils.py b/tests/test_gis_utils.py
index b5615465388dd1259f6bb56ba2083dcd74ae4b3d..3a17ecbdf14887231163a8c1c0ec59c59e79764d 100644
--- a/tests/test_gis_utils.py
+++ b/tests/test_gis_utils.py
@@ -1,7 +1,7 @@
# imports
# standard
-
+import sys
from ast import literal_eval
import random
@@ -1121,7 +1121,7 @@ class TestGisUtils:
# trigger the error
- error_triggered = False
+ error_raised = False
try:
(
node_keys,
@@ -1129,8 +1129,8 @@ class TestGisUtils:
_,
) = gis_utils.prepare_node_data_from_geodataframe(gdf=gdf)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# *****************************************************************************
# *****************************************************************************
@@ -1322,18 +1322,18 @@ class TestGisUtils:
# mismatched longitudes and latitudes
- error_triggered = False
+ error_raised = False
try:
_ = gis_utils.create_node_geodataframe(
longitudes=(_longitude, 528), latitudes=(_latitude,)
)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# mismatched longitudes/latitudes and osmids
- error_triggered = False
+ error_raised = False
try:
_ = gis_utils.create_node_geodataframe(
longitudes=(_longitude, 528),
@@ -1341,8 +1341,8 @@ class TestGisUtils:
osmids=(59, 482, 135),
)
except ValueError:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# *************************************************************************
# *************************************************************************
@@ -1881,12 +1881,12 @@ class TestGisUtils:
gdf.to_file(filename_gpkg)
else: # incompatible: errors are expected
- error_triggered = False
+ error_raised = False
try:
gdf.to_file(filename_gpkg)
except Exception:
- error_triggered = True
- assert error_triggered
+ error_raised = True
+ assert error_raised
# *********************************************************************
# *********************************************************************
@@ -2603,6 +2603,21 @@ class TestGisUtils:
# *************************************************************************
def test_simplify_network_osmnx(self):
+
+ # BUG: there is a bug here, therefore we are printing the seed number
+ # it seems to occur if all the nodes around 1106295281 are simplified
+ # seed: 5785034948163332129
+# for edge_key in network.edges(keys=True):
+# > assert len(tuple(gis_iden.get_edges_between_two_nodes(network, *edge_key[0:2]))) == 1
+# E assert 2 == 1
+# E + where 2 = len(((1106295281, 1106295315, 0), (1106295315, 1106295281, 0)))
+# E + where ((1106295281, 1106295315, 0), (1106295315, 1106295281, 0)) = tuple([(1106295281, 1106295315, 0), (1106295315, 1106295281, 0)])
+# E + where [(1106295281, 1106295315, 0), (1106295315, 1106295281, 0)] = <function get_edges_between_two_nodes at 0x7f8d07bc9ee0>(<networkx.classes.multidigraph.MultiDiGraph object at 0x7f8d00d17410>, *(1106295281, 1106295315))
+# E + where <function get_edges_between_two_nodes at 0x7f8d07bc9ee0> = gis_iden.get_edges_between_two_nodes
+ seed = random.randrange(sys.maxsize)
+ random.seed(seed)
+ print("Seed was:", seed)
+
# get a network
network = ox.graph_from_point(
(55.71654, 9.11728),
@@ -2618,6 +2633,11 @@ class TestGisUtils:
node_keys[random.randint(0, len(node_keys) - 1)]
for i in range(number_nodes_protected)
]
+ # protected_nodes.append(1106295281)
+ # assert 1 == 0
+ # E + where 1 = len([[317212013, 1106295281, 1106295315]])
+ # E + where [[317212013, 1106295281, 1106295315]] = <function find_simplifiable_paths at 0x7f9ac0cf22a0>(<networkx.classes.multidigraph.MultiDiGraph object at 0x7f9ab2c7b350>, [115838, 317195115, 5031764839, 317811652, 5076232388, 615539272, ...])
+ # E + where <function find_simplifiable_paths at 0x7f9ac0cf22a0> = gis_iden.find_simplifiable_paths
# try simplifying it
gis_utils.simplify_network(network, protected_nodes=protected_nodes)
# protected nodes must still exist
diff --git a/tests/test_solvers.py b/tests/test_solvers.py
index 7f0a728322c65e460f30796ddecb72760290b8a4..9cb0eda81788bbf1f914b7846e3b9b68da175662 100644
--- a/tests/test_solvers.py
+++ b/tests/test_solvers.py
@@ -5,29 +5,99 @@ from src.topupopt.solvers.interface import SolverInterface
from pyomo.opt.results.solver import TerminationCondition
import pyomo.environ as pyo
-from pyomo.common.errors import ApplicationError
+from pyomo.opt import check_available_solvers
import random
+import pytest
# *****************************************************************************
# *****************************************************************************
-
+@pytest.mark.parametrize(
+ "solver",
+ ['glpk',
+ 'cbc',
+ 'scip',
+ 'fakesolver']
+ )
class TestSolvers:
+
# *************************************************************************
# *************************************************************************
- def test_solver_factory_arguments(self):
- # test a collection of problems using different solvers
+ def test_inexistent_solver(self, solver):
+
+ # try using a fake solver and a problem incompatible with another solver
+
+ # list of problems: one compatible, one incompatible
+ list_problems = [
+ problem_milp_feasible(20, seed_number=50),
+ problem_lp_optimal(),
+ problem_qp_optimal(),
+ problem_qp_optimal(),
+ ]
- problem = self.problem_milp_feasible()
+ # problem types
+ list_problem_types = [
+ SolverInterface.PROBLEM_LP,
+ SolverInterface.PROBLEM_LP,
+ SolverInterface.PROBLEM_QP,
+ "fake_problem_type",
+ ]
# solver settings
+ solver_timelimit = 30
+ solver_abs_mip_gap = 0
+ solver_rel_mip_gap = 0.01
+ solver_options = {
+ "time_limit": solver_timelimit,
+ "relative_mip_gap": solver_rel_mip_gap,
+ "absolute_mip_gap": solver_abs_mip_gap,
+ }
- solver_timelimit = 10
+ # *********************************************************************
+ # *********************************************************************
- solver_abs_mip_gap = 0.001
+ for index, problem in enumerate(list_problems):
+
+ # optimise
+ try:
+ # test problem-solver compatibility
+ problem_type = list_problem_types[index]
+
+ if not SolverInterface.problem_and_solver_are_compatible(
+ solver, problem_type):
+ continue
+
+ except SolverInterface.UnknownSolverError:
+ assert True
+
+ except SolverInterface.UnknownProblemTypeError:
+ assert True
+ # test the solver interface
+ try:
+ # configure common solver interface
+ _ = SolverInterface(solver_name=solver, **solver_options)
+ except SolverInterface.UnknownSolverError:
+ assert True
+
+ # *************************************************************************
+ # *************************************************************************
+
+ # @pytest.mark.skipif(True, reason="requires python3.10 or higher")
+ def test_solver_factory_arguments(self, solver):
+
+ # skip test if the solver is not available
+ if not bool(check_available_solvers(solver)):
+ return
+
+ # test a feasible problem
+ problem = problem_milp_feasible()
+
+ # solver settings
+ solver_timelimit = 10
+ solver_abs_mip_gap = 0.001
solver_rel_mip_gap = 0.01
solver_options = {
@@ -35,61 +105,30 @@ class TestSolvers:
"relative_mip_gap": solver_rel_mip_gap,
"absolute_mip_gap": solver_abs_mip_gap,
# special option
- "tee": True,
+ "tee": False,
}
-
- solver_name = "scip"
-
- results, solver_interface = self.optimise(solver_name, solver_options, problem)
+ results, solver_interface = optimise(solver, solver_options, problem)
# *************************************************************************
# *************************************************************************
- def test_problems(self):
+ def test_problems(self, solver):
# test a collection of problems using different solvers
- # solver = "scip"
- # # scip_exec_path = '/usr/bin/scip'
- # # solver_options = {'executable': scip_exec_path}
- # solver_options = {}
-
- # solver = 'cplex'
- # # cplex_exec_path = '/home/pmlpm/Software/CPLEX/cplex/bin/x86-64_linux/cplex'
- # cplex_exec_path = '/home/pmlpm/CPLEX/cplex/bin/x86-64_linux/cplex'
- # #solver_options = {}
- # solver_options = {'executable':cplex_exec_path}
-
- list_solvers = [
- "fake_solver",
- "cbc",
- "glpk",
- "scip",
- 'cplex'
- ]
-
- list_solver_options = [
- None, # fake
- None, # cbc
- {"tee": False}, # glpk
- None, # scip {'executable': scip_exec_path},
- None, # cplex
- # {'executable': cplex_exec_path},
- ]
-
# list of problems
list_concrete_models = [
- self.problem_qp_optimal(),
- self.problem_qp_infeasible(),
- self.problem_lp_unbounded(),
- self.problem_lp_infeasible(),
- self.problem_lp_optimal(),
- self.problem_milp_unbounded(),
- self.problem_milp_infeasible(),
- self.problem_milp_optimal(),
- self.problem_milp_feasible(),
- self.problem_milp_feasible(15, 64),
- self.problem_milp_feasible(10, 46),
+ problem_qp_optimal(),
+ problem_qp_infeasible(),
+ problem_lp_unbounded(),
+ problem_lp_infeasible(),
+ problem_lp_optimal(),
+ problem_milp_unbounded(),
+ problem_milp_infeasible(),
+ problem_milp_optimal(),
+ problem_milp_feasible(),
+ problem_milp_feasible(15, 64),
+ problem_milp_feasible(10, 46),
]
# list of problem types
@@ -138,577 +177,475 @@ class TestSolvers:
True,
]
- # list of solvers
-
- list_solvers = ["fake_solver", "cbc", "glpk", "scip", "cplex"]
-
# solver settings
-
solver_timelimit = 10
-
solver_abs_mip_gap = 0.001
-
solver_rel_mip_gap = 0.01
+ solver_options = {
+ "time_limit": solver_timelimit,
+ "relative_mip_gap": solver_rel_mip_gap,
+ "absolute_mip_gap": solver_abs_mip_gap,
+ }
- for solver_name, solver_options in zip(list_solvers, list_solver_options):
- if type(solver_options) == dict:
- solver_options.update(
- {
- "time_limit": solver_timelimit,
- "relative_mip_gap": solver_rel_mip_gap,
- "absolute_mip_gap": solver_abs_mip_gap,
- }
- )
-
- else:
- solver_options = {
- "time_limit": solver_timelimit,
- "relative_mip_gap": solver_rel_mip_gap,
- "absolute_mip_gap": solver_abs_mip_gap,
- }
-
- for problem_index, problem in enumerate(list_concrete_models):
- try:
- # check problem and solver compatibility
-
- problem_type = list_problem_types[problem_index]
-
- if (
- SolverInterface.problem_and_solver_are_compatible(
- solver_name, problem_type
- )
- == False
- ):
- continue
-
- # optimise
-
- results, solver_interface = self.optimise(
- solver_name, solver_options, problem, print_solver_output=False
- )
-
- except SolverInterface.UnknownSolverError:
- continue
-
- except SolverInterface.UnknownProblemTypeError:
- continue
-
- # *************************************************************
- # *************************************************************
-
- # termination condition
-
- exp_term_cond = list_problem_termination_conditions[problem_index]
-
- term_cond = results.solver.termination_condition
-
- if (
- exp_term_cond == None
- or (
- solver_name == "glpk"
- and exp_term_cond == TerminationCondition.unbounded
- )
- or (
- solver_name == "cplex"
- and exp_term_cond == TerminationCondition.unbounded
- )
- or (
- solver_name == "cplex"
- and exp_term_cond == TerminationCondition.optimal
- )
- or (
- solver_name == "cplex"
- and exp_term_cond == TerminationCondition.infeasible
- )
- ):
- # exceptions in need of correction
-
- pass
-
- else:
- # print(solver_name)
- # print(results)
- assert exp_term_cond == term_cond
-
- # *************************************************************
- # *************************************************************
-
- # solver status
-
- if (
- (
- solver_name == "glpk"
- and term_cond == TerminationCondition.infeasible
- )
- or (
- solver_name == "cplex"
- and term_cond == TerminationCondition.unknown
- )
- or (
- solver_name == "cplex"
- and exp_term_cond == TerminationCondition.unbounded
- )
- or (
- solver_name == "cplex"
- and exp_term_cond == TerminationCondition.infeasible
- )
- ):
- pass
-
- else:
- # check if the solver status matches the one one would expect
- # if the termination condition was correct
-
- assert (
- TerminationCondition.to_solver_status(term_cond)
- == results.solver.status
- )
-
- # if valid, it means the results object is coherent
+ for problem_index, problem in enumerate(list_concrete_models):
+ try:
+ # check problem and solver compatibility
- # *************************************************************
- # *************************************************************
+ problem_type = list_problem_types[problem_index]
if (
- exp_term_cond == None
- or (
- solver_name == "glpk"
- and exp_term_cond == TerminationCondition.unbounded
- )
- or (
- solver_name == "glpk"
- and exp_term_cond == TerminationCondition.infeasible
- )
- or (
- solver_name == "cplex"
- and exp_term_cond == TerminationCondition.unknown
- )
- or (
- solver_name == "cplex"
- and exp_term_cond == TerminationCondition.unbounded
- )
- or (
- solver_name == "cplex"
- and exp_term_cond == TerminationCondition.infeasible
+ SolverInterface.problem_and_solver_are_compatible(
+ solver, problem_type
)
+ == False
):
- pass
+ continue
- else:
- # check if the solver status matches the one one would expect
- # if the termination condition predicted was obtained
+ # optimise
- assert (
- TerminationCondition.to_solver_status(exp_term_cond)
- == results.solver.status
- )
+ results, solver_interface = optimise(
+ solver, solver_options, problem, print_solver_output=False
+ )
- # if valid, the solver status is correct despite other issues
+ except SolverInterface.UnknownSolverError:
+ continue
- # *************************************************************
- # *************************************************************
+ except SolverInterface.UnknownProblemTypeError:
+ continue
- # make sure the optimisation went as expected
+ # *************************************************************
+ # *************************************************************
- exp_optim_result = list_problem_optimisation_sucess[problem_index]
+ # termination condition
- if (
- TerminationCondition.to_solver_status(
- results.solver.termination_condition
- )
- != results.solver.status
- ):
- # this can be removed once the aforementioned issues have
- # been fixed (e.g. for the cplex and glpk solvers)
+ exp_term_cond = list_problem_termination_conditions[problem_index]
- pass
+ term_cond = results.solver.termination_condition
- else:
- optim_result = solver_interface.was_optimisation_sucessful(
- results, problem_type
- )
-
- # *************************************************************
- # *************************************************************
+ if (
+ exp_term_cond == None
+ or (
+ solver == "glpk"
+ and exp_term_cond == TerminationCondition.unbounded
+ )
+ or (
+ solver == "cplex"
+ and exp_term_cond == TerminationCondition.unbounded
+ )
+ or (
+ solver == "cplex"
+ and exp_term_cond == TerminationCondition.optimal
+ )
+ or (
+ solver == "cplex"
+ and exp_term_cond == TerminationCondition.infeasible
+ )
+ ):
+ # exceptions in need of correction
- if (
- TerminationCondition.to_solver_status(
- results.solver.termination_condition
- )
- != results.solver.status
- or exp_term_cond == TerminationCondition.unbounded
- ):
- # this can be removed once the aforementioned issues have
- # been fixed (e.g. for the cplex and glpk solvers)
+ pass
- pass
+ else:
+ # print(solver)
+ # print(results)
+ assert exp_term_cond == term_cond
- else:
- assert optim_result == exp_optim_result
+ # *************************************************************
+ # *************************************************************
- # *************************************************************
- # *************************************************************
+ # solver status
- # test additional scenarios
+ if (
+ (
+ solver == "glpk"
+ and term_cond == TerminationCondition.infeasible
+ )
+ or (
+ solver == "cplex"
+ and term_cond == TerminationCondition.unknown
+ )
+ or (
+ solver == "cplex"
+ and exp_term_cond == TerminationCondition.unbounded
+ )
+ or (
+ solver == "cplex"
+ and exp_term_cond == TerminationCondition.infeasible
+ )
+ ):
+ pass
- if optim_result == False:
- continue
+ else:
+ # check if the solver status matches the one one would expect
+ # if the termination condition was correct
- # force unknown solver status error
+ assert (
+ TerminationCondition.to_solver_status(term_cond)
+ == results.solver.status
+ )
- results.solver.status = "false_solver_status"
+ # if valid, it means the results object is coherent
- try:
- _ = solver_interface.was_optimisation_sucessful(
- results, problem_type
- )
+ # *************************************************************
+ # *************************************************************
- except solver_interface.UnknownSolverStatusError:
- assert True
+ if (
+ exp_term_cond == None
+ or (
+ solver == "glpk"
+ and exp_term_cond == TerminationCondition.unbounded
+ )
+ or (
+ solver == "glpk"
+ and exp_term_cond == TerminationCondition.infeasible
+ )
+ or (
+ solver == "cplex"
+ and exp_term_cond == TerminationCondition.unknown
+ )
+ or (
+ solver == "cplex"
+ and exp_term_cond == TerminationCondition.unbounded
+ )
+ or (
+ solver == "cplex"
+ and exp_term_cond == TerminationCondition.infeasible
+ )
+ ):
+ pass
- # force unknown termination condition error
+ else:
+ # check if the solver status matches the one one would expect
+ # if the termination condition predicted was obtained
- results.solver.termination_condition = "false_termin_condition"
+ assert (
+ TerminationCondition.to_solver_status(exp_term_cond)
+ == results.solver.status
+ )
- try:
- _ = solver_interface.was_optimisation_sucessful(
- results, problem_type
- )
+ # if valid, the solver status is correct despite other issues
- except solver_interface.UnknownTerminationConditionError:
- assert True
+ # *************************************************************
+ # *************************************************************
- # force an InconsistentSolverStatusError
+ # make sure the optimisation went as expected
- results.solver.termination_condition = TerminationCondition.optimal
+ exp_optim_result = list_problem_optimisation_sucess[problem_index]
- results.solver.status = TerminationCondition.to_solver_status(
+ if (
+ TerminationCondition.to_solver_status(
results.solver.termination_condition
)
+ != results.solver.status
+ ):
+ # this can be removed once the aforementioned issues have
+ # been fixed (e.g. for the cplex and glpk solvers)
- results.solver.termination_condition = TerminationCondition.unknown
+ pass
- try:
- _ = solver_interface.was_optimisation_sucessful(
- results, problem_type
- )
+ else:
+ optim_result = solver_interface.was_optimisation_sucessful(
+ results, problem_type
+ )
- except solver_interface.InconsistentSolverStatusError:
- assert True
+ # *************************************************************
+ # *************************************************************
- # force an InconsistentProblemTypeAndSolverError
+ if (
+ TerminationCondition.to_solver_status(
+ results.solver.termination_condition
+ )
+ != results.solver.status
+ or exp_term_cond == TerminationCondition.unbounded
+ ):
+ # this can be removed once the aforementioned issues have
+ # been fixed (e.g. for the cplex and glpk solvers)
- if problem_type == SolverInterface.PROBLEM_LP and solver_name == "glpk":
- problem_type = SolverInterface.PROBLEM_QP
+ pass
- try:
- _ = solver_interface.was_optimisation_sucessful(
- results, problem_type
- )
+ else:
+ assert optim_result == exp_optim_result
- except solver_interface.InconsistentProblemTypeAndSolverError:
- assert True
+ # *************************************************************
+ # *************************************************************
- # *********************************************************************
- # *********************************************************************
+ # test additional scenarios
- # *************************************************************************
- # *************************************************************************
+ if optim_result == False:
+ continue
- # carry out optimisations
+ # force unknown solver status error
- def optimise(
- self,
- solver_name: str,
- solver_options: dict,
- # solver_interface: SolverInterface,
- problem: pyo.ConcreteModel,
- print_solver_output: bool = True,
- ):
- # configure common solver interface
- solver_interface = SolverInterface(solver_name=solver_name, **solver_options)
+ results.solver.status = "false_solver_status"
- # get the solver handler
- solver_handler = solver_interface.get_solver_handler(**solver_options)
+ try:
+ _ = solver_interface.was_optimisation_sucessful(
+ results, problem_type
+ )
- # solve
- if "tee" not in solver_options:
- results = solver_handler.solve(problem, tee=print_solver_output)
- else:
- results = solver_handler.solve(problem)
+ except solver_interface.UnknownSolverStatusError:
+ assert True
- # return
- return results, solver_interface
+ # force unknown termination condition error
- # *************************************************************************
- # *************************************************************************
+ results.solver.termination_condition = "false_termin_condition"
- def problem_qp_optimal(self):
- model = pyo.ConcreteModel("qp_optimal")
+ try:
+ _ = solver_interface.was_optimisation_sucessful(
+ results, problem_type
+ )
- model.x = pyo.Var(within=pyo.NonNegativeReals)
- model.y = pyo.Var(within=pyo.NonNegativeReals)
+ except solver_interface.UnknownTerminationConditionError:
+ assert True
- def constraint_rule(model):
- return model.x + model.y >= 10
+ # force an InconsistentSolverStatusError
- model.constraint = pyo.Constraint(rule=constraint_rule)
+ results.solver.termination_condition = TerminationCondition.optimal
- def objective_rule(model):
- return (
- model.x
- + model.y
- + 0.5
- * (model.x * model.x + 4 * model.x * model.y + 7 * model.y * model.y)
+ results.solver.status = TerminationCondition.to_solver_status(
+ results.solver.termination_condition
)
- model.objective = pyo.Objective(rule=objective_rule, sense=pyo.minimize)
-
- return model
-
- # *************************************************************************
- # *************************************************************************
-
- def problem_qp_infeasible(self):
- model = pyo.ConcreteModel("qp_infeasible")
+ results.solver.termination_condition = TerminationCondition.unknown
- # model.x = pyo.Var(within=pyo.NonNegativeReals, bounds=(0,5))
- # model.y = pyo.Var(within=pyo.NonNegativeReals, bounds=(0,4))
+ try:
+ _ = solver_interface.was_optimisation_sucessful(
+ results, problem_type
+ )
- model.x = pyo.Var(bounds=(0, 5))
- model.y = pyo.Var(bounds=(0, 4))
+ except solver_interface.InconsistentSolverStatusError:
+ assert True
- def constraint_rule(model):
- return model.x + model.y >= 10
+ # force an InconsistentProblemTypeAndSolverError
- model.constraint = pyo.Constraint(rule=constraint_rule)
+ if problem_type == SolverInterface.PROBLEM_LP and solver == "glpk":
+ problem_type = SolverInterface.PROBLEM_QP
- def objective_rule(model):
- return (
- model.x
- + model.y
- + 0.5
- * (model.x * model.x + 4 * model.x * model.y + 7 * model.y * model.y)
- )
+ try:
+ _ = solver_interface.was_optimisation_sucessful(
+ results, problem_type
+ )
- model.objective = pyo.Objective(rule=objective_rule, sense=pyo.minimize)
+ except solver_interface.InconsistentProblemTypeAndSolverError:
+ assert True
- return model
+ # *********************************************************************
+ # *********************************************************************
# *************************************************************************
# *************************************************************************
- def problem_lp_optimal(self):
- model = pyo.ConcreteModel("lp_optimal")
-
- model.x = pyo.Var([1, 2], domain=pyo.NonNegativeReals)
+# *****************************************************************************
+# *****************************************************************************
- model.OBJ = pyo.Objective(expr=2 * model.x[1] + 3 * model.x[2])
+# carry out optimisations
- model.Constraint1 = pyo.Constraint(expr=3 * model.x[1] + 4 * model.x[2] >= 1)
+def optimise(
+ solver_name: str,
+ solver_options: dict,
+ # solver_interface: SolverInterface,
+ problem: pyo.ConcreteModel,
+ print_solver_output: bool = True,
+):
+ # configure common solver interface
+ solver_interface = SolverInterface(solver_name=solver_name, **solver_options)
- return model
+ # get the solver handler
+ solver_handler = solver_interface.get_solver_handler(**solver_options)
- # *************************************************************************
- # *************************************************************************
+ # solve
+ if "tee" not in solver_options:
+ results = solver_handler.solve(problem, tee=print_solver_output)
+ else:
+ results = solver_handler.solve(problem)
- def problem_lp_infeasible(self):
- model = pyo.ConcreteModel("lp_infeasible")
+ # return
+ return results, solver_interface
- model.x = pyo.Var([1, 2], domain=pyo.NonNegativeReals)
- model.OBJ = pyo.Objective(expr=2 * model.x[1] + 3 * model.x[2])
+# *****************************************************************************
+# *****************************************************************************
- model.Constraint1 = pyo.Constraint(expr=3 * model.x[1] + 4 * model.x[2] <= -1)
+def problem_qp_optimal():
+ model = pyo.ConcreteModel("qp_optimal")
- return model
+ model.x = pyo.Var(within=pyo.NonNegativeReals)
+ model.y = pyo.Var(within=pyo.NonNegativeReals)
- # *************************************************************************
- # *************************************************************************
+ def constraint_rule(model):
+ return model.x + model.y >= 10
- def problem_lp_unbounded(self):
- model = pyo.ConcreteModel("lp_unbounded")
+ model.constraint = pyo.Constraint(rule=constraint_rule)
- model.x = pyo.Var([1, 2], domain=pyo.NonNegativeReals)
-
- model.OBJ = pyo.Objective(
- expr=2 * model.x[1] + 3 * model.x[2], sense=pyo.maximize
+ def objective_rule(model):
+ return (
+ model.x
+ + model.y
+ + 0.5
+ * (model.x * model.x + 4 * model.x * model.y + 7 * model.y * model.y)
)
- model.Constraint1 = pyo.Constraint(expr=3 * model.x[1] + 4 * model.x[2] >= 1)
+ model.objective = pyo.Objective(rule=objective_rule, sense=pyo.minimize)
- return model
+ return model
- # *************************************************************************
- # *************************************************************************
+# *****************************************************************************
+# *****************************************************************************
- def problem_milp_optimal(self):
- model = pyo.ConcreteModel("milp_optimal")
+def problem_qp_infeasible():
+ model = pyo.ConcreteModel("qp_infeasible")
- model.x = pyo.Var([1, 2], domain=pyo.Binary)
+ # model.x = pyo.Var(within=pyo.NonNegativeReals, bounds=(0,5))
+ # model.y = pyo.Var(within=pyo.NonNegativeReals, bounds=(0,4))
- model.OBJ = pyo.Objective(expr=2.15 * model.x[1] + 3.8 * model.x[2])
+ model.x = pyo.Var(bounds=(0, 5))
+ model.y = pyo.Var(bounds=(0, 4))
- model.Constraint1 = pyo.Constraint(expr=3 * model.x[1] + 4 * model.x[2] >= 1)
+ def constraint_rule(model):
+ return model.x + model.y >= 10
- return model
+ model.constraint = pyo.Constraint(rule=constraint_rule)
- # *************************************************************************
- # *************************************************************************
+ def objective_rule(model):
+ return (
+ model.x
+ + model.y
+ + 0.5
+ * (model.x * model.x + 4 * model.x * model.y + 7 * model.y * model.y)
+ )
- def problem_milp_infeasible(self):
- model = pyo.ConcreteModel("milp_infeasible")
+ model.objective = pyo.Objective(rule=objective_rule, sense=pyo.minimize)
- model.x = pyo.Var([1, 2], domain=pyo.Binary)
+ return model
- model.OBJ = pyo.Objective(expr=2 * model.x[1] + 3 * model.x[2])
+# *****************************************************************************
+# *****************************************************************************
- model.Constraint1 = pyo.Constraint(expr=3 * model.x[1] + 4 * model.x[2] <= -1)
+def problem_lp_optimal():
+ model = pyo.ConcreteModel("lp_optimal")
- return model
+ model.x = pyo.Var([1, 2], domain=pyo.NonNegativeReals)
- # *************************************************************************
- # *************************************************************************
+ model.OBJ = pyo.Objective(expr=2 * model.x[1] + 3 * model.x[2])
- def problem_milp_unbounded(self):
- model = pyo.ConcreteModel("milp_unbounded")
+ model.Constraint1 = pyo.Constraint(expr=3 * model.x[1] + 4 * model.x[2] >= 1)
- model.x = pyo.Var([1, 2], domain=pyo.NonNegativeReals)
+ return model
- model.y = pyo.Var(domain=pyo.Binary)
+# *****************************************************************************
+# *****************************************************************************
- model.OBJ = pyo.Objective(
- expr=2 * model.x[1] + 3 * model.x[2] + model.y, sense=pyo.maximize
- )
+def problem_lp_infeasible():
+ model = pyo.ConcreteModel("lp_infeasible")
- model.Constraint1 = pyo.Constraint(expr=3 * model.x[1] + 4 * model.x[2] >= 1)
+ model.x = pyo.Var([1, 2], domain=pyo.NonNegativeReals)
- return model
+ model.OBJ = pyo.Objective(expr=2 * model.x[1] + 3 * model.x[2])
- # *************************************************************************
- # *************************************************************************
+ model.Constraint1 = pyo.Constraint(expr=3 * model.x[1] + 4 * model.x[2] <= -1)
- def problem_milp_feasible(self, number_binary_variables=25, seed_number=None):
- if seed_number != None:
- random.seed(seed_number)
+ return model
- model = pyo.ConcreteModel("milp_feasible")
+# *****************************************************************************
+# *****************************************************************************
- # a knapsack-type problem
+def problem_lp_unbounded():
+ model = pyo.ConcreteModel("lp_unbounded")
- model.Y = pyo.RangeSet(number_binary_variables)
+ model.x = pyo.Var([1, 2], domain=pyo.NonNegativeReals)
- model.y = pyo.Var(model.Y, domain=pyo.Binary)
+ model.OBJ = pyo.Objective(
+ expr=2 * model.x[1] + 3 * model.x[2], sense=pyo.maximize
+ )
- model.OBJ = pyo.Objective(
- expr=sum(model.y[j] * random.random() for j in model.Y), sense=pyo.maximize
- )
+ model.Constraint1 = pyo.Constraint(expr=3 * model.x[1] + 4 * model.x[2] >= 1)
- model.Constraint1 = pyo.Constraint(
- expr=sum(model.y[j] * random.random() for j in model.Y)
- <= round(number_binary_variables / 5)
- )
+ return model
- def rule_c1(m, i):
- return (
- sum(
- model.y[j] * (random.random() - 0.5)
- for j in model.Y
- if j != i
- if random.randint(0, 1)
- )
- <= round(number_binary_variables / 5) * model.y[i]
- )
+# *****************************************************************************
+# *****************************************************************************
- model.constr_c1 = pyo.Constraint(model.Y, rule=rule_c1)
+def problem_milp_optimal():
+ model = pyo.ConcreteModel("milp_optimal")
- return model
+ model.x = pyo.Var([1, 2], domain=pyo.Binary)
- # *************************************************************************
- # *************************************************************************
+ model.OBJ = pyo.Objective(expr=2.15 * model.x[1] + 3.8 * model.x[2])
- def test_inexistent_solver(self):
- fake_solver = "fake_solver"
- good_solver = "glpk"
- # solver_options: dict = None
+ model.Constraint1 = pyo.Constraint(expr=3 * model.x[1] + 4 * model.x[2] >= 1)
- # try using a fake solver and a problem incompatible with another solver
+ return model
- # list of problems: one compatible, one incompatible
+# *****************************************************************************
+# *****************************************************************************
- list_problems = [
- self.problem_milp_feasible(20, seed_number=50),
- self.problem_lp_optimal(),
- self.problem_qp_optimal(),
- self.problem_qp_optimal(),
- ]
+def problem_milp_infeasible():
+ model = pyo.ConcreteModel("milp_infeasible")
- # problem types
+ model.x = pyo.Var([1, 2], domain=pyo.Binary)
- list_problem_types = [
- SolverInterface.PROBLEM_LP,
- SolverInterface.PROBLEM_LP,
- SolverInterface.PROBLEM_QP,
- "fake_problem_type",
- ]
+ model.OBJ = pyo.Objective(expr=2 * model.x[1] + 3 * model.x[2])
- # list of solvers: one fake, one real
+ model.Constraint1 = pyo.Constraint(expr=3 * model.x[1] + 4 * model.x[2] <= -1)
- list_solvers = [fake_solver, good_solver]
+ return model
- # solver settings
+# *****************************************************************************
+# *****************************************************************************
- solver_timelimit = 30
+def problem_milp_unbounded():
+ model = pyo.ConcreteModel("milp_unbounded")
- solver_abs_mip_gap = 0
+ model.x = pyo.Var([1, 2], domain=pyo.NonNegativeReals)
- solver_rel_mip_gap = 0.01
+ model.y = pyo.Var(domain=pyo.Binary)
- solver_options = {
- "time_limit": solver_timelimit,
- "relative_mip_gap": solver_rel_mip_gap,
- "absolute_mip_gap": solver_abs_mip_gap,
- }
+ model.OBJ = pyo.Objective(
+ expr=2 * model.x[1] + 3 * model.x[2] + model.y, sense=pyo.maximize
+ )
- # *********************************************************************
- # *********************************************************************
+ model.Constraint1 = pyo.Constraint(expr=3 * model.x[1] + 4 * model.x[2] >= 1)
- for solver_name in list_solvers:
- for index, problem in enumerate(list_problems):
- # optimise
+ return model
- try:
- # test problem-solver compatibility
+# *****************************************************************************
+# *****************************************************************************
- problem_type = list_problem_types[index]
+def problem_milp_feasible(number_binary_variables=25, seed_number=None):
+ if seed_number != None:
+ random.seed(seed_number)
- if (
- SolverInterface.problem_and_solver_are_compatible(
- solver_name, problem_type
- )
- == False
- ):
- continue
+ model = pyo.ConcreteModel("milp_feasible")
- except SolverInterface.UnknownSolverError:
- assert True
+ # a knapsack-type problem
- except SolverInterface.UnknownProblemTypeError:
- assert True
+ model.Y = pyo.RangeSet(number_binary_variables)
- # test the solver interface
+ model.y = pyo.Var(model.Y, domain=pyo.Binary)
- try:
- # configure common solver interface
+ model.OBJ = pyo.Objective(
+ expr=sum(model.y[j] * random.random() for j in model.Y), sense=pyo.maximize
+ )
- _ = SolverInterface(solver_name=solver_name, **solver_options)
+ model.Constraint1 = pyo.Constraint(
+ expr=sum(model.y[j] * random.random() for j in model.Y)
+ <= round(number_binary_variables / 5)
+ )
- except SolverInterface.UnknownSolverError:
- assert True
+ def rule_c1(m, i):
+ return (
+ sum(
+ model.y[j] * (random.random() - 0.5)
+ for j in model.Y
+ if j != i
+ if random.randint(0, 1)
+ )
+ <= round(number_binary_variables / 5) * model.y[i]
+ )
- # **************************************************************************
- # **************************************************************************
+ model.constr_c1 = pyo.Constraint(model.Y, rule=rule_c1)
+ return model
-# ******************************************************************************
-# ******************************************************************************
+# *****************************************************************************
+# *****************************************************************************