def test_minimal_startnodes_for_node(self):
spsg = sparse_powerset_graph(self.computers)
targetVars = frozenset({A, B})
fig1 = plt.figure(figsize=(15, 30))
axs = fig1.subplots(2, 1)
draw_ComputerSetMultiDiGraph_matplotlib(
axs[1],
spsg,
targetNode=frozenset({B})
)
draw_ComputerSetMultiDiGraph_matplotlib(
axs[0],
spsg,
targetNode=frozenset({A})
)
fig1.savefig("spsg.pdf")
plt.close(fig1)
res = minimal_startnodes_for_node(spsg, targetVars)
# print('###############################') print('miminal startsets
# for: ', node_2_string(targetVars),nodes_2_string(res))
# print('###############################')
self.assertSetEqual(
res,
frozenset({
frozenset({I, E, F}),
frozenset({I, C, D}),
frozenset({I, H, C, G}),
frozenset({I, H, C, D, G}),
frozenset({I, E, H, F, G})
})
)
def test_arg_set_graph(self):
asg = arg_set_graph(D, self.computers)
# For compatibility arg_set_graph returns a multigraph
# although we do not have more than one edge between a pair
# of nodes.
ref = nx.MultiDiGraph()
ref.add_edge(
frozenset({B}),
frozenset({D}),
computers=frozenset({d_from_b})
)
ref.add_edge(
frozenset({G, H}),
frozenset({D}),
computers=frozenset({d_from_g_h})
)
# picture for manual check
fig = plt.figure(figsize=(20, 20))
ax1 = fig.add_subplot(1, 2, 1)
ax2 = fig.add_subplot(1, 2, 2)
draw_ComputerSetMultiDiGraph_matplotlib(ax1, ref)
draw_ComputerSetMultiDiGraph_matplotlib(ax2, asg)
fig.savefig("arg_set_graph.pdf")
self.assertTrue(equivalent_multigraphs(asg, ref))
def test_computable_mvars(self):
# for debugging we draw the sparse_powerset_graph of the actually present computers and mvars
spsg = sparse_powerset_graph(bgc_md2_computers())
f = plt.figure()
ax = f.add_subplot(1, 1, 1)
draw_ComputerSetMultiDiGraph_matplotlib(ax,
spsg,
bgc_md2_mvar_aliases(),
bgc_md2_computer_aliases(),
targetNode=frozenset(
{SmoothModelRun}))
f.savefig("spgs.pdf")
fig = plt.figure()
draw_update_sequence(bgc_md2_computers(), max_it=8, fig=fig)
fig.savefig("c1.pdf")
# https://docs.python.org/3/library/unittest.html#distinguishing-test-iterations-using-subtests
for mn in [
"Potter1993GlobalBiogeochemicalCycles",
"testVectorFree",
"Williams2005GCB", # just uncomment the one model you are working on and comment the others
]:
with self.subTest(mn=mn):
mvs = MVarSet.from_model_name(mn)
mvars = mvs.computable_mvar_types()
list_str = "\n".join(
["<li> " + str(var.__name__) + " </li>" for var in mvars])
print(list_str)
for var in mvars:
print("########################################")
print(str(var.__name__))
print(mvs._get_single_mvar_value(var))
def test_ComputerSetMultiGraph_matplotlib(self):
# The direct visualization of networkx (using matplotlib)
# is very rudimentary.
fig = plt.figure(figsize=(20, 20))
ax = fig.add_subplot(1, 1, 1)
draw_ComputerSetMultiDiGraph_matplotlib(ax, self.spsg)
fig.savefig("SetMultiGraph.pdf")
def test_ComputerSetMultiGraph_matplotlib_bgc_md2(self):
# The direct visualization of networkx (using matplotlib)
# is very rudimentary.
spsg = sparse_powerset_graph(bgc_md2_computers())
fig = plt.figure(figsize=(20, 20))
ax = fig.add_subplot(1, 1, 1)
draw_ComputerSetMultiDiGraph_matplotlib(
ax,
spsg,
bgc_md2_mvar_aliases(),
bgc_md2_computer_aliases(),
)
fig.savefig("SetMultiGraph.pdf")
def test_arg_set_graph(self):
asg_I = arg_set_graph(I, self.computers)
asg_B = arg_set_graph(B, self.computers)
# For compatibility arg_set_graph returns a multigraph
# although we do not have more than one edge between a pair
# of nodes.
ref_I = nx.MultiDiGraph()
ref_I.add_edge(
frozenset({A, B, K, J}),
frozenset({I}),
computers=frozenset({i_from_a_b_k_j}),
)
ref_B = nx.MultiDiGraph()
ref_B.add_node(frozenset({B}))
# picture for manual check
fig = plt.figure(figsize=(20, 20))
ax1 = fig.add_subplot(2, 2, 1)
ax2 = fig.add_subplot(2, 2, 2)
ax3 = fig.add_subplot(2, 2, 3)
ax4 = fig.add_subplot(2, 2, 4)
draw_ComputerSetMultiDiGraph_matplotlib(ax1, ref_I)
draw_ComputerSetMultiDiGraph_matplotlib(ax2, asg_I)
draw_ComputerSetMultiDiGraph_matplotlib(ax3, ref_B)
draw_ComputerSetMultiDiGraph_matplotlib(ax4, asg_B)
fig.savefig("arg_set_graph.pdf")
self.assertTrue(equivalent_multigraphs(asg_I, ref_I))
self.assertTrue(equivalent_multigraphs(asg_B, ref_B))
def test_ComputerSetMultiGraph_matplotlib(self):
# The direct visualization of networkx (using matplotlib)
# is very rudimentary.
fig = plt.figure(figsize=(20, 20))
ax = fig.add_subplot(1, 1, 1)
draw_ComputerSetMultiDiGraph_matplotlib(ax, self.spsg)
fig.savefig("SetMultiGraph.pdf")
fig = plt.figure(figsize=(20, 20))
ax = fig.add_subplot(1, 1, 1)
print(list(self.spsg.nodes))
draw_ComputerSetMultiDiGraph_matplotlib(ax,
self.spsg,
targetNode=frozenset({C, D}))
fig.savefig("SetMultiGraphWithTargetNode.pdf")
def test_minimal_startnodes_for_single_var(self):
spsg = sparse_powerset_graph(self.computers)
## After the graph has been computed we can use it
## to infer computability of all Mvars
fig1 = plt.figure(figsize=(20, 20))
axs = fig1.subplots(1, 1)
draw_ComputerSetMultiDiGraph_matplotlib(axs, spsg)
fig1.savefig("spsg.pdf")
plt.close(fig1)
fig2 = plt.figure(figsize=(20, 100))
draw_update_sequence(self.computers, max_it=8, fig=fig2)
fig2.savefig("c1.pdf")
plt.close(fig2)
res = minimal_startnodes_for_single_var(spsg, H)
print(nodes_2_string(res))
path = nx.single_source_shortest_path(spsg,
source=frozenset(
{A, B, C, E, G, J, K}))
print("path", nodes_2_string(path))
def test_minimal_startnodes_for_single_var(self):
spsg = sparse_powerset_graph(self.computers)
fig1 = plt.figure(figsize=(15, 15))
axs = fig1.subplots(1, 1)
draw_ComputerSetMultiDiGraph_matplotlib(
axs,
spsg,
targetNode=frozenset({B})
)
fig1.savefig("spsg_B.pdf")
plt.close(fig1)
# After the graph has been computed we can use it
# to infer computability of all Mvars
res_B = minimal_startnodes_for_single_var(spsg, B)
self.assertSetEqual(
res_B,
frozenset({
frozenset({E, F}),
frozenset({C, D}),
frozenset({H, C, G}),
frozenset({H, C, D, G}),
frozenset({E, H, F, G})
})
)
fig1 = plt.figure(figsize=(15, 15))
axs = fig1.subplots(1, 1)
draw_ComputerSetMultiDiGraph_matplotlib(
axs,
spsg,
targetNode=frozenset({A})
)
fig1.savefig("spsg_A.pdf")
plt.close(fig1)
res_A = minimal_startnodes_for_single_var(spsg, A)
self.assertSetEqual(
res_A,
frozenset({
frozenset({I})
})
)
def test_computable_mvars(self):
spsg=sparse_powerset_graph(bgc_md2_computers())
f = plt.figure()
ax = f.add_subplot(1,1,1)
draw_ComputerSetMultiDiGraph_matplotlib(
ax,
spsg,
bgc_md2_mvar_aliases(),
bgc_md2_computer_aliases(),
targetNode=frozenset({SmoothModelRun})
)
f.savefig("spgs.pdf")
fig = plt.figure()
draw_update_sequence(bgc_md2_computers(), max_it=8, fig=fig)
fig.savefig("c1.pdf")
mvs=self.mvs
mvars = mvs.computable_mvar_types()
list_str = "\n".join(["<li> " + str(var.__name__) + " </li>" for var in mvars])
print(list_str)
for var in mvars:
print("########################################")
print(str(var.__name__))
print(mvs._get_single_mvar_value(var))
def test_product_graph(self):
computers = frozenset({a_from_y, a_from_z, b_from_y, b_from_z})
asg_A = arg_set_graph(A, computers)
asg_B = arg_set_graph(B, computers)
pg_A_B = product_graph(asg_A, asg_B)
fig1 = plt.figure(figsize=(20, 100))
ax1 = fig1.add_subplot(411, frame_on=True, title="arg_set_graph(A)")
ax2 = fig1.add_subplot(412, frame_on=True, title="arg_set_graph(B)")
ax3 = fig1.add_subplot(413, frame_on=True, title="product_graph(A,B)")
# ax4=fig1.add_subplot(414,frame_on=True,title="ref")
draw_ComputerSetMultiDiGraph_matplotlib(ax1, asg_A)
draw_ComputerSetMultiDiGraph_matplotlib(ax2, asg_B)
draw_ComputerSetMultiDiGraph_matplotlib(ax3, pg_A_B)
fig1.savefig("AB_Z.pdf")
computers = frozenset({a_from_y, b_from_y, b_from_z})
asg_A = arg_set_graph(A, computers)
asg_B = arg_set_graph(B, computers)
pg_A_B = product_graph(asg_A, asg_B)
fig1 = plt.figure(figsize=(10, 30))
ax1 = fig1.add_subplot(411, frame_on=True, title="arg_set_graph(A)")
ax2 = fig1.add_subplot(412, frame_on=True, title="arg_set_graph(B)")
ax3 = fig1.add_subplot(413, frame_on=True, title="product_graph(A,B)")
# ax4=fig1.add_subplot(414,frame_on=True,title="ref")
draw_ComputerSetMultiDiGraph_matplotlib(ax1, asg_A)
draw_ComputerSetMultiDiGraph_matplotlib(ax2, asg_B)
draw_ComputerSetMultiDiGraph_matplotlib(ax3, pg_A_B)
fig1.savefig("A_y_B_Y_B_Z.pdf")
# {a(z)} {b(z)} {a(z),b(z)}
# {z} -> {a} x {z} -> {b} = {z} -> {a,b}
computers = frozenset({a_from_z, b_from_z})
asg_A = arg_set_graph(A, computers)
asg_B = arg_set_graph(B, computers)
pg_A_B = product_graph(asg_A, asg_B)
fig1 = plt.figure(figsize=(10, 30))
ax1 = fig1.add_subplot(411, frame_on=True, title="arg_set_graph(A)")
ax2 = fig1.add_subplot(412, frame_on=True, title="arg_set_graph(B)")
ax3 = fig1.add_subplot(413, frame_on=True, title="product_graph(A,B)")
# ax4=fig1.add_subplot(414,frame_on=True,title="ref")
draw_ComputerSetMultiDiGraph_matplotlib(ax1, asg_A)
draw_ComputerSetMultiDiGraph_matplotlib(ax2, asg_B)
draw_ComputerSetMultiDiGraph_matplotlib(ax3, pg_A_B)
fig1.savefig("A_Z_B_Y.pdf")
computers = frozenset({a_from_z, b_from_z, c_from_b})
asg_A = arg_set_graph(A, computers)
asg_B = arg_set_graph(B, computers)
asg_C = arg_set_graph(C, computers)
asg_C = arg_set_graph(C, computers)
prod = product_graph(*[asg_A, asg_B, asg_C])
fig1 = plt.figure(figsize=(10, 30))
ax1 = fig1.add_subplot(511, frame_on=True, title="arg_set_graph(A)")
ax2 = fig1.add_subplot(512, frame_on=True, title="arg_set_graph(B)")
ax3 = fig1.add_subplot(513, frame_on=True, title="arg_set_graph(C)")
ax4 = fig1.add_subplot(514, frame_on=True, title="product_graph(A,B,C)")
# ax4=fig1.add_subplot(414,frame_on=True,title="ref")
draw_ComputerSetMultiDiGraph_matplotlib(ax1, asg_A)
draw_ComputerSetMultiDiGraph_matplotlib(ax2, asg_B)
draw_ComputerSetMultiDiGraph_matplotlib(ax3, asg_C)
draw_ComputerSetMultiDiGraph_matplotlib(ax4, prod)
fig1.savefig("ABC.pdf")