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