def test_singletonblock_noindextemplate(self):
        st_model = CreateConcreteTwoStageScenarioTreeModel(1)
        st_model.StageVariables['Stage1'].add("b1")
        st_model.StageDerivedVariables['Stage1'].add("b2")
        st_model.NodeVariables['RootNode'].add("b3")
        st_model.NodeDerivedVariables['RootNode'].add("b4")
        st_model.StageCost['Stage1'] = "FirstStageCost"
        st_model.StageCost['Stage2'] = "SecondStageCost"

        scenario_tree = ScenarioTree(scenariotreeinstance=st_model)
        self.assertEqual(len(scenario_tree.stages), 2)
        self.assertEqual(len(scenario_tree.nodes), 2)
        self.assertEqual(len(scenario_tree.scenarios), 1)

        model = self._get_block_model()

        scenario_tree.linkInInstances({'Scenario1': model})

        root = scenario_tree.findRootNode()
        self.assertEqual(len(root._variable_ids), 12)
        self.assertEqual(len(root._standard_variable_ids), 6)
        self.assertEqual(len(root._derived_variable_ids), 6)
        for name in ("b1.x", "b2.x", "b3.x", "b4.x"):
            for index in [None]:
                self.assertEqual(
                    (name,index) in root._name_index_to_id, True)
        for name in ("b1.X", "b2.X", "b3.X", "b4.X"):
            for index in model.s:
                self.assertEqual(
                    (name,index) in root._name_index_to_id, True)
Exemple #2
0
    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
Exemple #3
0
    def test_indexedvar_noindextemplate(self):
        st_model = CreateConcreteTwoStageScenarioTreeModel(1)
        st_model.StageVariables['Stage1'].add("x")
        st_model.StageDerivedVariables['Stage1'].add("y")
        st_model.NodeVariables['RootNode'].add("z")
        st_model.NodeDerivedVariables['RootNode'].add("q")
        st_model.StageCost['Stage1'] = "FirstStageCost"
        st_model.StageCost['Stage2'] = "SecondStageCost"

        scenario_tree = ScenarioTree(scenariotreeinstance=st_model)
        self.assertEqual(len(scenario_tree.stages), 2)
        self.assertEqual(len(scenario_tree.nodes), 2)
        self.assertEqual(len(scenario_tree.scenarios), 1)

        model = ConcreteModel()
        model.s = Set(initialize=[1, 2, 3])
        model.x = Var(model.s)
        model.y = Var(model.s)
        model.z = Var(model.s)
        model.q = Var(model.s)
        model.FirstStageCost = Expression(expr=0.0)
        model.SecondStageCost = Expression(expr=0.0)
        model.obj = Objective(expr=0.0)

        scenario_tree.linkInInstances({'Scenario1': model})

        root = scenario_tree.findRootNode()
        self.assertEqual(len(root._variable_ids), 12)
        self.assertEqual(len(root._standard_variable_ids), 6)
        self.assertEqual(len(root._derived_variable_ids), 6)
        for name in ("x", "y", "z", "q"):
            for index in model.s:
                self.assertEqual((name, index) in root._name_index_to_id, True)
Exemple #4
0
    def test_indexedblock_wildcardtemplate(self):
        st_model = CreateConcreteTwoStageScenarioTreeModel(1)
        st_model.StageVariables['Stage1'].add("B1[*]")
        st_model.StageDerivedVariables['Stage1'].add("B2[*]")
        st_model.NodeVariables['RootNode'].add("B3[*]")
        st_model.NodeDerivedVariables['RootNode'].add("B4[*]")
        st_model.StageCost['Stage1'] = "FirstStageCost"
        st_model.StageCost['Stage2'] = "SecondStageCost"

        scenario_tree = ScenarioTree(scenariotreeinstance=st_model)
        self.assertEqual(len(scenario_tree.stages), 2)
        self.assertEqual(len(scenario_tree.nodes), 2)
        self.assertEqual(len(scenario_tree.scenarios), 1)

        model = self._get_block_model()

        scenario_tree.linkInInstances({'Scenario1': model})

        root = scenario_tree.findRootNode()
        self.assertEqual(len(root._variable_ids), 24)
        self.assertEqual(len(root._standard_variable_ids), 12)
        self.assertEqual(len(root._derived_variable_ids), 12)
        for name in ("B1[1].x", "B1[2].x", "B2[1].x", "B2[2].x", "B3[1].x",
                     "B3[2].x", "B4[1].x", "B4[2].x"):
            for index in [None]:
                self.assertEqual((name, index) in root._name_index_to_id, True)
        for name in ("B1[1].X", "B1[2].X", "B2[1].X", "B2[2].X", "B3[1].X",
                     "B3[2].X", "B4[1].X", "B4[2].X"):
            for index in model.s:
                self.assertEqual((name, index) in root._name_index_to_id, True)
    def test_singletonvar_wildcardtemplate(self):
        st_model = CreateConcreteTwoStageScenarioTreeModel(1)
        st_model.StageVariables['Stage1'].add("x[*]")
        st_model.StageDerivedVariables['Stage1'].add("y[*]")
        st_model.NodeVariables['RootNode'].add("z[*]")
        st_model.NodeDerivedVariables['RootNode'].add("q[*]")
        st_model.StageCost['Stage1'] = "FirstStageCost"
        st_model.StageCost['Stage2'] = "SecondStageCost"

        scenario_tree = ScenarioTree(scenariotreeinstance=st_model)
        self.assertEqual(len(scenario_tree.stages), 2)
        self.assertEqual(len(scenario_tree.nodes), 2)
        self.assertEqual(len(scenario_tree.scenarios), 1)

        model = ConcreteModel()
        model.x = Var()
        model.y = Var()
        model.z = Var()
        model.q = Var()
        model.FirstStageCost = Expression(expr=0.0)
        model.SecondStageCost = Expression(expr=0.0)
        model.obj = Objective(expr=0.0)

        scenario_tree.linkInInstances({'Scenario1': model})

        root = scenario_tree.findRootNode()
        self.assertEqual(len(root._variable_ids), 4)
        self.assertEqual(len(root._standard_variable_ids), 2)
        self.assertEqual(len(root._derived_variable_ids), 2)
        for name in ("x", "y", "z", "q"):
            for index in [None]:
                self.assertEqual(
                    (name,index) in root._name_index_to_id, True)
