NGF_on_Fractale / src /modules /artifacts.py
antaris's picture
Upload 33 files
5543795 verified
Raw History Blame Contribute Delete
3.76 kB
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()