File size: 3,764 Bytes
5543795
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

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()