Exemple #6
0
    def test_singletonvar_wildcardtemplate(self):
        st_model = CreateConcreteTwoStageScenarioTreeModel(1)
        st_model.StageVariables['Stage1'].add("x[*]")
        st_model.StageDerivedVariables['Stage1'].add("y[*]")
        st_model.NodeVariables['RootNode'].add("z[*]")
        st_model.NodeDerivedVariables['RootNode'].add("q[*]")
        st_model.StageCost['Stage1'] = "FirstStageCost"
        st_model.StageCost['Stage2'] = "SecondStageCost"

        scenario_tree = ScenarioTree(scenariotreeinstance=st_model)
        self.assertEqual(len(scenario_tree.stages), 2)
        self.assertEqual(len(scenario_tree.nodes), 2)
        self.assertEqual(len(scenario_tree.scenarios), 1)

        model = ConcreteModel()
        model.x = Var()
        model.y = Var()
        model.z = Var()
        model.q = Var()
        model.FirstStageCost = Expression(expr=0.0)
        model.SecondStageCost = Expression(expr=0.0)
        model.obj = Objective(expr=0.0)

        scenario_tree.linkInInstances({'Scenario1': model})

        root = scenario_tree.findRootNode()
        self.assertEqual(len(root._variable_ids), 4)
        self.assertEqual(len(root._standard_variable_ids), 2)
        self.assertEqual(len(root._derived_variable_ids), 2)
        for name in ("x", "y", "z", "q"):
            for index in [None]:
                self.assertEqual((name, index) in root._name_index_to_id, True)
Exemple #7
0
    def test_singletonblock_noindextemplate(self):
        st_model = CreateConcreteTwoStageScenarioTreeModel(1)
        st_model.StageVariables['Stage1'].add("b1")
        st_model.StageDerivedVariables['Stage1'].add("b2")
        st_model.NodeVariables['RootNode'].add("b3")
        st_model.NodeDerivedVariables['RootNode'].add("b4")
        st_model.StageCost['Stage1'] = "FirstStageCost"
        st_model.StageCost['Stage2'] = "SecondStageCost"

        scenario_tree = ScenarioTree(scenariotreeinstance=st_model)
        self.assertEqual(len(scenario_tree.stages), 2)
        self.assertEqual(len(scenario_tree.nodes), 2)
        self.assertEqual(len(scenario_tree.scenarios), 1)

        model = self._get_block_model()

        scenario_tree.linkInInstances({'Scenario1': model})

        root = scenario_tree.findRootNode()
        self.assertEqual(len(root._variable_ids), 12)
        self.assertEqual(len(root._standard_variable_ids), 6)
        self.assertEqual(len(root._derived_variable_ids), 6)
        for name in ("b1.x", "b2.x", "b3.x", "b4.x"):
            for index in [None]:
                self.assertEqual((name, index) in root._name_index_to_id, True)
        for name in ("b1.X", "b2.X", "b3.X", "b4.X"):
            for index in model.s:
                self.assertEqual((name, index) in root._name_index_to_id, True)
    def test_indexedvar_noindextemplate(self):
        st_model = CreateConcreteTwoStageScenarioTreeModel(1)
        st_model.StageVariables['Stage1'].add("x")
        st_model.StageDerivedVariables['Stage1'].add("y")
        st_model.NodeVariables['RootNode'].add("z")
        st_model.NodeDerivedVariables['RootNode'].add("q")
        st_model.StageCost['Stage1'] = "FirstStageCost"
        st_model.StageCost['Stage2'] = "SecondStageCost"

        scenario_tree = ScenarioTree(scenariotreeinstance=st_model)
        self.assertEqual(len(scenario_tree.stages), 2)
        self.assertEqual(len(scenario_tree.nodes), 2)
        self.assertEqual(len(scenario_tree.scenarios), 1)

        model = ConcreteModel()
        model.s = Set(initialize=[1,2,3])
        model.x = Var(model.s)
        model.y = Var(model.s)
        model.z = Var(model.s)
        model.q = Var(model.s)
        model.FirstStageCost = Expression(expr=0.0)
        model.SecondStageCost = Expression(expr=0.0)
        model.obj = Objective(expr=0.0)

        scenario_tree.linkInInstances({'Scenario1': model})

        root = scenario_tree.findRootNode()
        self.assertEqual(len(root._variable_ids), 12)
        self.assertEqual(len(root._standard_variable_ids), 6)
        self.assertEqual(len(root._derived_variable_ids), 6)
        for name in ("x", "y", "z", "q"):
            for index in model.s:
                self.assertEqual(
                    (name,index) in root._name_index_to_id, True)
Exemple #9
0
    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
