Spaces:
Running
Running
| import matplotlib.pyplot as plt | |
| from mpl_toolkits.mplot3d import Axes3D | |
| import networkx as nx | |
| import numpy as np | |
| import json | |
| import sys | |
| import random | |
| def generate_tree(current_x, current_y, depth, max_depth, max_nodes, x_range, G, parent=None, node_count_per_depth=None): | |
| """Generates a tree of nodes with positions adjusted on the x-axis, y-axis, and number of nodes on the z-axis.""" | |
| if node_count_per_depth is None: | |
| node_count_per_depth = {} | |
| if depth > max_depth: | |
| return node_count_per_depth | |
| if depth not in node_count_per_depth: | |
| node_count_per_depth[depth] = 0 | |
| num_children = random.randint(1, max_nodes) | |
| x_positions = [current_x + i * x_range / (num_children + 1) for i in range(num_children)] | |
| for x in x_positions: | |
| node_id = len(G.nodes) | |
| node_count_per_depth[depth] += 1 | |
| prob = random.uniform(0, 1) | |
| G.add_node(node_id, pos=(x, prob, depth)) | |
| if parent is not None: | |
| G.add_edge(parent, node_id) | |
| generate_tree(x, current_y + 1, depth + 1, max_depth, max_nodes, x_range, G, parent=node_id, node_count_per_depth=node_count_per_depth) | |
| return node_count_per_depth | |
| def build_graph_from_json(json_data, G): | |
| """Builds a graph from JSON data.""" | |
| # data = json.loads(json_data) # No need to load JSON here | |
| def add_event(parent_id, event_data, depth): | |
| node_id = len(G.nodes) | |
| prob = event_data['probability'] / 100.0 | |
| pos = (depth, prob, event_data['event_number']) | |
| label = event_data['name'] | |
| G.add_node(node_id, pos=pos, label=label) | |
| if parent_id is not None: | |
| G.add_edge(parent_id, node_id) | |
| subevents = event_data.get('subevents', {}).get('event', []) | |
| if not isinstance(subevents, list): | |
| subevents = [subevents] | |
| for subevent in subevents: | |
| add_event(node_id, subevent, depth + 1) | |
| root_event = list(json_data.get('events', {}).values())[0] # Use json_data directly | |
| root_id = len(G.nodes) | |
| G.add_node(root_id, pos=(0, root_event['probability'] / 100.0, root_event['event_number']), label=root_event['name']) | |
| add_event(None, root_event, 0) | |
| def find_paths(G): | |
| """Finds paths with highest/lowest probability and longest/shortest durations.""" | |
| best_path, worst_path = None, None | |
| longest_path, shortest_path = None, None | |
| best_mean_prob, worst_mean_prob = -1, float('inf') | |
| max_duration, min_duration = -1, float('inf') | |
| # Use nx.all_pairs_shortest_path for efficiency | |
| all_paths_dict = dict(nx.all_pairs_shortest_path(G)) | |
| for source, paths_from_source in all_paths_dict.items(): | |
| for target, path in paths_from_source.items(): | |
| if source != target and all('pos' in G.nodes[node] for node in path): | |
| probabilities = [G.nodes[node]['pos'][1] for node in path] | |
| mean_prob = np.mean(probabilities) | |
| if mean_prob > best_mean_prob: | |
| best_mean_prob = mean_prob | |
| best_path = path | |
| if mean_prob < worst_mean_prob: | |
| worst_mean_prob = mean_prob | |
| worst_path = path | |
| x_positions = [G.nodes[node]['pos'][0] for node in path] | |
| duration = max(x_positions) - min(x_positions) | |
| if duration > max_duration: | |
| max_duration = duration | |
| longest_path = path | |
| if duration < min_duration and duration > 0: # Avoid paths with 0 duration | |
| min_duration = duration | |
| shortest_path = path | |
| return best_path, best_mean_prob, worst_path, worst_mean_prob, longest_path, shortest_path | |
| def draw_path_3d(G, path, filename='path_plot_3d.png', highlight_color='blue'): | |
| """Draws a specific path in 3D.""" | |
| H = G.subgraph(path).copy() | |
| pos = nx.get_node_attributes(G, 'pos') | |
| x_vals, y_vals, z_vals = zip(*[pos[node] for node in path]) | |
| fig = plt.figure(figsize=(16, 12)) | |
| ax = fig.add_subplot(111, projection='3d') | |
| node_colors = ['red' if prob < 0.33 else 'blue' if prob < 0.67 else 'green' for _, prob, _ in [pos[node] for node in path]] | |
| ax.scatter(x_vals, y_vals, z_vals, c=node_colors, s=700, edgecolors='black', alpha=0.7) | |
| for edge in H.edges(): | |
| x_start, y_start, z_start = pos[edge[0]] | |
| x_end, y_end, z_end = pos[edge[1]] | |
| ax.plot([x_start, x_end], [y_start, y_end], [z_start, z_end], color=highlight_color, lw=2) | |
| for node, (x, y, z) in pos.items(): | |
| if node in path: | |
| ax.text(x, y, z, str(node), fontsize=12, color='black') | |
| ax.set_xlabel('Time (weeks)') | |
| ax.set_ylabel('Event Probability') | |
| ax.set_zlabel('Event Number') | |
| ax.set_title('3D Event Tree - Path') | |
| plt.savefig(filename, bbox_inches='tight') | |
| plt.close() | |
| def draw_global_tree_3d(G, filename='global_tree.png'): | |
| """Draws the entire graph in 3D.""" | |
| pos = nx.get_node_attributes(G, 'pos') | |
| labels = nx.get_node_attributes(G, 'label') | |
| if not pos: | |
| print("Graph is empty. No nodes to visualize.") | |
| return | |
| x_vals, y_vals, z_vals = zip(*pos.values()) | |
| fig = plt.figure(figsize=(16, 12)) | |
| ax = fig.add_subplot(111, projection='3d') | |
| node_colors = ['red' if prob < 0.33 else 'blue' if prob < 0.67 else 'green' for _, prob, _ in pos.values()] | |
| ax.scatter(x_vals, y_vals, z_vals, c=node_colors, s=700, edgecolors='black', alpha=0.7) | |
| for edge in G.edges(): | |
| x_start, y_start, z_start = pos[edge[0]] | |
| x_end, y_end, z_end = pos[edge[1]] | |
| ax.plot([x_start, x_end], [y_start, y_end], [z_start, z_end], color='gray', lw=2) | |
| for node, (x, y, z) in pos.items(): | |
| label = labels.get(node, f"{node}") | |
| ax.text(x, y, z, label, fontsize=12, color='black') | |
| ax.set_xlabel('Time') | |
| ax.set_ylabel('Probability') | |
| ax.set_zlabel('Event Number') | |
| ax.set_title('3D Event Tree') | |
| plt.savefig(filename, bbox_inches='tight') | |
| plt.close() | |
| def main(json_data): | |
| G = nx.DiGraph() | |
| build_graph_from_json(json_data, G) # Build graph from the provided JSON data | |
| draw_global_tree_3d(G, filename='global_tree.png') | |
| best_path, best_mean_prob, worst_path, worst_mean_prob, longest_path, shortest_path = find_paths(G) | |
| if best_path: | |
| print(f"\nPath with the highest average probability: {' -> '.join(map(str, best_path))}") | |
| print(f"Average probability: {best_mean_prob:.2f}") | |
| if worst_path: | |
| print(f"\nPath with the lowest average probability: {' -> '.join(map(str, worst_path))}") | |
| print(f"Average probability: {worst_mean_prob:.2f}") | |
| if longest_path: | |
| print(f"\nPath with the longest duration: {' -> '.join(map(str, longest_path))}") | |
| print(f"Duration: {max(G.nodes[node]['pos'][0] for node in longest_path) - min(G.nodes[node]['pos'][0] for node in longest_path):.2f}") | |
| if shortest_path: | |
| print(f"\nPath with the shortest duration: {' -> '.join(map(str, shortest_path))}") | |
| print(f"Duration: {max(G.nodes[node]['pos'][0] for node in shortest_path) - min(G.nodes[node]['pos'][0] for node in shortest_path):.2f}") | |
| if best_path: | |
| draw_path_3d(G, best_path, 'best_path.png', 'blue') | |
| if worst_path: | |
| draw_path_3d(G, worst_path, 'worst_path.png', 'red') | |
| if longest_path: | |
| draw_path_3d(G, longest_path, 'longest_duration_path.png', 'green') | |
| if shortest_path: | |
| draw_path_3d(G, shortest_path, 'shortest_duration_path.png', 'purple') | |
| return 'global_tree.png' # Return the filename of the global tree | |