def createScenarioTreeModel(self):
"""
Construct scenario tree based on abstract scenario tree model for stochastic programming
@ In, None
@ Out, treeModel, Instance, pyomo scenario tree model
"""
treeModel = CreateAbstractScenarioTreeModel()
if pyoVersion:
treeModel = treeModel.create_instance()
treeModel.Stages.add('FirstStage')
treeModel.Stages.add('SecondStage')
treeModel.Nodes.add('RootNode')
for i in self.scenarios['scenario_name']:
leafNode = 'leaf_' + i
treeModel.Nodes.add(leafNode)
treeModel.Scenarios.add(i)
if not pyoVersion:
treeModel = treeModel.create_instance()
treeModel.NodeStage['RootNode'] = 'FirstStage'
treeModel.ConditionalProbability['RootNode'] = 1.0
for node in treeModel.Nodes:
if node != 'RootNode':
treeModel.NodeStage[node] = 'SecondStage'
treeModel.Children['RootNode'].add(node)
treeModel.Children[node].clear()
treeModel.ConditionalProbability[node] = self.scenarios['probabilities'][node.replace('leaf_','')]
treeModel.ScenarioLeafNode[node.replace('leaf_','')] = node
return treeModel
def _generate_base_scenario_tree(self, model, variable_stage_assignments):
stage_cost_annotation = locate_annotations(
model,
PySP_StageCostAnnotation,
max_allowed=1)
if len(stage_cost_annotation) == 0:
raise ValueError("Reference model is missing stage cost "
"annotation: %s" % (PySP_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 != stage2_cost
#
# Create a dummy 1-scenario scenario tree
#
stm = CreateAbstractScenarioTreeModel()
stm.Stages.add('Stage1')
stm.Stages.add('Stage2')
stm.Nodes.add('RootNode')
stm.Nodes.add('LeafNode')
stm.Scenarios.add('ReferenceScenario')
stm = stm.create_instance()
stm.NodeStage['RootNode'] = 'Stage1'
stm.ConditionalProbability['RootNode'] = 1.0
stm.NodeStage['LeafNode'] = 'Stage2'
stm.Children['RootNode'].add('LeafNode')
stm.Children['LeafNode'].clear()
stm.ConditionalProbability['LeafNode'] = 1.0
stm.ScenarioLeafNode['ReferenceScenario'] = 'LeafNode'
stm.StageCost['Stage1'] = stage1_cost.name
stm.StageCost['Stage2'] = stage2_cost.name
for var, (stagenum, derived) in variable_stage_assignments.items():
stagelabel = 'Stage'+str(stagenum)
if not derived:
stm.StageVariables[stagelabel].add(var.name)
else:
stm.StageDerivedVariables[second_stage].add(var.name)
scenario_tree = ScenarioTree(scenariotreeinstance=stm)
scenario_tree.linkInInstances(
{'ReferenceScenario': self.reference_model})
return scenario_tree
def _treemaker(scenlist):
"""Makes a scenario tree (avoids dependence on daps)
Parameters
----------
scenlist (list of `int`): experiment (i.e. scenario) numbers
Returns
-------
a `ConcreteModel` that is the scenario tree
"""
num_scenarios = len(scenlist)
m = CreateAbstractScenarioTreeModel()
m.Stages.add('Stage1')
m.Stages.add('Stage2')
m.Nodes.add('RootNode')
for i in scenlist:
m.Nodes.add('LeafNode_Experiment' + str(i))
m.Scenarios.add('Experiment' + str(i))
m = m.create_instance()
m.NodeStage['RootNode'] = 'Stage1'
m.ConditionalProbability['RootNode'] = 1.0
for node in m.Nodes:
if node != 'RootNode':
m.NodeStage[node] = 'Stage2'
m.Children['RootNode'].add(node)
m.Children[node].clear()
m.ConditionalProbability[node] = 1.0 / num_scenarios
m.ScenarioLeafNode[node.replace('LeafNode_', '')] = node
return m
def setUp(self):
""" Get ready for tests"""
######## make a temp dir to which files can be copied #####
self.tdir = tempfile.mkdtemp() #TemporaryDirectory().name
sys.path.insert(1,self.tdir)
""" During debugging, local files might get in the way
of finding the file in the temp dir, so we cd there."""
self.savecwd = os.getcwd()
os.chdir(self.tdir)
p = str(pyomoroot.__path__)
l = p.find("'")
r = p.find("'", l+1)
pyomorootpath = p[l+1:r]
farmpath = pyomorootpath + os.sep + ".." + os.sep + "examples" + \
os.sep + "pysp" + os.sep + "farmer"
farmpath = os.path.abspath(farmpath)
self.farmer_concrete_file = farmpath + os.sep + \
"concrete" + os.sep + "ReferenceModel.py"
shutil.copyfile(self.farmer_concrete_file,
self.tdir + os.sep + "ReferenceModel.py")
abstract_tree = CreateAbstractScenarioTreeModel()
shutil.copyfile(farmpath + os.sep +"scenariodata" + os.sep + "ScenarioStructure.dat",
self.tdir + os.sep + "ScenarioStructure.dat")
self.farmer_concrete_tree = \
abstract_tree.create_instance("ScenarioStructure.dat")
def setUp(self):
""" Get ready for tests"""
######## make a temp dir to which files can be copied #####
self.tdir = tempfile.mkdtemp() #TemporaryDirectory().name
sys.path.insert(1, self.tdir)
""" During debugging, local files might get in the way
of finding the file in the temp dir, so we cd there."""
self.savecwd = os.getcwd()
os.chdir(self.tdir)
p = str(pyomoroot.__path__)
l = p.find("'")
r = p.find("'", l + 1)
pyomorootpath = p[l + 1:r]
farmpath = pyomorootpath + os.sep + ".." + os.sep + "examples" + \
os.sep + "pysp" + os.sep + "farmer"
farmpath = os.path.abspath(farmpath)
self.farmer_concrete_file = farmpath + os.sep + \
"concrete" + os.sep + "ReferenceModel.py"
shutil.copyfile(self.farmer_concrete_file,
self.tdir + os.sep + "ReferenceModel.py")
abstract_tree = CreateAbstractScenarioTreeModel()
shutil.copyfile(
farmpath + os.sep + "scenariodata" + os.sep +
"ScenarioStructure.dat",
self.tdir + os.sep + "ScenarioStructure.dat")
self.farmer_concrete_tree = \
abstract_tree.create_instance("ScenarioStructure.dat")
def solve_sto(f, IndexReturn, Tbill):
#The next two lines show one way to create a concrete scenario tree. There are
#others that can be found in `pyomo.pysp.scenariotree.tree_structure_model`.
abstract_tree = CreateAbstractScenarioTreeModel()
concrete_tree = abstract_tree.create_instance("/Users/xiaoshiguo/Desktop/model"+str(J)+"/ScenarioStructure"+str(J)+".dat")
concrete_tree.IndexReturn = IndexReturn # line added by DLW
concrete_tree.Tbill = Tbill
stsolver = rapper.StochSolver("ReferenceModel"+str(J)+".py", fsfct = "pysp_instance_creation_callback", tree_model = concrete_tree)
#stsolver = rapper.StochSolver("/Users/xiaoshiguo/Desktop/portfolio/models/ReferenceModel.py", tree_model = concrete_tree)
ef_sol = stsolver.solve_ef('glpk', tee=False)
# ef_sol = stsolver.solve_ph(subsolver = solvername, default_rho = 1)
if ef_sol.solver.termination_condition != TerminationCondition.optimal:
print ("oops! not optimal:",ef_sol.solver.termination_condition)
#There is an iterator to loop over the root node solution:
for varname, varval in stsolver.root_Var_solution():
if varname == "weight":
weight = varval
else:
eta = varval
#print (varname, str(varval))
#a function to compute compute the objective function value
obj = stsolver.root_E_obj()
#print ("Expecatation take over scenarios=", obj)
# write down scenario tree in testcref file
#csvw.write_csv_soln(stsolver.scenario_tree, str(f))
return obj, weight, eta
def _generate_base_scenario_tree(self, model, variable_stage_assignments):
stage_cost_annotation = locate_annotations(model,
PySP_StageCostAnnotation,
max_allowed=1)
if len(stage_cost_annotation) == 0:
raise ValueError("Reference model is missing stage cost "
"annotation: %s" %
(PySP_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 != stage2_cost
#
# Create a dummy 1-scenario scenario tree
#
stm = CreateAbstractScenarioTreeModel()
stm.Stages.add('Stage1')
stm.Stages.add('Stage2')
stm.Nodes.add('RootNode')
stm.Nodes.add('LeafNode')
stm.Scenarios.add('ReferenceScenario')
stm = stm.create_instance()
stm.NodeStage['RootNode'] = 'Stage1'
stm.ConditionalProbability['RootNode'] = 1.0
stm.NodeStage['LeafNode'] = 'Stage2'
stm.Children['RootNode'].add('LeafNode')
stm.Children['LeafNode'].clear()
stm.ConditionalProbability['LeafNode'] = 1.0
stm.ScenarioLeafNode['ReferenceScenario'] = 'LeafNode'
stm.StageCost['Stage1'] = stage1_cost.name
stm.StageCost['Stage2'] = stage2_cost.name
for var, (stagenum, derived) in variable_stage_assignments.items():
stagelabel = 'Stage' + str(stagenum)
if not derived:
stm.StageVariables[stagelabel].add(var.name)
else:
stm.StageDerivedVariables[second_stage].add(var.name)
scenario_tree = ScenarioTree(scenariotreeinstance=stm)
scenario_tree.linkInInstances(
{'ReferenceScenario': self.reference_model})
return scenario_tree
def _treemaker(scenlist):
"""
Makes a scenario tree (avoids dependence on daps)
Parameters
----------
scenlist (list of `int`): experiment (i.e. scenario) numbers
Returns
-------
a `ConcreteModel` that is the scenario tree
"""
num_scenarios = len(scenlist)
m = CreateAbstractScenarioTreeModel()
m.Stages.add('Stage1')
m.Stages.add('Stage2')
m.Nodes.add('RootNode')
for i in scenlist:
m.Nodes.add('LeafNode_Experiment'+str(i))
m.Scenarios.add('Experiment'+str(i))
m = m.create_instance()
m.NodeStage['RootNode'] = 'Stage1'
m.ConditionalProbability['RootNode'] = 1.0
for node in m.Nodes:
if node != 'RootNode':
m.NodeStage[node] = 'Stage2'
m.Children['RootNode'].add(node)
m.Children[node].clear()
m.ConditionalProbability[node] = 1.0/num_scenarios
m.ScenarioLeafNode[node.replace('LeafNode_','')] = node
return m
def _create_scenario_tree_model(self, size):
assert size > 0
stm = CreateAbstractScenarioTreeModel()
stm.Stages.add('t1')
stm.Stages.add('t2')
stm.Nodes.add('root')
for i in xrange(1, size+1):
stm.Nodes.add('n'+str(i))
stm.Scenarios.add('s'+str(i))
stm = stm.create_instance()
stm.NodeStage['root'] = 't1'
stm.ConditionalProbability['root'] = 1.0
weight = 1.0/float(size)
for i in xrange(1, size+1):
node_name = 'n'+str(i)
scen_name = 's'+str(i)
stm.NodeStage[node_name] = 't2'
stm.Children['root'].add(node_name)
stm.Children[node_name].clear()
stm.ConditionalProbability[node_name] = weight
stm.ScenarioLeafNode[scen_name] = node_name
stm.StageCost['t1'] = self._stage1_cost.name
stm.StageCost['t2'] = self._stage2_cost.name
for var, (stagenum, derived) in \
self._variable_stage_assignments.items():
stage_name = 't'+str(stagenum)
if not derived:
stm.StageVariables[stage_name].add(var.name)
else:
stm.StageDerivedVariables[stage_name].add(var.name)
return stm
def pysp_scenario_tree_model_callback():
from pyomo.pysp.scenariotree.tree_structure_model import \
CreateAbstractScenarioTreeModel
#Model
st_model = CreateAbstractScenarioTreeModel()
#----------------------------------------
#Basic Spectification
#----------------------------------------
#Stages-------------------
for i in Root.stages:
st_model.Stages.add(i)
#Nodes--------------------
for i in sorted(Case.tree.nodes()):
st_model.Nodes.add(i)
#Scenarios----------------
for i in sorted(Case.names):
st_model.Scenarios.add(i)
st_model = st_model.create_instance()
#----------------------------------------
#Advanced Spectification
#----------------------------------------
#Scenario Leaf Node
for i in sorted(Case.names):
st_model.ScenarioLeafNode[i] = Case.scenario_node[i]
#Node attributes
for i in st_model.Nodes:
#Conditional probability
st_model.ConditionalProbability[i] = Case.tree.node[i]['probability']
#Stage
st_model.NodeStage[i] = Case.tree.node[i]['stage']
#Children Node
for j in Case.tree.edges(i):
st_model.Children[i].add(j[1])
#-------------------------------------------
#Variable /Objective Spectification
#-------------------------------------------
for i in Root.variables:
st_model.StageVariables[Root.st_to_var[i]].add('x[' + i + ']')
for i in Root.stages:
st_model.StageCost[i] = 'SC[' + i + ']'
return st_model