Exemple #10
0
 def test_two_stage_custom_names(self):
     G = networkx.DiGraph()
     G.add_node("R", label="Root")
     G.add_node("C1", label="Child1")
     G.add_edge("R", "C1", weight=0.8)
     G.add_node("C2", label="Child2")
     G.add_edge("R", "C2", weight=0.2)
     model = ScenarioTreeModelFromNetworkX(
         G,
         edge_probability_attribute='weight',
         node_name_attribute='label',
         stage_names=['T1', 'T2'],
         scenario_names={
             'C1': 'S1',
             'C2': 'S2'
         })
     self.assertEqual(sorted(list(model.Stages)), sorted(['T1', 'T2']))
     self.assertEqual(sorted(list(model.Nodes)),
                      sorted(['Root', 'Child1', 'Child2']))
     self.assertEqual(sorted(list(model.Children['Root'])),
                      sorted(['Child1', 'Child2']))
     self.assertEqual(sorted(list(model.Children['Child1'])), sorted([]))
     self.assertEqual(sorted(list(model.Children['Child2'])), sorted([]))
     self.assertEqual(sorted(list(model.Scenarios)), sorted(['S1', 'S2']))
     self.assertEqual(model.ConditionalProbability['Root'], 1.0)
     self.assertEqual(model.ConditionalProbability['Child1'], 0.8)
     self.assertEqual(model.ConditionalProbability['Child2'], 0.2)
     model.StageCost['T1'] = 'c1'
     model.StageCost['T2'] = 'c2'
     model.StageVariables['T1'].add('x')
     ScenarioTree(scenariotreeinstance=model)
Exemple #11
0
 def test_bundles(self):
     G = networkx.DiGraph()
     G.add_node("r")
     for i in range(4):
         G.add_node("u" + str(i), bundle=i % 2)
         G.add_edge("r", "u" + str(i))
     model = ScenarioTreeModelFromNetworkX(G,
                                           edge_probability_attribute=None)
     self.assertEqual(sorted(list(model.Stages)),
                      sorted(["Stage1", "Stage2"]))
     self.assertEqual(sorted(list(model.Nodes)),
                      sorted(["r", "u0", "u1", "u2", "u3"]))
     self.assertEqual(sorted(list(model.Children["r"])),
                      sorted(["u0", "u1", "u2", "u3"]))
     for i in range(4):
         self.assertEqual(sorted(list(model.Children["u" + str(i)])),
                          sorted([]))
     self.assertEqual(sorted(list(model.Scenarios)),
                      sorted(["u0", "u1", "u2", "u3"]))
     self.assertEqual(model.ConditionalProbability["r"], 1.0)
     for i in range(4):
         self.assertEqual(model.ConditionalProbability["u" + str(i)], 0.25)
     self.assertEqual(model.Bundling.value, True)
     self.assertEqual(list(model.Bundles), [0, 1])
     for k, bundle_name in enumerate(model.Bundles):
         self.assertEqual(list(model.BundleScenarios[bundle_name]),
                          ["u" + str(i) for i in range(4) if i % 2 == k])
     model.StageCost["Stage1"] = "c1"
     model.StageCost["Stage2"] = "c2"
     model.StageVariables["Stage1"].add("x")
     ScenarioTree(scenariotreeinstance=model)
Exemple #12
0
 def test_two_stage_custom_names(self):
     G = networkx.DiGraph()
     G.add_node("R", label="Root")
     G.add_node("C1", label="Child1", scenario="S1")
     G.add_edge("R", "C1", probability=0.8)
     G.add_node("C2", label="Child2", scenario="S2")
     G.add_edge("R", "C2", probability=0.2)
     model = ScenarioTreeModelFromNetworkX(
         G,
         edge_probability_attribute="probability",
         node_name_attribute="label",
         stage_names=["T1", "T2"],
         scenario_name_attribute="scenario")
     self.assertEqual(sorted(list(model.Stages)), sorted(["T1", "T2"]))
     self.assertEqual(sorted(list(model.Nodes)),
                      sorted(["Root", "Child1", "Child2"]))
     self.assertEqual(sorted(list(model.Children["Root"])),
                      sorted(["Child1", "Child2"]))
     self.assertEqual(sorted(list(model.Children["Child1"])), sorted([]))
     self.assertEqual(sorted(list(model.Children["Child2"])), sorted([]))
     self.assertEqual(sorted(list(model.Scenarios)), sorted(["S1", "S2"]))
     self.assertEqual(model.ConditionalProbability["Root"], 1.0)
     self.assertEqual(model.ConditionalProbability["Child1"], 0.8)
     self.assertEqual(model.ConditionalProbability["Child2"], 0.2)
     model.StageCost["T1"] = "c1"
     model.StageCost["T2"] = "c2"
     model.StageVariables["T1"].add("x")
     self.assertEqual(model.Bundling.value, False)
     self.assertEqual(list(model.Bundles), [])
     self.assertEqual(len(model.BundleScenarios), 0)
     ScenarioTree(scenariotreeinstance=model)
Exemple #13
0
 def test_two_stage(self):
     G = networkx.DiGraph()
     G.add_node("Root")
     G.add_node("Child1")
     G.add_edge("Root", "Child1", weight=0.8)
     G.add_node("Child2")
     G.add_edge("Root", "Child2", weight=0.2)
     model = ScenarioTreeModelFromNetworkX(G)
     self.assertEqual(sorted(list(model.Stages)),
                      sorted(["Stage1", "Stage2"]))
     self.assertEqual(sorted(list(model.Nodes)),
                      sorted(["Root", "Child1", "Child2"]))
     self.assertEqual(sorted(list(model.Children["Root"])),
                      sorted(["Child1", "Child2"]))
     self.assertEqual(sorted(list(model.Children["Child1"])), sorted([]))
     self.assertEqual(sorted(list(model.Children["Child2"])), sorted([]))
     self.assertEqual(sorted(list(model.Scenarios)),
                      sorted(["Child1", "Child2"]))
     self.assertEqual(model.ConditionalProbability["Root"], 1.0)
     self.assertEqual(model.ConditionalProbability["Child1"], 0.8)
     self.assertEqual(model.ConditionalProbability["Child2"], 0.2)
     model.StageCost["Stage1"] = "c1"
     model.StageCost["Stage2"] = "c2"
     model.StageVariables["Stage1"].add("x")
     self.assertEqual(model.Bundling.value, False)
     self.assertEqual(list(model.Bundles), [])
     self.assertEqual(len(model.BundleScenarios), 0)
     ScenarioTree(scenariotreeinstance=model)
