def annotate_rule(m):
m.stoch_rhs = StochasticConstraintBoundsAnnotation()
m.stoch_rhs.declare(m.r[3])
m.stoch_rhs.declare(m.r[6])
m.stoch_rhs.declare(m.r[9])
m.stoch_rhs.declare(m.c)
m.stoch_rhs.declare(m.b.c)
def pysp_instance_creation_callback(scenario_name, node_names):
model = create_instance(scenario_name)
#
# SMPS Related Annotations
#
model.stoch_rhs = StochasticConstraintBoundsAnnotation()
# declarations can be blocks to imply that all
# components (Constraints in this case) should be
# considered on that block
model.stoch_rhs.declare(model.p_second_stage)
model.stoch_rhs.declare(model.r_second_stage)
model.stoch_matrix = StochasticConstraintBodyAnnotation()
# exercise more of the code by testing this with an
# indexed block and a single block
model.stoch_matrix.declare(model.c_second_stage, variables=[model.r])
model.stoch_matrix.declare(model.p_second_stage[1])
model.stoch_objective = StochasticObjectiveAnnotation()
return model
def pysp_instance_creation_callback(scenario_name, node_names):
model = create_instance(scenario_name)
#
# SMPS Related Annotations
#
model.stoch_rhs = StochasticConstraintBoundsAnnotation()
for con in model.p_second_stage[1].component_data_objects(Constraint,
active=True):
model.stoch_rhs.declare(con)
model.stoch_rhs.declare(model.r_second_stage)
model.stoch_matrix = StochasticConstraintBodyAnnotation()
# exercise more of the code by testing this with an
# indexed block and a single block
model.stoch_matrix.declare(model.c_second_stage, variables=[model.r])
model.stoch_matrix.declare(model.p_second_stage[1])
model.stoch_objective = StochasticObjectiveAnnotation()
model.stoch_objective.declare(model.o)
return model
def __init__(self, reference_model):
self.reference_model = None
self.objective = None
self.time_stages = None
self.stage_to_variables_map = {}
self.variable_to_stage_map = {}
# the set of stochastic data objects
# (possibly mapped to some distribution)
self.stochastic_data = None
# maps between variables and objectives
self.variable_to_objectives_map = ComponentMap()
self.objective_to_variables_map = ComponentMap()
# maps between variables and constraints
self.variable_to_constraints_map = ComponentMap()
self.constraint_to_variables_map = ComponentMap()
# maps between stochastic data and objectives
self.stochastic_data_to_objectives_map = ComponentMap()
self.objective_to_stochastic_data_map = ComponentMap()
# maps between stochastic data and constraints
self.stochastic_data_to_constraints_map = ComponentMap()
self.constraint_to_stochastic_data_map = ComponentMap()
# maps between stochastic data and variable lower and upper bounds
self.stochastic_data_to_variables_lb_map = ComponentMap()
self.variable_to_stochastic_data_lb_map = ComponentMap()
self.stochastic_data_to_variables_ub_map = ComponentMap()
self.variable_to_stochastic_data_ub_map = ComponentMap()
self.variable_symbols = ComponentMap()
if not isinstance(reference_model, Block):
raise TypeError("reference model input must be a Pyomo model")
self.reference_model = reference_model
#
# Extract stochastic parameters from the
# StochasticDataAnnotation object
#
self.stochastic_data = \
_extract_stochastic_data(self.reference_model)
#
# Get the variable stages from the
# VariableStageAnnotation object
#
(self.stage_to_variables_map,
self.variable_to_stage_map,
self._variable_stage_assignments) = \
_map_variable_stages(self.reference_model)
self.time_stages = tuple(sorted(self.stage_to_variables_map))
assert self.time_stages[0] == 1
self.variable_symbols = generate_cuid_names(self.reference_model,
ctype=Var)
# remove the parent blocks from this map
keys_to_delete = []
for var in self.variable_symbols:
if var.parent_component().ctype is not Var:
keys_to_delete.append(var)
for key in keys_to_delete:
del self.variable_symbols[key]
#
# Get the stage cost components from the StageCostAnnotation
# and generate a dummy single-scenario scenario tree
#
stage_cost_annotation = locate_annotations(self.reference_model,
StageCostAnnotation,
max_allowed=1)
if len(stage_cost_annotation) == 0:
raise ValueError("Reference model is missing stage cost "
"annotation: %s" % (StageCostAnnotation.__name__))
else:
assert len(stage_cost_annotation) == 1
stage_cost_annotation = stage_cost_annotation[0][1]
stage_cost_assignments = ComponentMap(
stage_cost_annotation.expand_entries())
stage1_cost = None
stage2_cost = None
for cdata, stagenum in stage_cost_assignments.items():
if stagenum == 1:
stage1_cost = cdata
elif stagenum == 2:
stage2_cost = cdata
if stage1_cost is None:
raise ValueError("Missing stage cost annotation "
"for time stage: 1")
if stage2_cost is None:
raise ValueError("Missing stage cost annotation "
"for time stage: 2")
assert stage1_cost is not stage2_cost
self._stage1_cost = stage1_cost
self._stage2_cost = stage2_cost
#
# Extract the locations of variables and stochastic data
# within the model
#
sto_obj = StochasticObjectiveAnnotation()
for objcntr, obj in enumerate(
self.reference_model.component_data_objects(Objective,
active=True,
descend_into=True),
1):
if objcntr > 1:
raise ValueError(
"Reference model can not contain more than one "
"active objective")
self.objective = obj
self.objective_sense = obj.sense
obj_params = tuple(
self._collect_mutable_parameters(obj.expr).values())
self.objective_to_stochastic_data_map[obj] = []
for paramdata in obj_params:
if paramdata in self.stochastic_data:
self.stochastic_data_to_objectives_map.\
setdefault(paramdata, []).append(obj)
self.objective_to_stochastic_data_map[obj].\
append(paramdata)
if len(self.objective_to_stochastic_data_map[obj]) == 0:
del self.objective_to_stochastic_data_map[obj]
else:
# TODO: Can we make this declaration sparse
# by identifying which variables have
# stochastic coefficients? How to handle
# non-linear expressions?
sto_obj.declare(obj)
obj_variables = tuple(self._collect_variables(obj.expr).values())
self.objective_to_variables_map[obj] = []
for var in obj_variables:
self.variable_to_objectives_map.\
setdefault(var, []).append(obj)
self.objective_to_variables_map[obj].append(var)
if len(self.objective_to_variables_map[obj]) == 0:
del self.objective_to_variables_map[obj]
sto_conbounds = StochasticConstraintBoundsAnnotation()
sto_conbody = StochasticConstraintBodyAnnotation()
for con in self.reference_model.component_data_objects(
Constraint, active=True, descend_into=True):
lower_params = tuple(
self._collect_mutable_parameters(con.lower).values())
body_params = tuple(
self._collect_mutable_parameters(con.body).values())
upper_params = tuple(
self._collect_mutable_parameters(con.upper).values())
# TODO: Can we make this declaration sparse
# by idenfifying which variables have
# stochastic coefficients? How to handle
# non-linear expressions? Currently, this
# code also fails to detect that mutable
# "constant" expressions might fall out
# of the body and into the bounds.
if len(body_params):
sto_conbody.declare(con)
if len(body_params) or \
len(lower_params) or \
len(upper_params):
sto_conbounds.declare(
con,
lb=bool(len(lower_params) or len(body_params)),
ub=bool(len(upper_params) or len(body_params)))
all_stochastic_params = {}
for param in itertools.chain(lower_params, body_params,
upper_params):
if param in self.stochastic_data:
all_stochastic_params[id(param)] = param
if len(all_stochastic_params) > 0:
self.constraint_to_stochastic_data_map[con] = []
# no params will appear twice in this iteration
for param in all_stochastic_params.values():
self.stochastic_data_to_constraints_map.\
setdefault(param, []).append(con)
self.constraint_to_stochastic_data_map[con].\
append(param)
body_variables = tuple(self._collect_variables(con.body).values())
self.constraint_to_variables_map[con] = []
for var in body_variables:
self.variable_to_constraints_map.\
setdefault(var, []).append(con)
self.constraint_to_variables_map[con].append(var)
# For now, it is okay to have SOSConstraints in the
# representation of a problem, but the SOS
# constraints can't have custom weights that
# represent stochastic data
for soscon in self.reference_model.component_data_objects(
SOSConstraint, active=True, descend_into=True):
for var, weight in soscon.get_items():
weight_params = tuple(
self._collect_mutable_parameters(weight).values())
if param in self.stochastic_data:
raise ValueError(
"SOSConstraints with stochastic data are currently"
" not supported in embedded stochastic programs. "
"The SOSConstraint component '%s' has a weight "
"term for variable '%s' that references stochastic"
" parameter '%s'" %
(soscon.name, var.name, param.name))
self.variable_to_constraints_map.\
setdefault(var, []).append(soscon)
self.constraint_to_variables_map.\
setdefault(soscon, []).append(var)
sto_varbounds = StochasticVariableBoundsAnnotation()
for var in self.reference_model.component_data_objects(
Var, descend_into=True):
lower_params = tuple(
self._collect_mutable_parameters(var.lb).values())
upper_params = tuple(
self._collect_mutable_parameters(var.ub).values())
if (len(lower_params) > 0) or \
(len(upper_params) > 0):
sto_varbounds.declare(var,
lb=bool(len(lower_params) > 0),
ub=bool(len(upper_params) > 0))
self.variable_to_stochastic_data_lb_map[var] = []
for param in lower_params:
if param in self.stochastic_data:
self.stochastic_data_to_variables_lb_map.\
setdefault(param, []).append(var)
self.variable_to_stochastic_data_lb_map[var].\
append(param)
if len(self.variable_to_stochastic_data_lb_map[var]) == 0:
del self.variable_to_stochastic_data_lb_map[var]
self.variable_to_stochastic_data_ub_map[var] = []
for param in upper_params:
if param in self.stochastic_data:
self.stochastic_data_to_variables_ub_map.\
setdefault(param, []).append(var)
self.variable_to_stochastic_data_ub_map[var].\
append(param)
if len(self.variable_to_stochastic_data_ub_map[var]) == 0:
del self.variable_to_stochastic_data_ub_map[var]
#
# Generate the explicit annotations
#
# first make sure these annotations do not already exist
if len(
locate_annotations(self.reference_model,
StochasticConstraintBoundsAnnotation)) > 0:
raise ValueError(
"Reference model can not contain "
"a StochasticConstraintBoundsAnnotation declaration.")
if len(
locate_annotations(self.reference_model,
StochasticConstraintBodyAnnotation)) > 0:
raise ValueError(
"Reference model can not contain "
"a StochasticConstraintBodyAnnotation declaration.")
if len(
locate_annotations(self.reference_model,
StochasticObjectiveAnnotation)) > 0:
raise ValueError("Reference model can not contain "
"a StochasticObjectiveAnnotation declaration.")
# now add any necessary annotations
if sto_obj.has_declarations:
assert not hasattr(
self.reference_model,
".pyspembeddedsp_stochastic_objective_annotation")
setattr(self.reference_model,
".pyspembeddedsp_stochastic_objective_annotation", sto_obj)
if sto_conbody.has_declarations:
assert not hasattr(
self.reference_model,
".pyspembeddedsp_stochastic_constraint_body_annotation")
setattr(self.reference_model,
".pyspembeddedsp_stochastic_constraint_body_annotation",
sto_conbody)
if sto_conbounds.has_declarations:
assert not hasattr(
self.reference_model,
".pyspembeddedsp_stochastic_constraint_bounds_annotation")
setattr(self.reference_model,
".pyspembeddedsp_stochastic_constraint_bounds_annotation",
sto_conbounds)
if sto_varbounds.has_declarations:
assert not hasattr(
self.reference_model,
".pyspembeddedsp_stochastic_variable_bounds_annotation")
setattr(self.reference_model,
".pyspembeddedsp_stochastic_variable_bounds_annotation",
sto_varbounds)
d2_rhs_table = [0, 1, 2, 3, 5]
d3_rhs_table = [0, 1, 2, 3]
model = ConcreteModel()
#-------C--------
# model.constraint_stage = PySP_ConstraintStageAnnotation()
# model.stoch_matrix = StochasticConstraintBodyAnnotation()
# num_scenarios = len(theta1_table)*len(theta2_table)
# scenario_data = dict(('Scenario'+str(i), (theta1val, theta2val))
# for i, (theta1val, theta2val) in
# enumerate (itertools.product(theta1_table, theta2_table),1))
#----------------
#-------D--------
model.constraint_stage = PySP_ConstraintStageAnnotation()
model.stoch_rhs = StochasticConstraintBoundsAnnotation()
model.stoch_matrix = StochasticConstraintBodyAnnotation()
num_scenarios = len(theta1_table) * len(theta2_table) * len(
d1_rhs_table) * len(d2_rhs_table) * len(d3_rhs_table)
scenario_data = dict(
('Scenario' + str(i), (theta1val, theta2val, d1_rhs_val, d2_rhs_val,
d3_rhs_val))
for i, (theta1val, theta2val, d1_rhs_val, d2_rhs_val,
d3_rhs_val) in enumerate(
itertools.product(theta1_table, theta2_table, d1_rhs_table,
d2_rhs_table, d3_rhs_table), 1))
#----------------
model.d1_rhs = Param(mutable=True, initialize=0.0)
model.d2_rhs = Param(mutable=True, initialize=0.0)
model.d3_rhs = Param(mutable=True, initialize=0.0)
def test_constraint_bounds(self):
m = pyo.ConcreteModel()
self._populate_block_with_constraints(m)
m.b = pyo.Block()
self._populate_block_with_constraints(m.b)
m.b_inactive = pyo.Block()
self._populate_block_with_constraints(m.b_inactive)
m.b_inactive.deactivate()
m.B = pyo.Block([1],
rule=lambda b: \
self._populate_block_with_constraints(b))
a = StochasticConstraintBoundsAnnotation()
self.assertEqual(a.default, True)
self.assertEqual(a.has_declarations, False)
a.declare(m.c)
self.assertEqual(a.has_declarations, True)
a.declare(m.C1)
a.declare(m.C2[1])
a.declare(m.C3)
a.declare(m.b)
a.declare(m.b_inactive)
a.declare(m.B, lb=False, ub=True)
with self.assertRaises(TypeError):
a.declare(None, 1)
self.assertEqual(
set([(v[0].name, v[1]) for v in a.expand_entries()]),
set([('c', True),
('C1[1]', True), ('C2[1]', True), ('C3[1]', True),
('b.c', True), ('b.C1[1]', True), ('b.C2[1]', True),
('b.C3[1]', True), ('B[1].c', (False, True)),
('B[1].C1[1]', (False, True)), ('B[1].C2[1]', (False, True)),
('B[1].C3[1]', (False, True))]))
self.assertEqual(
set([(v[0].name, v[1])
for v in a.expand_entries(expand_containers=False)]),
set([('c', True), ('C1', True), ('C2[1]', True), ('C3', True),
('b.c', True), ('b.C1', True), ('b.C2', True), ('b.C3', True),
('B[1].c', (False, True)), ('B[1].C1', (False, True)),
('B[1].C2', (False, True)), ('B[1].C3', (False, True))]))
def __init__(self, reference_model):
self.reference_model = None
self.objective = None
self.time_stages = None
self.stage_to_variables_map = {}
self.variable_to_stage_map = {}
# the set of stochastic data objects
# (possibly mapped to some distribution)
self.stochastic_data = None
# maps between variables and objectives
self.variable_to_objectives_map = ComponentMap()
self.objective_to_variables_map = ComponentMap()
# maps between variables and constraints
self.variable_to_constraints_map = ComponentMap()
self.constraint_to_variables_map = ComponentMap()
# maps between stochastic data and objectives
self.stochastic_data_to_objectives_map = ComponentMap()
self.objective_to_stochastic_data_map = ComponentMap()
# maps between stochastic data and constraints
self.stochastic_data_to_constraints_map = ComponentMap()
self.constraint_to_stochastic_data_map = ComponentMap()
# maps between stochastic data and variable lower and upper bounds
self.stochastic_data_to_variables_lb_map = ComponentMap()
self.variable_to_stochastic_data_lb_map = ComponentMap()
self.stochastic_data_to_variables_ub_map = ComponentMap()
self.variable_to_stochastic_data_ub_map = ComponentMap()
self.variable_symbols = ComponentMap()
if not isinstance(reference_model, Block):
raise TypeError("reference model input must be a Pyomo model")
self.reference_model = reference_model
#
# Extract stochastic parameters from the
# StochasticDataAnnotation object
#
self.stochastic_data = \
_extract_stochastic_data(self.reference_model)
#
# Get the variable stages from the
# VariableStageAnnotation object
#
(self.stage_to_variables_map,
self.variable_to_stage_map,
self._variable_stage_assignments) = \
_map_variable_stages(self.reference_model)
self.time_stages = tuple(sorted(self.stage_to_variables_map))
assert self.time_stages[0] == 1
self.variable_symbols = generate_cuid_names(self.reference_model,
ctype=Var)
# remove the parent blocks from this map
keys_to_delete = []
for var in self.variable_symbols:
if var.parent_component().type() is not Var:
keys_to_delete.append(var)
for key in keys_to_delete:
del self.variable_symbols[key]
#
# Get the stage cost components from the StageCostAnnotation
# and generate a dummy single-scenario scenario tree
#
stage_cost_annotation = locate_annotations(
self.reference_model,
StageCostAnnotation,
max_allowed=1)
if len(stage_cost_annotation) == 0:
raise ValueError(
"Reference model is missing stage cost "
"annotation: %s" % (StageCostAnnotation.__name__))
else:
assert len(stage_cost_annotation) == 1
stage_cost_annotation = stage_cost_annotation[0][1]
stage_cost_assignments = ComponentMap(
stage_cost_annotation.expand_entries())
stage1_cost = None
stage2_cost = None
for cdata, stagenum in stage_cost_assignments.items():
if stagenum == 1:
stage1_cost = cdata
elif stagenum == 2:
stage2_cost = cdata
if stage1_cost is None:
raise ValueError("Missing stage cost annotation "
"for time stage: 1")
if stage2_cost is None:
raise ValueError("Missing stage cost annotation "
"for time stage: 2")
assert stage1_cost is not stage2_cost
self._stage1_cost = stage1_cost
self._stage2_cost = stage2_cost
#
# Extract the locations of variables and stochastic data
# within the model
#
sto_obj = StochasticObjectiveAnnotation()
for objcntr, obj in enumerate(
self.reference_model.component_data_objects(
Objective,
active=True,
descend_into=True), 1):
if objcntr > 1:
raise ValueError(
"Reference model can not contain more than one "
"active objective")
self.objective = obj
self.objective_sense = obj.sense
obj_params = tuple(
self._collect_mutable_parameters(obj.expr).values())
self.objective_to_stochastic_data_map[obj] = []
for paramdata in obj_params:
if paramdata in self.stochastic_data:
self.stochastic_data_to_objectives_map.\
setdefault(paramdata, []).append(obj)
self.objective_to_stochastic_data_map[obj].\
append(paramdata)
if len(self.objective_to_stochastic_data_map[obj]) == 0:
del self.objective_to_stochastic_data_map[obj]
else:
# TODO: Can we make this declaration sparse
# by identifying which variables have
# stochastic coefficients? How to handle
# non-linear expressions?
sto_obj.declare(obj)
obj_variables = tuple(
self._collect_variables(obj.expr).values())
self.objective_to_variables_map[obj] = []
for var in obj_variables:
self.variable_to_objectives_map.\
setdefault(var, []).append(obj)
self.objective_to_variables_map[obj].append(var)
if len(self.objective_to_variables_map[obj]) == 0:
del self.objective_to_variables_map[obj]
sto_conbounds = StochasticConstraintBoundsAnnotation()
sto_conbody = StochasticConstraintBodyAnnotation()
for con in self.reference_model.component_data_objects(
Constraint,
active=True,
descend_into=True):
lower_params = tuple(
self._collect_mutable_parameters(con.lower).values())
body_params = tuple(
self._collect_mutable_parameters(con.body).values())
upper_params = tuple(
self._collect_mutable_parameters(con.upper).values())
# TODO: Can we make this declaration sparse
# by idenfifying which variables have
# stochastic coefficients? How to handle
# non-linear expressions? Currently, this
# code also fails to detect that mutable
# "constant" expressions might fall out
# of the body and into the bounds.
if len(body_params):
sto_conbody.declare(con)
if len(body_params) or \
len(lower_params) or \
len(upper_params):
sto_conbounds.declare(con,
lb=bool(len(lower_params) or len(body_params)),
ub=bool(len(upper_params) or len(body_params)))
all_stochastic_params = {}
for param in itertools.chain(lower_params,
body_params,
upper_params):
if param in self.stochastic_data:
all_stochastic_params[id(param)] = param
if len(all_stochastic_params) > 0:
self.constraint_to_stochastic_data_map[con] = []
# no params will appear twice in this iteration
for param in all_stochastic_params.values():
self.stochastic_data_to_constraints_map.\
setdefault(param, []).append(con)
self.constraint_to_stochastic_data_map[con].\
append(param)
body_variables = tuple(
self._collect_variables(con.body).values())
self.constraint_to_variables_map[con] = []
for var in body_variables:
self.variable_to_constraints_map.\
setdefault(var, []).append(con)
self.constraint_to_variables_map[con].append(var)
# For now, it is okay to have SOSConstraints in the
# representation of a problem, but the SOS
# constraints can't have custom weights that
# represent stochastic data
for soscon in self.reference_model.component_data_objects(
SOSConstraint,
active=True,
descend_into=True):
for var, weight in soscon.get_items():
weight_params = tuple(
self._collect_mutable_parameters(weight).values())
if param in self.stochastic_data:
raise ValueError(
"SOSConstraints with stochastic data are currently"
" not supported in embedded stochastic programs. "
"The SOSConstraint component '%s' has a weight "
"term for variable '%s' that references stochastic"
" parameter '%s'"
% (soscon.name,
var.name,
param.name))
self.variable_to_constraints_map.\
setdefault(var, []).append(soscon)
self.constraint_to_variables_map.\
setdefault(soscon, []).append(var)
sto_varbounds = StochasticVariableBoundsAnnotation()
for var in self.reference_model.component_data_objects(
Var,
descend_into=True):
lower_params = tuple(
self._collect_mutable_parameters(var.lb).values())
upper_params = tuple(
self._collect_mutable_parameters(var.ub).values())
if (len(lower_params) > 0) or \
(len(upper_params) > 0):
sto_varbounds.declare(var,
lb=bool(len(lower_params) > 0),
ub=bool(len(upper_params) > 0))
self.variable_to_stochastic_data_lb_map[var] = []
for param in lower_params:
if param in self.stochastic_data:
self.stochastic_data_to_variables_lb_map.\
setdefault(param, []).append(var)
self.variable_to_stochastic_data_lb_map[var].\
append(param)
if len(self.variable_to_stochastic_data_lb_map[var]) == 0:
del self.variable_to_stochastic_data_lb_map[var]
self.variable_to_stochastic_data_ub_map[var] = []
for param in upper_params:
if param in self.stochastic_data:
self.stochastic_data_to_variables_ub_map.\
setdefault(param, []).append(var)
self.variable_to_stochastic_data_ub_map[var].\
append(param)
if len(self.variable_to_stochastic_data_ub_map[var]) == 0:
del self.variable_to_stochastic_data_ub_map[var]
#
# Generate the explicit annotations
#
# first make sure these annotations do not already exist
if len(locate_annotations(self.reference_model,
StochasticConstraintBoundsAnnotation)) > 0:
raise ValueError("Reference model can not contain "
"a StochasticConstraintBoundsAnnotation declaration.")
if len(locate_annotations(self.reference_model,
StochasticConstraintBodyAnnotation)) > 0:
raise ValueError("Reference model can not contain "
"a StochasticConstraintBodyAnnotation declaration.")
if len(locate_annotations(self.reference_model,
StochasticObjectiveAnnotation)) > 0:
raise ValueError("Reference model can not contain "
"a StochasticObjectiveAnnotation declaration.")
# now add any necessary annotations
if sto_obj.has_declarations:
assert not hasattr(self.reference_model,
".pyspembeddedsp_stochastic_objective_annotation")
setattr(self.reference_model,
".pyspembeddedsp_stochastic_objective_annotation",
sto_obj)
if sto_conbody.has_declarations:
assert not hasattr(self.reference_model,
".pyspembeddedsp_stochastic_constraint_body_annotation")
setattr(self.reference_model,
".pyspembeddedsp_stochastic_constraint_body_annotation",
sto_conbody)
if sto_conbounds.has_declarations:
assert not hasattr(self.reference_model,
".pyspembeddedsp_stochastic_constraint_bounds_annotation")
setattr(self.reference_model,
".pyspembeddedsp_stochastic_constraint_bounds_annotation",
sto_conbounds)
if sto_varbounds.has_declarations:
assert not hasattr(self.reference_model,
".pyspembeddedsp_stochastic_variable_bounds_annotation")
setattr(self.reference_model,
".pyspembeddedsp_stochastic_variable_bounds_annotation",
sto_varbounds)
def pysp_annotation_rule(model):
# to enable SMPS and or DDSIP
model.stoch_rhs = StochasticConstraintBoundsAnnotation()
model.stoch_rhs.declare(model.FlowBalanceConstraint)
model.stoch_matrix = StochasticConstraintBodyAnnotation()
model.stoch_matrix.declare(model.ComputeSecondStageCost)
def pysp_annotation_rule(model):
# to enable SMPS and or DDSIP
model.stoch_rhs = StochasticConstraintBoundsAnnotation()
model.stoch_rhs.declare(model.DemandSatisfiedSecondStage)
def test_constraint_bounds(self):
m = aml.ConcreteModel()
self._populate_block_with_constraints(m)
m.b = aml.Block()
self._populate_block_with_constraints(m.b)
m.b_inactive = aml.Block()
self._populate_block_with_constraints(m.b_inactive)
m.b_inactive.deactivate()
m.B = aml.Block([1],
rule=lambda b: \
self._populate_block_with_constraints(b))
a = StochasticConstraintBoundsAnnotation()
self.assertEqual(a.default, True)
self.assertEqual(a.has_declarations, False)
a.declare(m.c)
self.assertEqual(a.has_declarations, True)
a.declare(m.C1)
a.declare(m.C2[1])
a.declare(m.C3)
a.declare(m.b)
a.declare(m.b_inactive)
a.declare(m.B, lb=False, ub=True)
with self.assertRaises(TypeError):
a.declare(None, 1)
self.assertEqual(
set([(v[0].name, v[1]) for v in a.expand_entries()]),
set([('c', True), ('C1[1]', True), ('C2[1]', True), ('C3[1]', True),
('b.c', True), ('b.C1[1]', True), ('b.C2[1]', True), ('b.C3[1]', True),
('B[1].c', (False,True)), ('B[1].C1[1]', (False,True)),
('B[1].C2[1]', (False,True)), ('B[1].C3[1]', (False,True))]))
self.assertEqual(
set([(v[0].name, v[1]) for v in a.expand_entries(expand_containers=False)]),
set([('c', True), ('C1', True), ('C2[1]', True), ('C3', True),
('b.c', True), ('b.C1', True), ('b.C2', True), ('b.C3', True),
('B[1].c', (False,True)), ('B[1].C1', (False,True)),
('B[1].C2', (False,True)), ('B[1].C3', (False,True))]))