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)
def pysp_scenario_tree_model_callback():
from pyomo.pysp.scenariotree.tree_structure_model import ScenarioTreeModelFromNetworkX
## build a decision tree object
Tree_Graph = DT(dec_GLOBAL,MD_GLOBAL)
builtins.Tree_Graph_GLOBAL = Tree_Graph
### Initialize scenario tree model
try:
stm = ScenarioTreeModelFromNetworkX(Tree_Graph.G,edge_probability_attribute='probability', stage_names = Tree_Graph.stage_names)
except:
pdb.set_trace()
### Define Variables for each Node
for N in Tree_Graph.G.node:
if N.startswith('s') or N.startswith('pn'):
stm.NodeVariables[N].add(str(N)+'VarXX')
stm.NodeDerivedVariables[N].add(str(N)+'VarY')
stm.NodeDerivedVariables[N].add(str(N)+'VarZ')
else:
###NAC Constrained Decision Variables
stm.NodeVariables[N].add(str(N)+'VarX')
stm.NodeVariables[N].add(str(N)+'VarXX')
stm.NodeDerivedVariables[N].add(str(N)+'VarY')
stm.NodeDerivedVariables[N].add(str(N)+'VarZ')
for stage_name in Tree_Graph.stage_names:
stm.StageCost[stage_name] = str(stage_name) + "StageCost"
return stm
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)
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)
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)
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)
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(["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")
ScenarioTree(scenariotreeinstance=model)
def pysp_scenario_tree_model_callback():
from pyomo.pysp.scenariotree.tree_structure_model import \
ScenarioTreeModelFromNetworkX
#
# Define a tree with three stages using
# a networkx directed graph
#
G = networkx.DiGraph()
G.add_node("R")
G.add_node("u0")
G.add_edge("R", "u0", probability=0.1)
G.add_node("u1")
G.add_edge("R", "u1", probability=0.5)
G.add_node("u2")
G.add_edge("R", "u2", probability=0.4)
G.add_node("u00")
G.add_edge("u0", "u00", probability=0.1)
G.add_node("u01")
G.add_edge("u0", "u01", probability=0.9)
G.add_node("u10")
G.add_edge("u1", "u10", probability=0.5)
G.add_node("u11")
G.add_edge("u1", "u11", probability=0.5)
G.add_node("u20")
G.add_edge("u2", "u20", probability=1.0)
stm = ScenarioTreeModelFromNetworkX(
G,
edge_probability_attribute="probability",
stage_names=["T1", "T2", "T3"])
# Declare the variables for each node (or stage)
stm.StageVariables["T1"].add("x")
stm.StageDerivedVariables["T1"].add("z")
# for this example, variables in the second and
# third time-stage change for each node
stm.NodeVariables["u0"].add("y0")
stm.NodeDerivedVariables["u0"].add("xu0")
stm.NodeVariables["u1"].add("y1")
stm.NodeDerivedVariables["u1"].add("xu1")
stm.NodeVariables["u2"].add("y2")
stm.NodeDerivedVariables["u2"].add("xu2")
stm.NodeVariables["u00"].add("yu00")
stm.NodeVariables["u01"].add("yu01")
stm.NodeVariables["u10"].add("yu10")
stm.NodeVariables["u11"].add("yu11")
stm.NodeVariables["u20"].add("yu20")
# Declare the Var or Expression object that
# reports the cost at each time stage
stm.StageCost["T1"] = "FirstStageCost"
stm.StageCost["T2"] = "SecondStageCost"
stm.StageCost["T3"] = "ThirdStageCost"
return stm
def pysp_scenario_tree_model_callback():
from pyomo.pysp.scenariotree.tree_structure_model import \
ScenarioTreeModelFromNetworkX
#
# Define a tree with three stages using
# a networkx directed graph
#
G = networkx.DiGraph()
G.add_node("R")
G.add_node("u0")
G.add_edge("R", "u0", probability=0.1)
G.add_node("u1")
G.add_edge("R", "u1", probability=0.5)
G.add_node("u2")
G.add_edge("R", "u2", probability=0.4)
G.add_node("u00")
G.add_edge("u0", "u00", probability=0.1)
G.add_node("u01")
G.add_edge("u0", "u01", probability=0.9)
G.add_node("u10")
G.add_edge("u1", "u10", probability=0.5)
G.add_node("u11")
G.add_edge("u1", "u11", probability=0.5)
G.add_node("u20")
G.add_edge("u2", "u20", probability=1.0)
stm = ScenarioTreeModelFromNetworkX(
G,
edge_probability_attribute="probability",
stage_names=["T1", "T2", "T3"])
# Declare the variables for each node (or stage)
stm.StageVariables["T1"].add("x")
stm.StageDerivedVariables["T1"].add("z")
# for this example, variables in the second and
# third time-stage change for each node
stm.NodeVariables["u0"].add("y0")
stm.NodeDerivedVariables["u0"].add("xu0")
stm.NodeVariables["u1"].add("y1")
stm.NodeDerivedVariables["u1"].add("xu1")
stm.NodeVariables["u2"].add("y2")
stm.NodeDerivedVariables["u2"].add("xu2")
stm.NodeVariables["u00"].add("yu00")
stm.NodeVariables["u01"].add("yu01")
stm.NodeVariables["u10"].add("yu10")
stm.NodeVariables["u11"].add("yu11")
stm.NodeVariables["u20"].add("yu20")
# Declare the Var or Expression object that
# reports the cost at each time stage
stm.StageCost["T1"] = "FirstStageCost"
stm.StageCost["T2"] = "SecondStageCost"
stm.StageCost["T3"] = "ThirdStageCost"
return stm
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_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_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)
def test_missing_probability(self):
G = networkx.DiGraph()
G.add_node("R", name="Root")
G.add_node("C", name="Child")
G.add_edge("R", "C")
with self.assertRaises(KeyError):
ScenarioTreeModelFromNetworkX(G)
def test_bad_custom_stage_names1(self):
G = networkx.DiGraph()
G.add_node("R", )
G.add_node("C1")
G.add_edge("R", "C1", weight=1.0)
with self.assertRaises(ValueError):
ScenarioTreeModelFromNetworkX(G, stage_names=["Stage1"])
def test_not_directed(self):
G = networkx.Graph()
G.add_node("1")
G.add_node("2")
G.add_edge("1", "2")
with self.assertRaises(TypeError):
ScenarioTreeModelFromNetworkX(G)
def test_bad_probability1(self):
G = networkx.DiGraph()
G.add_node("R", )
G.add_node("C", )
G.add_edge("R", "C", probability=0.8)
with self.assertRaises(ValueError):
ScenarioTreeModelFromNetworkX(G)
def test_bad_custom_stage_names2(self):
G = networkx.DiGraph()
G.add_node("R")
G.add_node("C1")
G.add_edge("R", "C1", probability=1.0)
with self.assertRaises(ValueError):
ScenarioTreeModelFromNetworkX(G, stage_names=['Stage1', 'Stage1'])
def test_missing_name(self):
G = networkx.DiGraph()
G.add_node("R", name="Root")
G.add_node("C")
G.add_edge("R", "C", probability=1)
with self.assertRaises(KeyError):
ScenarioTreeModelFromNetworkX(G, node_name_attribute='name')
def test_missing_scenario_name(self):
G = networkx.DiGraph()
G.add_node("R", name="Root")
G.add_node("C")
G.add_edge("R", "C", weight=1)
with self.assertRaises(KeyError):
ScenarioTreeModelFromNetworkX(G, scenario_name_attribute="name")
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)
def test_bad_weight2(self):
G = networkx.DiGraph()
G.add_node("R")
G.add_node("C1")
G.add_edge("R", "C1", weight=0.8)
G.add_node("C2")
G.add_edge("R", "C2", weight=0.1)
with self.assertRaises(ValueError):
ScenarioTreeModelFromNetworkX(G)
def test_bundles_incomplete(self):
G = networkx.DiGraph()
G.add_node("r")
for i in range(4):
G.add_node("u" + str(i), bundle="B")
G.add_edge("r", "u" + str(i))
model = ScenarioTreeModelFromNetworkX(G,
edge_probability_attribute=None)
self.assertEqual(model.Bundling.value, True)
self.assertEqual(list(model.Bundles), ["B"])
self.assertEqual(list(model.BundleScenarios["B"]),
["u" + str(i) for i in range(4)])
G.nodes["u0"]["bundle"] = None
with self.assertRaises(ValueError):
ScenarioTreeModelFromNetworkX(G, edge_probability_attribute=None)
del G.nodes["u0"]["bundle"]
with self.assertRaises(ValueError):
ScenarioTreeModelFromNetworkX(G, edge_probability_attribute=None)
def test_not_branching(self):
G = networkx.DiGraph()
G.add_node("1")
G.add_node("2")
G.add_node("R")
G.add_edge("1", "R")
G.add_edge("2", "R")
with self.assertRaises(TypeError):
ScenarioTreeModelFromNetworkX(G)
def simple_threestage_scenario_tree():
from pyomo.pysp.scenariotree.tree_structure_model import CreateConcreteTwoStageScenarioTreeModel
import networkx
G = networkx.balanced_tree(2, 2, networkx.DiGraph())
st_model = ScenarioTreeModelFromNetworkX(G, edge_probability_attribute=None)
first_stage = st_model.Stages.first()
second_stage = st_model.Stages.next(first_stage)
third_stage = st_model.Stages.last()
# First Stage
st_model.StageCost[first_stage] = "StageCost[1]"
st_model.StageVariables[first_stage].add("x")
# Second Stage
st_model.StageCost[second_stage] = "StageCost[2]"
st_model.StageVariables[second_stage].add("y")
# Third Stage
st_model.StageCost[thrid_stage] = "StageCost[3]"
st_model.StageVariables[second_stage].add("z")
return st_model
def __init__(self, scenario_creator, tree_model=None,
scenarios_dir=None,
scenario_creator_callback_name=None,
tree_model_callback_name=None):
## first, attempt to determine abstract vs concrete
## and get a scenario instance creator
## if callable, a instance creator
if callable(scenario_creator):
self.pysp_instance_creator = scenario_creator
self.abstract = False
else: ## else, either and abstract model or a module with a callback
if scenario_creator_callback_name is None:
scenario_creator_callback_name = 'pysp_instance_creation_callback'
module = import_file(scenario_creator)
if hasattr(module, scenario_creator_callback_name):
self.pysp_instance_creator = \
getattr(module, scenario_creator_callback_name)
self.abstract = False
else:
self.pysp_instance_creator = module.model.create_instance
self.abstract = True
## attempt to find and construct a tree model
if tree_model is None:
if tree_model_callback_name is None:
tree_model_callback_name = 'pysp_scenario_tree_model_callback'
tree_maker = getattr(module, tree_model_callback_name)
tree_model = tree_maker()
## if we get a *.dat file, assume the scenarios are here unless
## otherwise specified
if isinstance(tree_model, str):
self.tree_model = CreateAbstractScenarioTreeModel(\
).create_instance(tree_model)
self.scenarios_dir = os.path.dirname(tree_model)
elif hasnetworkx and isinstance(tree_model, networkx.DiGraph):
self.tree_model = ScenarioTreeModelFromNetworkX(tree_model)
elif isinstance(tree_model, pyo.ConcreteModel):
self.tree_model = tree_model
else:
raise RuntimeError("Type of tree_model {} unrecongized".format(
type(tree_model)))
## set the scenarios_dir if specified, but complain if
## we don't have an abstract model
if scenarios_dir is not None:
if not self.abstract:
raise RuntimeError("An abstract model is required for "
"scenarios_dir")
self.scenarios_dir = scenarios_dir
self._init()
def simple_threestage_scenario_tree():
from pyomo.pysp.scenariotree.tree_structure_model \
import CreateConcreteTwoStageScenarioTreeModel
import networkx
G = networkx.balanced_tree(2, 2, networkx.DiGraph())
st_model = ScenarioTreeModelFromNetworkX(G,
edge_probability_attribute=None)
first_stage = st_model.Stages.first()
second_stage = st_model.Stages.next(first_stage)
third_stage = st_model.Stages.last()
# First Stage
st_model.StageCost[first_stage] = 'StageCost[1]'
st_model.StageVariables[first_stage].add('x')
# Second Stage
st_model.StageCost[second_stage] = 'StageCost[2]'
st_model.StageVariables[second_stage].add('y')
# Third Stage
st_model.StageCost[thrid_stage] = 'StageCost[3]'
st_model.StageVariables[second_stage].add('z')
return st_model
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)
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)
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)
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)
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
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")
ScenarioTree(scenariotreeinstance=model)
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
def test_not_enough_stages(self):
G = networkx.DiGraph()
G.add_node("R")
with self.assertRaises(ValueError):
ScenarioTreeModelFromNetworkX(G)
def test_empty(self):
G = networkx.DiGraph()
with self.assertRaises(networkx.NetworkXPointlessConcept):
ScenarioTreeModelFromNetworkX(G)