Exemple #14
0
 def test_two_stage(self):
     G = networkx.DiGraph()
     G.add_node("Root")
     G.add_node("Child1")
     G.add_edge("Root", "Child1", probability=0.8)
     G.add_node("Child2")
     G.add_edge("Root", "Child2", probability=0.2)
     model = ScenarioTreeModelFromNetworkX(G)
     self.assertEqual(sorted(list(model.Stages)),
                      sorted(['Stage1', 'Stage2']))
     self.assertEqual(sorted(list(model.Nodes)),
                      sorted(['Root', 'Child1', 'Child2']))
     self.assertEqual(sorted(list(model.Children['Root'])),
                      sorted(['Child1', 'Child2']))
     self.assertEqual(sorted(list(model.Children['Child1'])), sorted([]))
     self.assertEqual(sorted(list(model.Children['Child2'])), sorted([]))
     self.assertEqual(sorted(list(model.Scenarios)),
                      sorted(['Scenario_uChild1', 'Scenario_uChild2']))
     self.assertEqual(model.ConditionalProbability['Root'], 1.0)
     self.assertEqual(model.ConditionalProbability['Child1'], 0.8)
     self.assertEqual(model.ConditionalProbability['Child2'], 0.2)
     model.StageCost['Stage1'] = 'c1'
     model.StageCost['Stage2'] = 'c2'
     model.StageVariables['Stage1'].add('x')
     ScenarioTree(scenariotreeinstance=model)
Exemple #15
0
    def test_two_stage_more_node_attributes(self):
        G = networkx.DiGraph()
        G.add_node("Root", cost="c1", variables=["x"], derived_variables=["y"])
        G.add_node("Child1",
                   cost="c2",
                   variables=["q"],
                   derived_variables=["z"])
        G.add_edge("Root", "Child1", weight=0.8)
        G.add_node("Child2",
                   cost="c2",
                   variables=["q"],
                   derived_variables=["z"])
        G.add_edge("Root", "Child2", weight=0.2)
        model = ScenarioTreeModelFromNetworkX(G)
        self.assertEqual(sorted(list(model.Stages)),
                         sorted(["Stage1", "Stage2"]))
        self.assertEqual(sorted(list(model.Nodes)),
                         sorted(["Root", "Child1", "Child2"]))
        self.assertEqual(sorted(list(model.Children["Root"])),
                         sorted(["Child1", "Child2"]))
        self.assertEqual(sorted(list(model.Children["Child1"])), sorted([]))
        self.assertEqual(sorted(list(model.Children["Child2"])), sorted([]))
        self.assertEqual(sorted(list(model.Scenarios)),
                         sorted(["Child1", "Child2"]))
        self.assertEqual(model.ConditionalProbability["Root"], 1.0)
        self.assertEqual(model.ConditionalProbability["Child1"], 0.8)
        self.assertEqual(model.ConditionalProbability["Child2"], 0.2)

        # FIXME: #300 on GitHub
        self.assertEqual(model.StageCost["Stage1"]._value, None)
        self.assertEqual(list(model.StageVariables["Stage1"]), [])
        self.assertEqual(list(model.StageDerivedVariables["Stage1"]), [])

        self.assertEqual(model.NodeCost["Root"].value, "c1")
        self.assertEqual(list(model.NodeVariables["Root"]), ["x"])
        self.assertEqual(list(model.NodeDerivedVariables["Root"]), ["y"])

        # FIXME: #300 on GitHub
        self.assertEqual(model.StageCost["Stage2"]._value, None)
        self.assertEqual(list(model.StageVariables["Stage2"]), [])
        self.assertEqual(list(model.StageDerivedVariables["Stage2"]), [])

        self.assertEqual(model.NodeCost["Child1"].value, "c2")
        self.assertEqual(list(model.NodeVariables["Child1"]), ["q"])
        self.assertEqual(list(model.NodeDerivedVariables["Child1"]), ["z"])

        self.assertEqual(model.NodeCost["Child2"].value, "c2")
        self.assertEqual(list(model.NodeVariables["Child2"]), ["q"])
        self.assertEqual(list(model.NodeDerivedVariables["Child2"]), ["z"])
        self.assertEqual(model.Bundling.value, False)
        self.assertEqual(list(model.Bundles), [])
        self.assertEqual(len(model.BundleScenarios), 0)
        ScenarioTree(scenariotreeinstance=model)
