from __future__ import annotations import io import zipfile from typing import Dict, Tuple import networkx as nx import numpy as np import pandas as pd import scipy.sparse as sp def _graph_to_edge_list(G: nx.Graph, use_real_pos: bool = False) -> Tuple[pd.DataFrame, pd.DataFrame]: nodes_rows = [] edges_rows = [] for n, data in G.nodes(data=True): if use_real_pos and "pos_real" in data: p = data["pos_real"] else: p = data.get("pos") if p is None: x = y = z = float("nan") else: x, y, z = float(p[0]), float(p[1]), float(p[2]) nodes_rows.append({"node_id": n, "x": x, "y": y, "z": z}) for u, v, edata in G.edges(data=True): edges_rows.append( { "u": u, "v": v, "weight": float(edata.get("weight", 1.0)), "energy": float(edata.get("energy", 0.0)), } ) df_nodes = pd.DataFrame(nodes_rows) df_edges = pd.DataFrame(edges_rows) return df_nodes, df_edges def make_artifacts_zip(context: Dict) -> bytes: """ Sammle wichtige Artefakte eines Runs in einem ZIP. """ G_ideal = context["G_ideal"] G_real = context["G_real"] pos_real = context["pos_real"] Q = context["Q"] node_order = context["node_order"] bath_info = context["bath"] f_potential = context["potential"] edge_energies = context["edge_energies"] address_df = context["address_df"] # REAL-Positionen im Graph speichern for nid, p in pos_real.items(): G_real.nodes[nid]["pos_real"] = p ideal_nodes_df, ideal_edges_df = _graph_to_edge_list(G_ideal, use_real_pos=False) real_nodes_df, real_edges_df = _graph_to_edge_list(G_real, use_real_pos=True) boundary_values = bath_info["boundary_values"] boundary_order = bath_info["boundary_order"] C = bath_info["C"] df_bath = pd.DataFrame( { "boundary_node": boundary_order, "value": [float(boundary_values[n]) for n in boundary_order], } ) df_potential = pd.DataFrame( { "node_id": list(f_potential.keys()), "potential": [float(v) for v in f_potential.values()], } ) edge_rows = [] for (u, v), E in edge_energies.items(): edge_rows.append({"u": u, "v": v, "energy": float(E)}) df_edge_energy = pd.DataFrame(edge_rows) df_Q_nodes = pd.DataFrame({"index": list(range(len(node_order))), "node_id": node_order}) buf = io.BytesIO() with zipfile.ZipFile(buf, mode="w", compression=zipfile.ZIP_DEFLATED) as zf: def add_df(name: str, df: pd.DataFrame): inner = io.StringIO() df.to_csv(inner, index=False) zf.writestr(name, inner.getvalue()) add_df("ideal_nodes.csv", ideal_nodes_df) add_df("ideal_edges.csv", ideal_edges_df) add_df("real_nodes.csv", real_nodes_df) add_df("real_edges.csv", real_edges_df) add_df("bath_boundary_values.csv", df_bath) add_df("bath_covariance_C.csv", pd.DataFrame(C)) add_df("potential_f.csv", df_potential) add_df("edge_energies.csv", df_edge_energy) add_df("Q_node_order.csv", df_Q_nodes) add_df("cell_address_tree.csv", address_df) if sp.issparse(Q): zf.writestr("Q_sparse_shape.txt", f"{Q.shape[0]} {Q.shape[1]}") coo = Q.tocoo() df_Q = pd.DataFrame( { "row": coo.row.astype(int), "col": coo.col.astype(int), "data": coo.data.astype(float), } ) add_df("Q_sparse_entries.csv", df_Q) return buf.getvalue()