Exemple #16
0
 def test_unbalanced(self):
     G = networkx.DiGraph()
     G.add_node("R")
     G.add_node("0")
     G.add_node("1")
     G.add_edge("R", "0")
     G.add_edge("R", "1")
     G.add_node("00")
     G.add_node("01")
     G.add_edge("0", "00")
     G.add_edge("0", "01")
     model = ScenarioTreeModelFromNetworkX(
         G,
         edge_probability_attribute=None)
     self.assertEqual(
         sorted(list(model.Stages)),
         sorted(["Stage1", "Stage2", "Stage3"]))
     self.assertEqual(
         sorted(list(model.Nodes)),
         sorted(["R","0","1","00","01"]))
     self.assertEqual(
         sorted(list(model.Children["R"])),
         sorted(["0", "1"]))
     self.assertEqual(
         sorted(list(model.Children["0"])),
         sorted(["00","01"]))
     self.assertEqual(
         sorted(list(model.Children["1"])),
         sorted([]))
     self.assertEqual(
         sorted(list(model.Children["00"])),
         sorted([]))
     self.assertEqual(
         sorted(list(model.Children["01"])),
         sorted([]))
     self.assertEqual(
         sorted(list(model.Scenarios)),
         sorted(["00", "01", "1"]))
     self.assertEqual(model.ConditionalProbability["R"], 1.0)
     self.assertEqual(model.ConditionalProbability["0"], 0.5)
     self.assertEqual(model.ConditionalProbability["1"], 0.5)
     self.assertEqual(model.ConditionalProbability["00"], 0.5)
     self.assertEqual(model.ConditionalProbability["01"], 0.5)
     model.StageCost["Stage1"] = "c1"
     model.StageCost["Stage2"] = "c2"
     model.StageCost["Stage3"] = "c3"
     model.StageVariables["Stage1"].add("x")
     model.StageVariables["Stage2"].add("x")
     self.assertEqual(model.Bundling.value, False)
     self.assertEqual(list(model.Bundles), [])
     self.assertEqual(len(model.BundleScenarios), 0)
     ScenarioTree(scenariotreeinstance=model)
    def test_indexedblock_wildcardtemplate(self):
        st_model = CreateConcreteTwoStageScenarioTreeModel(1)
        st_model.StageVariables['Stage1'].add("B1[*]")
        st_model.StageDerivedVariables['Stage1'].add("B2[*]")
        st_model.NodeVariables['RootNode'].add("B3[*]")
        st_model.NodeDerivedVariables['RootNode'].add("B4[*]")
        st_model.StageCost['Stage1'] = "FirstStageCost"
        st_model.StageCost['Stage2'] = "SecondStageCost"

        scenario_tree = ScenarioTree(scenariotreeinstance=st_model)
        self.assertEqual(len(scenario_tree.stages), 2)
        self.assertEqual(len(scenario_tree.nodes), 2)
        self.assertEqual(len(scenario_tree.scenarios), 1)

        model = self._get_block_model()

        scenario_tree.linkInInstances({'Scenario1': model})

        root = scenario_tree.findRootNode()
        self.assertEqual(len(root._variable_ids), 24)
        self.assertEqual(len(root._standard_variable_ids), 12)
        self.assertEqual(len(root._derived_variable_ids), 12)
        for name in ("B1[1].x", "B1[2].x",
                     "B2[1].x", "B2[2].x",
                     "B3[1].x", "B3[2].x",
                     "B4[1].x", "B4[2].x"):
            for index in [None]:
                self.assertEqual(
                    (name,index) in root._name_index_to_id, True)
        for name in ("B1[1].X", "B1[2].X",
                     "B2[1].X", "B2[2].X",
                     "B3[1].X", "B3[2].X",
                     "B4[1].X", "B4[2].X"):
            for index in model.s:
                self.assertEqual(
                    (name,index) in root._name_index_to_id, True)
Exemple #18
0
 def test_multi_stage(self):
     G = networkx.balanced_tree(3, 2, networkx.DiGraph())
     model = ScenarioTreeModelFromNetworkX(G,
                                           edge_probability_attribute=None)
     self.assertEqual(sorted(list(model.Stages)),
                      sorted(['Stage1', 'Stage2', 'Stage3']))
     self.assertEqual(sorted(list(model.Nodes)),
                      sorted([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]))
     self.assertEqual(sorted(list(model.Children[0])), sorted([1, 2, 3]))
     self.assertEqual(sorted(list(model.Children[1])), sorted([4, 5, 6]))
     self.assertEqual(sorted(list(model.Children[2])), sorted([7, 8, 9]))
     self.assertEqual(sorted(list(model.Children[3])), sorted([10, 11, 12]))
     self.assertEqual(sorted(list(model.Children[4])), sorted([]))
     self.assertEqual(sorted(list(model.Children[5])), sorted([]))
     self.assertEqual(sorted(list(model.Children[6])), sorted([]))
     self.assertEqual(sorted(list(model.Children[7])), sorted([]))
     self.assertEqual(sorted(list(model.Children[8])), sorted([]))
     self.assertEqual(sorted(list(model.Children[9])), sorted([]))
     self.assertEqual(sorted(list(model.Children[10])), sorted([]))
     self.assertEqual(sorted(list(model.Children[11])), sorted([]))
     self.assertEqual(sorted(list(model.Children[12])), sorted([]))
     self.assertEqual(
         sorted(list(model.Scenarios)),
         sorted([
             'Scenario_u4', 'Scenario_u5', 'Scenario_u6', 'Scenario_u7',
             'Scenario_u8', 'Scenario_u9', 'Scenario_u10', 'Scenario_u11',
             'Scenario_u12'
         ]))
     self.assertEqual(model.ConditionalProbability[0], 1.0)
     self.assertAlmostEqual(model.ConditionalProbability[1], 1.0 / 3)
     self.assertAlmostEqual(model.ConditionalProbability[2], 1.0 / 3)
     self.assertAlmostEqual(model.ConditionalProbability[3], 1.0 / 3)
     self.assertAlmostEqual(model.ConditionalProbability[4], 1.0 / 3)
     self.assertAlmostEqual(model.ConditionalProbability[5], 1.0 / 3)
     self.assertAlmostEqual(model.ConditionalProbability[6], 1.0 / 3)
     self.assertAlmostEqual(model.ConditionalProbability[7], 1.0 / 3)
     self.assertAlmostEqual(model.ConditionalProbability[8], 1.0 / 3)
     self.assertAlmostEqual(model.ConditionalProbability[9], 1.0 / 3)
     self.assertAlmostEqual(model.ConditionalProbability[10], 1.0 / 3)
     self.assertAlmostEqual(model.ConditionalProbability[11], 1.0 / 3)
     self.assertAlmostEqual(model.ConditionalProbability[12], 1.0 / 3)
     model.StageCost['Stage1'] = 'c1'
     model.StageCost['Stage2'] = 'c2'
     model.StageCost['Stage3'] = 'c3'
     model.StageVariables['Stage1'].add('x')
     model.StageVariables['Stage2'].add('y')
     model.StageVariables['Stage3'].add('y')
     ScenarioTree(scenariotreeinstance=model)
Exemple #19
0
 def test_multi_stage(self):
     G = networkx.balanced_tree(3, 2, networkx.DiGraph())
     model = ScenarioTreeModelFromNetworkX(G,
                                           edge_probability_attribute=None)
     self.assertEqual(sorted(list(model.Stages)),
                      sorted(["Stage1", "Stage2", "Stage3"]))
     self.assertEqual(sorted(list(model.Nodes)),
                      sorted([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]))
     self.assertEqual(sorted(list(model.Children[0])), sorted([1, 2, 3]))
     self.assertEqual(sorted(list(model.Children[1])), sorted([4, 5, 6]))
     self.assertEqual(sorted(list(model.Children[2])), sorted([7, 8, 9]))
     self.assertEqual(sorted(list(model.Children[3])), sorted([10, 11, 12]))
     self.assertEqual(sorted(list(model.Children[4])), sorted([]))
     self.assertEqual(sorted(list(model.Children[5])), sorted([]))
     self.assertEqual(sorted(list(model.Children[6])), sorted([]))
     self.assertEqual(sorted(list(model.Children[7])), sorted([]))
     self.assertEqual(sorted(list(model.Children[8])), sorted([]))
     self.assertEqual(sorted(list(model.Children[9])), sorted([]))
     self.assertEqual(sorted(list(model.Children[10])), sorted([]))
     self.assertEqual(sorted(list(model.Children[11])), sorted([]))
     self.assertEqual(sorted(list(model.Children[12])), sorted([]))
     self.assertEqual(sorted(list(model.Scenarios)),
                      sorted([4, 5, 6, 7, 8, 9, 10, 11, 12]))
     self.assertEqual(model.ConditionalProbability[0], 1.0)
     self.assertAlmostEqual(model.ConditionalProbability[1], 1.0 / 3)
     self.assertAlmostEqual(model.ConditionalProbability[2], 1.0 / 3)
     self.assertAlmostEqual(model.ConditionalProbability[3], 1.0 / 3)
     self.assertAlmostEqual(model.ConditionalProbability[4], 1.0 / 3)
     self.assertAlmostEqual(model.ConditionalProbability[5], 1.0 / 3)
     self.assertAlmostEqual(model.ConditionalProbability[6], 1.0 / 3)
     self.assertAlmostEqual(model.ConditionalProbability[7], 1.0 / 3)
     self.assertAlmostEqual(model.ConditionalProbability[8], 1.0 / 3)
     self.assertAlmostEqual(model.ConditionalProbability[9], 1.0 / 3)
     self.assertAlmostEqual(model.ConditionalProbability[10], 1.0 / 3)
     self.assertAlmostEqual(model.ConditionalProbability[11], 1.0 / 3)
     self.assertAlmostEqual(model.ConditionalProbability[12], 1.0 / 3)
     model.StageCost["Stage1"] = "c1"
     model.StageCost["Stage2"] = "c2"
     model.StageCost["Stage3"] = "c3"
     model.StageVariables["Stage1"].add("x")
     model.StageVariables["Stage2"].add("y")
     model.StageVariables["Stage3"].add("y")
     self.assertEqual(model.Bundling.value, False)
     self.assertEqual(list(model.Bundles), [])
     self.assertEqual(len(model.BundleScenarios), 0)
     ScenarioTree(scenariotreeinstance=model)
Exemple #20
0
 def test_unbalanced(self):
     G = networkx.DiGraph()
     G.add_node('R')
     G.add_node('0')
     G.add_node('1')
     G.add_edge('R', '0')
     G.add_edge('R', '1')
     G.add_node('00')
     G.add_node('01')
     G.add_edge('0', '00')
     G.add_edge('0', '01')
     model = ScenarioTreeModelFromNetworkX(G,
                                           edge_probability_attribute=None)
     self.assertEqual(sorted(list(model.Stages)),
                      sorted(['Stage1', 'Stage2', 'Stage3']))
     self.assertEqual(sorted(list(model.Nodes)),
                      sorted(['R', '0', '1', '00', '01']))
     self.assertEqual(sorted(list(model.Children['R'])), sorted(['0', '1']))
     self.assertEqual(sorted(list(model.Children['0'])),
                      sorted(['00', '01']))
     self.assertEqual(sorted(list(model.Children['1'])), sorted([]))
     self.assertEqual(sorted(list(model.Children['00'])), sorted([]))
     self.assertEqual(sorted(list(model.Children['01'])), sorted([]))
     self.assertEqual(
         sorted(list(model.Scenarios)),
         sorted(['Scenario_u00', 'Scenario_u01', 'Scenario_u1']))
     self.assertEqual(model.ConditionalProbability['R'], 1.0)
     self.assertEqual(model.ConditionalProbability['0'], 0.5)
     self.assertEqual(model.ConditionalProbability['1'], 0.5)
     self.assertEqual(model.ConditionalProbability['00'], 0.5)
     self.assertEqual(model.ConditionalProbability['01'], 0.5)
     model.StageCost['Stage1'] = 'c1'
     model.StageCost['Stage2'] = 'c2'
     model.StageCost['Stage3'] = 'c3'
     model.StageVariables['Stage1'].add('x')
     model.StageVariables['Stage2'].add('x')
     ScenarioTree(scenariotreeinstance=model)
Exemple #21
0
    def generate_scenario_tree(self,
                               downsample_fraction=1.0,
                               include_scenarios=None,
                               bundles=None,
                               random_bundles=None,
                               random_seed=None,
                               verbose=True):

        scenario_tree_model = self._scenario_tree_model
        if scenario_tree_model is not None:
            if has_networkx and \
               isinstance(scenario_tree_model, networkx.DiGraph):
                scenario_tree_model = \
                    ScenarioTreeModelFromNetworkX(scenario_tree_model)
            else:
                assert isinstance(scenario_tree_model, (_BlockData, Block)), \
                    str(scenario_tree_model)+" "+str(type(scenario_tree_model))

        if bundles is not None:
            if isinstance(bundles, six.string_types):
                if scenario_tree_model is None:
                    raise ValueError("A bundles file can not be used when the "
                                     "scenario tree input was not a Pyomo "
                                     "model or ScenarioStructure.dat file.")
                logger.debug("attempting to locate bundle file for input: %s" %
                             (bundles))
                # we interpret the scenario bundle specification in one of
                # two ways. if the supplied name is a file, it is used
                # directly. otherwise, it is interpreted as the root of a
                # file with a .dat suffix to be found in the instance
                # directory.
                orig_input = bundles
                if not bundles.endswith(".dat"):
                    bundles = bundles + ".dat"
                bundles = os.path.expanduser(bundles)
                if not os.path.exists(bundles):
                    if self.data_directory() is None:
                        raise ValueError(
                            "Could not locate bundle .dat file from input "
                            "'%s'. Path does not exist and there is no data "
                            "directory to search in." % (orig_input))
                    bundles = os.path.join(self.data_directory(), bundles)
                if not os.path.exists(bundles):
                    raise ValueError("Could not locate bundle .dat file "
                                     "from input '%s' as absolute path or "
                                     "relative to data directory: %s" %
                                     (orig_input, self.data_directory()))

                if verbose:
                    print("Scenario tree bundle specification filename=%s" %
                          (bundles))

                scenario_tree_model = scenario_tree_model.clone()
                scenario_tree_model.Bundling = True
                scenario_tree_model.Bundling._constructed = False
                scenario_tree_model.Bundling._data.clear()
                scenario_tree_model.Bundles.clear()
                scenario_tree_model.Bundles._constructed = False
                scenario_tree_model.Bundles._data.clear()
                scenario_tree_model.BundleScenarios.clear()
                scenario_tree_model.BundleScenarios._constructed = False
                scenario_tree_model.BundleScenarios._data.clear()
                scenario_tree_model.load(bundles)

        #
        # construct the scenario tree
        #
        if scenario_tree_model is not None:
            scenario_tree = ScenarioTree(
                scenariotreeinstance=scenario_tree_model,
                scenariobundlelist=include_scenarios)
        else:
            assert self._scenario_tree is not None
            if include_scenarios is None:
                scenario_tree = copy.deepcopy(self._scenario_tree)
            else:
                # note: any bundles will be lost
                if self._scenario_tree.contains_bundles():
                    raise ValueError("Can not compress a scenario tree that "
                                     "contains bundles")
                scenario_tree = self._scenario_tree.make_compressed(
                    include_scenarios, normalize=True)

        # compress/down-sample the scenario tree, if requested
        if (downsample_fraction is not None) and \
           (downsample_fraction < 1.0):
            scenario_tree.downsample(downsample_fraction, random_seed, verbose)

        #
        # create bundles from a dict, if requested
        #
        if bundles is not None:
            if not isinstance(bundles, six.string_types):
                if verbose:
                    print("Adding bundles to scenario tree from "
                          "user-specified dict")
                if scenario_tree.contains_bundles():
                    if verbose:
                        print("Scenario tree already contains bundles. "
                              "All existing bundles will be removed.")
                    for bundle in list(scenario_tree.bundles):
                        scenario_tree.remove_bundle(bundle.name)
                for bundle_name in bundles:
                    scenario_tree.add_bundle(bundle_name, bundles[bundle_name])

        #
        # create random bundles, if requested
        #
        if (random_bundles is not None) and \
           (random_bundles > 0):
            if bundles is not None:
                raise ValueError("Cannot specify both random "
                                 "bundles and a bundles specification")

            num_scenarios = len(scenario_tree._scenarios)
            if random_bundles > num_scenarios:
                raise ValueError("Cannot create more random bundles "
                                 "than there are scenarios!")

            if verbose:
                print("Creating " + str(random_bundles) +
                      " random bundles using seed=" + str(random_seed))

            scenario_tree.create_random_bundles(random_bundles, random_seed)

        scenario_tree._scenario_instance_factory = self

        return scenario_tree
Exemple #22
0
    def generate_scenario_tree(self,
                               downsample_fraction=1.0,
                               include_scenarios=None,
                               bundles=None,
                               random_bundles=None,
                               random_seed=None):

        scenario_tree_instance = self._scenario_tree_instance
        if bundles is not None:
            if isinstance(bundles, string_types):
                bundles_file_path = None
                # we interpret the scenario bundle specification in one of
                # two ways. if the supplied name is a file, it is used
                # directly. otherwise, it is interpreted as the root of a
                # file with a .dat suffix to be found in the instance
                # directory.
                if os.path.exists(os.path.expanduser(bundles)):
                    bundles_file_path = \
                        os.path.expanduser(bundles)
                else:
                    bundles_file_path = \
                        os.path.join(self._scenario_tree_directory,
                                     bundles+".dat")

                if self._verbose:
                    if bundles_file_path is not None:
                        print("Scenario tree bundle specification filename="
                              +bundles_file_path)

                scenario_tree_instance = scenario_tree_instance.clone()
                scenario_tree_instance.Bundling._constructed = False
                scenario_tree_instance.Bundles._constructed = False
                scenario_tree_instance.BundleScenarios._constructed = False
                scenario_tree_instance.load(bundles_file_path)

        #
        # construct the scenario tree
        #
        scenario_tree = ScenarioTree(scenariotreeinstance=scenario_tree_instance,
                                     scenariobundlelist=include_scenarios)

        # compress/down-sample the scenario tree, if requested
        if (downsample_fraction is not None) and \
           (downsample_fraction < 1.0):
            scenario_tree.downsample(downsample_fraction,
                                     random_seed,
                                     self._verbose)

        #
        # create bundles from a dict, if requested
        #
        if bundles is not None:
            if not isinstance(bundles, string_types):
                if self._verbose:
                    print("Adding bundles to scenario tree from user-specified dict")
                if scenario_tree.contains_bundles():
                    if self._verbose:
                        print("Scenario tree already contains bundles. All existing "
                              "bundles will be removed.")
                    for bundle in list(scenario_tree.bundles):
                        scenario_tree.remove(bundle.name)
                for bundle_name in bundles:
                    scenario_tree.add_bundle(bundle_name, bundles[bundle_name])

        #
        # create random bundles, if requested
        #
        if (random_bundles is not None) and \
           (random_bundles > 0):
            if bundles is not None:
                raise ValueError("Cannot specify both random "
                                 "bundles and a bundles specification")

            num_scenarios = len(scenario_tree._scenarios)
            if random_bundles > num_scenarios:
                raise ValueError("Cannot create more random bundles "
                                 "than there are scenarios!")

            print("Creating "+str(random_bundles)+
                  " random bundles using seed="
                  +str(random_seed))

            scenario_tree.create_random_bundles(self._scenario_tree_instance,
                                                random_bundles,
                                                random_seed)

        scenario_tree._scenario_instance_factory = self

        return scenario_tree
Exemple #23
0
    def generate_scenario_tree(self,
                               downsample_fraction=1.0,
                               include_scenarios=None,
                               bundles=None,
                               random_bundles=None,
                               random_seed=None,
                               verbose=True):

        scenario_tree_model = self._scenario_tree_model
        if scenario_tree_model is not None:
            if has_networkx and \
               isinstance(scenario_tree_model, networkx.DiGraph):
                scenario_tree_model = \
                    ScenarioTreeModelFromNetworkX(scenario_tree_model)
            else:
                assert isinstance(scenario_tree_model, (_BlockData, Block)), \
                    str(scenario_tree_model)+" "+str(type(scenario_tree_model))

        if bundles is not None:
            if isinstance(bundles, six.string_types):
                if scenario_tree_model is None:
                    raise ValueError(
                        "A bundles file can not be used when the "
                        "scenario tree input was not a Pyomo "
                        "model or ScenarioStructure.dat file.")
                logger.debug("attempting to locate bundle file for input: %s"
                             % (bundles))
                # we interpret the scenario bundle specification in one of
                # two ways. if the supplied name is a file, it is used
                # directly. otherwise, it is interpreted as the root of a
                # file with a .dat suffix to be found in the instance
                # directory.
                orig_input = bundles
                if not bundles.endswith(".dat"):
                    bundles = bundles+".dat"
                bundles = os.path.expanduser(bundles)
                if not os.path.exists(bundles):
                    if self.data_directory() is None:
                        raise ValueError(
                            "Could not locate bundle .dat file from input "
                            "'%s'. Path does not exist and there is no data "
                            "directory to search in." % (orig_input))
                    bundles = os.path.join(self.data_directory(), bundles)
                if not os.path.exists(bundles):
                    raise ValueError("Could not locate bundle .dat file "
                                     "from input '%s' as absolute path or "
                                     "relative to data directory: %s"
                                     % (orig_input, self.data_directory()))

                if verbose:
                    print("Scenario tree bundle specification filename=%s"
                          % (bundles))

                scenario_tree_model = scenario_tree_model.clone()
                scenario_tree_model.Bundling = True
                scenario_tree_model.Bundling._constructed = False
                scenario_tree_model.Bundles.clear()
                scenario_tree_model.Bundles._constructed = False
                scenario_tree_model.BundleScenarios.clear()
                scenario_tree_model.BundleScenarios._constructed = False
                scenario_tree_model.load(bundles)

        #
        # construct the scenario tree
        #
        if scenario_tree_model is not None:
            scenario_tree = ScenarioTree(scenariotreeinstance=scenario_tree_model,
                                         scenariobundlelist=include_scenarios)
        else:
            assert self._scenario_tree is not None
            if include_scenarios is None:
                scenario_tree = copy.deepcopy(self._scenario_tree)
            else:
                # note: any bundles will be lost
                if self._scenario_tree.contains_bundles():
                    raise ValueError(
                        "Can not compress a scenario tree that "
                        "contains bundles")
                scenario_tree = self._scenario_tree.make_compressed(
                    include_scenarios,
                    normalize=True)

        # compress/down-sample the scenario tree, if requested
        if (downsample_fraction is not None) and \
           (downsample_fraction < 1.0):
            scenario_tree.downsample(downsample_fraction,
                                     random_seed,
                                     verbose)

        #
        # create bundles from a dict, if requested
        #
        if bundles is not None:
            if not isinstance(bundles, six.string_types):
                if verbose:
                    print("Adding bundles to scenario tree from "
                          "user-specified dict")
                if scenario_tree.contains_bundles():
                    if verbose:
                        print("Scenario tree already contains bundles. "
                              "All existing bundles will be removed.")
                    for bundle in list(scenario_tree.bundles):
                        scenario_tree.remove_bundle(bundle.name)
                for bundle_name in bundles:
                    scenario_tree.add_bundle(bundle_name,
                                             bundles[bundle_name])

        #
        # create random bundles, if requested
        #
        if (random_bundles is not None) and \
           (random_bundles > 0):
            if bundles is not None:
                raise ValueError("Cannot specify both random "
                                 "bundles and a bundles specification")

            num_scenarios = len(scenario_tree._scenarios)
            if random_bundles > num_scenarios:
                raise ValueError("Cannot create more random bundles "
                                 "than there are scenarios!")

            if verbose:
                print("Creating "+str(random_bundles)+
                      " random bundles using seed="
                      +str(random_seed))

            scenario_tree.create_random_bundles(random_bundles,
                                                random_seed)

        scenario_tree._scenario_instance_factory = self

        return scenario_tree