Update app.py

app.py

@@ -101,6 +101,11 @@ if "szenario_bestaetigt" not in st.session_state:
 if "szenario" not in st.session_state:
     st.session_state.szenario = None
 
+if "annuitaeten_objekt_map_batch" not in st.session_state:
+    st.session_state["annuitaeten_objekt_map_batch"] = {}
+if "annuitaeten_gesamt_batch" not in st.session_state:
+    st.session_state["annuitaeten_gesamt_batch"] = []
+
 szenario_df = load_szenario_data('Data/Szenario-Input.csv')
 szenario_liste = list(szenario_df.index)
 
@@ -521,9 +526,9 @@ elif modus == "Upload csv-Datei":
             else:
                 st.session_state.batch_user_values = None
 
-            annuitaeten_gesamt = []
-            annuitaeten_objekt_map = {}
-            
+            st.session_state["annuitaeten_gesamt_batch"] = annuitaeten_gesamt
+            st.session_state["annuitaeten_objekt_map_batch"] = annuitaeten_objekt_map
+
             do_calc = st.button("Batch-Berechnung starten")
             if do_calc:
                 try:
@@ -535,6 +540,9 @@ elif modus == "Upload csv-Datei":
                         df_out[name] = ""
                         df_out[hname] = ""
             
+                    annuitaeten_gesamt = []
+                    annuitaeten_objekt_map = {}
+            
                     for idx, row in df_input.iterrows():
                         try:
                             nutzflaeche = row["Wohnflaeche"]
@@ -556,18 +564,16 @@ elif modus == "Upload csv-Datei":
                                         "Fixkosten_O+M", "Preisänderungsfaktor_O+M", "Emissionsänderungsfaktor", "Förderung"]:
                                 df[col] = df[col].astype(str).str.replace(",", ".").str.replace("|", ".")
                                 df[col] = pd.to_numeric(df[col], errors='coerce')
-                            # Wenn Batch-global-Werte gesetzt sind, anwenden:
                             batch_user_vals = st.session_state.get("batch_user_values")
                             if batch_user_vals is not None:
-                                # Mapping via Name zur Sicherheit
                                 preview_heizsys_names = {preview_df.loc[x, "Name"]: x for x in preview_df.index}
                                 for pidx in batch_user_vals:
                                     sysname = preview_df.loc[pidx, "Name"]
-                                    # Suche nach dem Namen im aktuellen DF
                                     df_idx = df[df["Name"] == sysname].index
                                     if not df_idx.empty:
                                         for key in batch_user_vals[pidx]:
                                             df.at[df_idx[0], key] = batch_user_vals[pidx][key]
+            
                             energiebedarf = energiebedarf_spezifisch
                             df["Energiebedarf"] = df.apply(lambda rowh: calculate_energiebedarf(
                                 energiebedarf, nutzflaeche, rowh["Effizienz"]), axis=1)
@@ -586,133 +592,315 @@ elif modus == "Upload csv-Datei":
                             df["Annuität_NS"] = 0
                             df["Annuität"] = df["Annuität_NK"] + df["Annuität_NV"] + df["Annuität_NB"] + df["Annuität_NS"]
                             df = df.sort_values("Annuität")
+            
                             df_anni = df[[
                                 "Name", "Annuität_NK", "Annuität_NV", "Annuität_NB", "Annuität"
                             ]].copy()
                             df_anni["Objekt-ID"] = row.get("Objekt-ID", idx)
                             annuitaeten_gesamt.append(df_anni)
                             annuitaeten_objekt_map[str(row.get("Objekt-ID", idx))] = df_anni
-
+            
                             for j in range(min(len(df), max_count)):
                                 df_out.at[idx, annuität_colnames[j]] = int(df.iloc[j]["Annuität"])
                                 df_out.at[idx, hsystem_colnames[j]] = df.iloc[j]["Name"]
                         except Exception as e:
                             st.warning(f"Objekt-ID {row.get('Objekt-ID', idx)}: {e}")
+            
+                    # Im Session-State speichern!
+                    st.session_state["annuitaeten_gesamt_batch"] = annuitaeten_gesamt
+                    st.session_state["annuitaeten_objekt_map_batch"] = annuitaeten_objekt_map
+            
+                    # (Optional: Platz-1-Übersicht, Mapping, weitere Batch-Funktionen ...)
+                    st.success("Berechnung abgeschlossen!")
+                except Exception as e:
+                    st.error(f"Fehler beim Einlesen/Berechnen: {e}")
+
+            # --- Batch-Mittelwert-Grafik/Nachbereitung ---
+            
+            if st.session_state["annuitaeten_gesamt_batch"]:
+                df_alle = pd.concat(st.session_state["annuitaeten_gesamt_batch"], ignore_index=True)
+                df_mittel = df_alle.groupby("Name")[["Annuität_NK", "Annuität_NV", "Annuität_NB", "Annuität"]].mean(numeric_only=True).reset_index()
+                df_stacked = df_mittel.melt(
+                    id_vars="Name",
+                    value_vars=["Annuität_NK", "Annuität_NV", "Annuität_NB"],
+                    var_name="Kostenart",
+                    value_name="Wert"
+                )
+                df_stacked["Kostenart"] = df_stacked["Kostenart"].replace({
+                    "Annuität_NK": "Kapitalgebundene Kosten",
+                    "Annuität_NV": "Bedarfsgebundene Kosten",
+                    "Annuität_NB": "Betriebsgebundene Kosten"
+                })
+                kostenart_order = ["Kapitalgebundene Kosten", "Bedarfsgebundene Kosten", "Betriebsgebundene Kosten"]
+                df_stacked["Kostenart"] = pd.Categorical(df_stacked["Kostenart"], categories=kostenart_order, ordered=True)
+                color_scale = alt.Scale(domain=kostenart_order, range=["#00386c", "#004c93", "#0069c8"])
+                sortierte_names = df_mittel.sort_values("Annuität")["Name"]
+            
+                st.markdown("### Mittlere annualisierte Kosten pro Heizsystem (Batch-Durchschnitt)")
+                st.altair_chart(
+                    alt.Chart(df_stacked)
+                    .mark_bar()
+                    .encode(
+                        x=alt.X("Wert:Q", title="mittlere annualisierte Kosten (€)", stack="zero"),
+                        y=alt.Y("Name:N", title="Heizsystem", sort=list(sortierte_names)),
+                        color=alt.Color("Kostenart:N", scale=color_scale, title="Kostenart"),
+                        tooltip=["Name", "Kostenart", "Wert"]
+                    ).properties(height=350, width=650),
+                    use_container_width=True
+                )
+            
+            # Download der Batch-CSV
+            csv_buffer = io.StringIO()
+            df_out.to_csv(csv_buffer, sep=";", index=False)
+            csv_bytes = csv_buffer.getvalue().encode("utf-8")
+            st.download_button(
+                "Download Ergebnis-CSV",
+                csv_bytes,
+                file_name="heizsysteme_batch_ergebnis.csv",
+                mime="text/csv"
+            )
+            
+            # Einzelobjekt-Detailauswertung:
+            if st.session_state["annuitaeten_objekt_map_batch"] and len(st.session_state["annuitaeten_objekt_map_batch"]) > 0:
+                st.markdown("### Einzelanalyse eines Objekts (wie Einzel-Darstellung)")
+                objekt_ids = list(st.session_state["annuitaeten_objekt_map_batch"].keys())
+                col1, col2 = st.columns([5, 2])
+                with col1:
+                    auswahl = st.selectbox(
+                        "Objekt für Detaildarstellung auswählen", objekt_ids, key="batch_detail_sbox",
+                        index=objekt_ids.index(st.session_state["selected_objekt_id_batch_detail"])
+                        if st.session_state["selected_objekt_id_batch_detail"] in objekt_ids else 0
+                    )
+                with col2:
+                    if st.button("Kostenvergleich für ausgewähltes Objekt anzeigen", key="batch_detail_show_btn"):
+                        st.session_state["selected_objekt_id_batch_detail"] = auswahl
+            
+                show_id = st.session_state["selected_objekt_id_batch_detail"]
+                if show_id and show_id in st.session_state["annuitaeten_objekt_map_batch"]:
+                    df_einzel = st.session_state["annuitaeten_objekt_map_batch"][show_id]
+                    df_stacked = df_einzel[["Name", "Annuität_NK", "Annuität_NV", "Annuität_NB"]].melt(
+                        id_vars="Name",
+                        value_vars=["Annuität_NK", "Annuität_NV", "Annuität_NB"],
+                        var_name="Kostenart",
+                        value_name="Wert"
+                    )
+                    df_stacked["Kostenart"] = df_stacked["Kostenart"].replace({
+                        "Annuität_NK": "Kapitalgebundene Kosten",
+                        "Annuität_NV": "Bedarfsgebundene Kosten",
+                        "Annuität_NB": "Betriebsgebundene Kosten"
+                    })
+                    kostenart_order = ["Kapitalgebundene Kosten", "Bedarfsgebundene Kosten", "Betriebsgebundene Kosten"]
+                    df_stacked["Kostenart"] = pd.Categorical(df_stacked["Kostenart"], categories=kostenart_order, ordered=True)
+                    color_scale = alt.Scale(domain=kostenart_order, range=["#00386c", "#004c93", "#0069c8"])
+                    sortierte_names = df_einzel.sort_values("Annuität")["Name"]
+            
+                    st.markdown(f"#### Annualisierte Kosten für Objekt {show_id}")
+                    st.altair_chart(
+                        alt.Chart(df_stacked)
+                        .mark_bar()
+                        .encode(
+                            x=alt.X("Wert:Q", title="Annualisierte Kosten (€)", stack="zero"),
+                            y=alt.Y("Name:N", title="Heizsystem", sort=list(sortierte_names)),
+                            color=alt.Color("Kostenart:N", scale=color_scale, title="Kostenart"),
+                            tooltip=["Name", "Kostenart", "Wert"]
+                        ).properties(height=350, width=650),
+                        use_container_width=True
+                    )
+            
+            st.markdown("---")
+            st.caption("Berechnung nach VDI 2067, Heizsystemauswahl gemäß DIN EN 15378.")
+
+
+            
+        #     do_calc = st.button("Batch-Berechnung starten")
+        #     if do_calc:
+        #         try:
+        #             df_out = df_input.copy()
+        #             max_count = 8
+        #             annuität_colnames = [f"Heizsystem_{i+1}" for i in range(max_count)]
+        #             hsystem_colnames = [f"Heizsystem_Name_{i+1}" for i in range(max_count)]
+        #             for name, hname in zip(annuität_colnames, hsystem_colnames):
+        #                 df_out[name] = ""
+        #                 df_out[hname] = ""
+            
+        #             for idx, row in df_input.iterrows():
+        #                 try:
+        #                     nutzflaeche = row["Wohnflaeche"]
+        #                     baujahr = int(row["Baujahr"])
+        #                     gesamtbedarf = row.get("Gesamtwaermebedarf", "")
+        #                     spezbedarf = row.get("spezifischer Waermebedarf", "")
+        #                     if pd.notnull(gesamtbedarf) and gesamtbedarf != '' and float(gesamtbedarf) > 0 and nutzflaeche > 0:
+        #                         energiebedarf_spezifisch = float(gesamtbedarf) / float(nutzflaeche)
+        #                     else:
+        #                         energiebedarf_spezifisch = float(spezbedarf)
+        #                     df = finde_passende_heizsysteme(energiebedarf_spezifisch, baujahr, nutzflaeche, szen_kurz)
+        #                     df.columns = [
+        #                         "Name", "Leistung", "Investitionskosten", "Betriebsdauer", "Effizienz", "Emissionen",
+        #                         "Preisänderungsfaktor_Inv", "Betriebskosten", "Preisänderungsfaktor_Bedarf",
+        #                         "Fixkosten_O+M", "Preisänderungsfaktor_O+M", "Emissionsänderungsfaktor", "Förderung"
+        #                     ]
+        #                     for col in ["Investitionskosten", "Betriebsdauer", "Effizienz", "Emissionen",
+        #                                 "Preisänderungsfaktor_Inv", "Betriebskosten", "Preisänderungsfaktor_Bedarf",
+        #                                 "Fixkosten_O+M", "Preisänderungsfaktor_O+M", "Emissionsänderungsfaktor", "Förderung"]:
+        #                         df[col] = df[col].astype(str).str.replace(",", ".").str.replace("|", ".")
+        #                         df[col] = pd.to_numeric(df[col], errors='coerce')
+        #                     # Wenn Batch-global-Werte gesetzt sind, anwenden:
+        #                     batch_user_vals = st.session_state.get("batch_user_values")
+        #                     if batch_user_vals is not None:
+        #                         # Mapping via Name zur Sicherheit
+        #                         preview_heizsys_names = {preview_df.loc[x, "Name"]: x for x in preview_df.index}
+        #                         for pidx in batch_user_vals:
+        #                             sysname = preview_df.loc[pidx, "Name"]
+        #                             # Suche nach dem Namen im aktuellen DF
+        #                             df_idx = df[df["Name"] == sysname].index
+        #                             if not df_idx.empty:
+        #                                 for key in batch_user_vals[pidx]:
+        #                                     df.at[df_idx[0], key] = batch_user_vals[pidx][key]
+        #                     energiebedarf = energiebedarf_spezifisch
+        #                     df["Energiebedarf"] = df.apply(lambda rowh: calculate_energiebedarf(
+        #                         energiebedarf, nutzflaeche, rowh["Effizienz"]), axis=1)
+        #                     df["Annuität_NK"] = df.apply(
+        #                         lambda rowh: calculate_annuity_nk(rowh["Förderung"], rowh["Investitionskosten"], zinssatz, rowh["Betriebsdauer"],
+        #                                                          beobachtungszeitraum, rowh["Preisänderungsfaktor_Inv"]), axis=1)
+        #                     df["Annuität_NV"] = df.apply(
+        #                         lambda rowh: calculate_annuity_nv(
+        #                             float(rowh["Betriebskosten"]) - float(rowh["Emissionen"]) * emission_cost, rowh["Energiebedarf"], zinssatz,
+        #                             rowh["Preisänderungsfaktor_Bedarf"], beobachtungszeitraum,
+        #                             emission_cost, rowh["Emissionen"], preisaenderungsfaktor_emission, rowh["Emissionsänderungsfaktor"]
+        #                         ), axis=1)
+        #                     df["Annuität_NB"] = df.apply(
+        #                         lambda rowh: calculate_annuity_nb(rowh["Leistung"], rowh["Fixkosten_O+M"], rowh["Preisänderungsfaktor_O+M"],
+        #                                                          zinssatz, beobachtungszeitraum), axis=1)
+        #                     df["Annuität_NS"] = 0
+        #                     df["Annuität"] = df["Annuität_NK"] + df["Annuität_NV"] + df["Annuität_NB"] + df["Annuität_NS"]
+        #                     df = df.sort_values("Annuität")
+        #                     df_anni = df[[
+        #                         "Name", "Annuität_NK", "Annuität_NV", "Annuität_NB", "Annuität"
+        #                     ]].copy()
+        #                     df_anni["Objekt-ID"] = row.get("Objekt-ID", idx)
+        #                     annuitaeten_gesamt.append(df_anni)
+        #                     annuitaeten_objekt_map[str(row.get("Objekt-ID", idx))] = df_anni
+
+        #                     for j in range(min(len(df), max_count)):
+        #                         df_out.at[idx, annuität_colnames[j]] = int(df.iloc[j]["Annuität"])
+        #                         df_out.at[idx, hsystem_colnames[j]] = df.iloc[j]["Name"]
+        #                 except Exception as e:
+        #                     st.warning(f"Objekt-ID {row.get('Objekt-ID', idx)}: {e}")
     
-                    heizsystem_namensmap = {
-                        "Ölheizung": "Oelheizung",
-                        "Luft-Wasser Wärmepumpe": "Luft-Wasser Waermepumpe",
-                        "Sole-Wasser Wärmepumpe": "Sole-Wasser Waermepumpe",
-                        "Wasser-Wasser Wärmepumpe": "Wasser-Wasser Waermepumpe",
-                    }
-                    for col in hsystem_colnames:
-                        df_out[col] = df_out[col].replace(heizsystem_namensmap)
+        #             heizsystem_namensmap = {
+        #                 "Ölheizung": "Oelheizung",
+        #                 "Luft-Wasser Wärmepumpe": "Luft-Wasser Waermepumpe",
+        #                 "Sole-Wasser Wärmepumpe": "Sole-Wasser Waermepumpe",
+        #                 "Wasser-Wasser Wärmepumpe": "Wasser-Wasser Waermepumpe",
+        #             }
+        #             for col in hsystem_colnames:
+        #                 df_out[col] = df_out[col].replace(heizsystem_namensmap)
                         
-                    st.success("Berechnung abgeschlossen!")
+        #             st.success("Berechnung abgeschlossen!")
 
-                    if annuitaeten_gesamt:
-                        # Verbinde alle Einzel-DFs zu einem großen Table
-                        df_alle = pd.concat(annuitaeten_gesamt, ignore_index=True)
-                        # Mittelwerte pro System
-                        df_mittel = df_alle.groupby("Name")[["Annuität_NK", "Annuität_NV", "Annuität_NB", "Annuität"]].mean(numeric_only=True).reset_index()
+        #             if annuitaeten_gesamt:
+        #                 # Verbinde alle Einzel-DFs zu einem großen Table
+        #                 df_alle = pd.concat(annuitaeten_gesamt, ignore_index=True)
+        #                 # Mittelwerte pro System
+        #                 df_mittel = df_alle.groupby("Name")[["Annuität_NK", "Annuität_NV", "Annuität_NB", "Annuität"]].mean(numeric_only=True).reset_index()
                     
-                        # Für gestapeltes Balkendiagramm (wie im Einzel-Modus)
-                        df_stacked = df_mittel.melt(
-                            id_vars="Name",
-                            value_vars=["Annuität_NK", "Annuität_NV", "Annuität_NB"],
-                            var_name="Kostenart",
-                            value_name="Wert"
-                        )
-                        df_stacked["Kostenart"] = df_stacked["Kostenart"].replace({
-                            "Annuität_NK": "Kapitalgebundene Kosten",
-                            "Annuität_NV": "Bedarfsgebundene Kosten",
-                            "Annuität_NB": "Betriebsgebundene Kosten"
-                        })
-                        kostenart_order = ["Kapitalgebundene Kosten", "Bedarfsgebundene Kosten", "Betriebsgebundene Kosten"]
-                        df_stacked["Kostenart"] = pd.Categorical(df_stacked["Kostenart"], categories=kostenart_order, ordered=True)
-                        color_scale = alt.Scale(domain=kostenart_order, range=["#00386c", "#004c93", "#0069c8"])
+        #                 # Für gestapeltes Balkendiagramm (wie im Einzel-Modus)
+        #                 df_stacked = df_mittel.melt(
+        #                     id_vars="Name",
+        #                     value_vars=["Annuität_NK", "Annuität_NV", "Annuität_NB"],
+        #                     var_name="Kostenart",
+        #                     value_name="Wert"
+        #                 )
+        #                 df_stacked["Kostenart"] = df_stacked["Kostenart"].replace({
+        #                     "Annuität_NK": "Kapitalgebundene Kosten",
+        #                     "Annuität_NV": "Bedarfsgebundene Kosten",
+        #                     "Annuität_NB": "Betriebsgebundene Kosten"
+        #                 })
+        #                 kostenart_order = ["Kapitalgebundene Kosten", "Bedarfsgebundene Kosten", "Betriebsgebundene Kosten"]
+        #                 df_stacked["Kostenart"] = pd.Categorical(df_stacked["Kostenart"], categories=kostenart_order, ordered=True)
+        #                 color_scale = alt.Scale(domain=kostenart_order, range=["#00386c", "#004c93", "#0069c8"])
                     
-                        # Heizsysteme nach mittlerer Gesamtkosten sortieren
-                        sortierte_names = df_mittel.sort_values("Annuität")["Name"]
+        #                 # Heizsysteme nach mittlerer Gesamtkosten sortieren
+        #                 sortierte_names = df_mittel.sort_values("Annuität")["Name"]
                     
-                        st.markdown("### Mittlere annualisierte Kosten pro Heizsystem (Batch-Durchschnitt)")
-                        st.altair_chart(
-                            alt.Chart(df_stacked)
-                            .mark_bar()
-                            .encode(
-                                x=alt.X("Wert:Q", title="mittlere annualisierte Kosten (€)", stack="zero"),
-                                y=alt.Y("Name:N", title="Heizsystem", sort=list(sortierte_names)),
-                                color=alt.Color("Kostenart:N", scale=color_scale, title="Kostenart"),
-                                tooltip=["Name", "Kostenart", "Wert"]
-                            ).properties(height=350, width=650),
-                            use_container_width=True
-                        )
+        #                 st.markdown("### Mittlere annualisierte Kosten pro Heizsystem (Batch-Durchschnitt)")
+        #                 st.altair_chart(
+        #                     alt.Chart(df_stacked)
+        #                     .mark_bar()
+        #                     .encode(
+        #                         x=alt.X("Wert:Q", title="mittlere annualisierte Kosten (€)", stack="zero"),
+        #                         y=alt.Y("Name:N", title="Heizsystem", sort=list(sortierte_names)),
+        #                         color=alt.Color("Kostenart:N", scale=color_scale, title="Kostenart"),
+        #                         tooltip=["Name", "Kostenart", "Wert"]
+        #                     ).properties(height=350, width=650),
+        #                     use_container_width=True
+        #                 )
                    
-                    csv_buffer = io.StringIO()
-                    df_out.to_csv(csv_buffer, sep=";", index=False)
-                    csv_bytes = csv_buffer.getvalue().encode("utf-8")
-                    st.download_button(
-                        "Download Ergebnis-CSV",
-                        csv_bytes,
-                        file_name="heizsysteme_batch_ergebnis.csv",
-                        mime="text/csv"
-                    )
+        #             csv_buffer = io.StringIO()
+        #             df_out.to_csv(csv_buffer, sep=";", index=False)
+        #             csv_bytes = csv_buffer.getvalue().encode("utf-8")
+        #             st.download_button(
+        #                 "Download Ergebnis-CSV",
+        #                 csv_bytes,
+        #                 file_name="heizsysteme_batch_ergebnis.csv",
+        #                 mime="text/csv"
+        #             )
                     
-                    # --- Einzelobjekt-Grafik nach dem Batch-Durchschnitt (immer NACH Mittelwert und Download-Button!) ---
+        #             # --- Einzelobjekt-Grafik nach dem Batch-Durchschnitt (immer NACH Mittelwert und Download-Button!) ---
                     
-                    if annuitaeten_objekt_map and len(annuitaeten_objekt_map) > 0:
-                        st.markdown("### Einzelanalyse eines Objekts (wie Einzel-Darstellung)")
+        #             if annuitaeten_objekt_map and len(annuitaeten_objekt_map) > 0:
+        #                 st.markdown("### Einzelanalyse eines Objekts (wie Einzel-Darstellung)")
                     
-                        objekt_ids = list(annuitaeten_objekt_map.keys())
-                        # EIGENER Key, EIGENE Session-Variable nur für diese Auswahl!
-                        col1, col2 = st.columns([5, 2])
-                        with col1:
-                            auswahl = st.selectbox(
-                                "Objekt für Detaildarstellung auswählen", objekt_ids, key="batch_detail_sbox",
-                                index=objekt_ids.index(st.session_state["selected_objekt_id_batch_detail"])
-                                if st.session_state["selected_objekt_id_batch_detail"] in objekt_ids else 0
-                            )
-                        with col2:
-                            if st.button("Kostenvergleich für ausgewähltes Objekt anzeigen", key="batch_detail_show_btn"):
-                                st.session_state["selected_objekt_id_batch_detail"] = auswahl
+        #                 objekt_ids = list(annuitaeten_objekt_map.keys())
+        #                 # EIGENER Key, EIGENE Session-Variable nur für diese Auswahl!
+        #                 col1, col2 = st.columns([5, 2])
+        #                 with col1:
+        #                     auswahl = st.selectbox(
+        #                         "Objekt für Detaildarstellung auswählen", objekt_ids, key="batch_detail_sbox",
+        #                         index=objekt_ids.index(st.session_state["selected_objekt_id_batch_detail"])
+        #                         if st.session_state["selected_objekt_id_batch_detail"] in objekt_ids else 0
+        #                     )
+        #                 with col2:
+        #                     if st.button("Kostenvergleich für ausgewähltes Objekt anzeigen", key="batch_detail_show_btn"):
+        #                         st.session_state["selected_objekt_id_batch_detail"] = auswahl
                     
-                        # Nach dem Buttonklick bleibt das Diagramm sichtbar, bis ein neuer Klick gemacht wird
-                        show_id = st.session_state["selected_objekt_id_batch_detail"]
-                        if show_id and show_id in annuitaeten_objekt_map:
-                            df_einzel = annuitaeten_objekt_map[show_id]
-                            df_stacked = df_einzel[["Name", "Annuität_NK", "Annuität_NV", "Annuität_NB"]].melt(
-                                id_vars="Name",
-                                value_vars=["Annuität_NK", "Annuität_NV", "Annuität_NB"],
-                                var_name="Kostenart",
-                                value_name="Wert"
-                            )
-                            df_stacked["Kostenart"] = df_stacked["Kostenart"].replace({
-                                "Annuität_NK": "Kapitalgebundene Kosten",
-                                "Annuität_NV": "Bedarfsgebundene Kosten",
-                                "Annuität_NB": "Betriebsgebundene Kosten"
-                            })
-                            kostenart_order = ["Kapitalgebundene Kosten", "Bedarfsgebundene Kosten", "Betriebsgebundene Kosten"]
-                            df_stacked["Kostenart"] = pd.Categorical(df_stacked["Kostenart"], categories=kostenart_order, ordered=True)
-                            color_scale = alt.Scale(domain=kostenart_order, range=["#00386c", "#004c93", "#0069c8"])
-                            sortierte_names = df_einzel.sort_values("Annuität")["Name"]
+        #                 # Nach dem Buttonklick bleibt das Diagramm sichtbar, bis ein neuer Klick gemacht wird
+        #                 show_id = st.session_state["selected_objekt_id_batch_detail"]
+        #                 if show_id and show_id in annuitaeten_objekt_map:
+        #                     df_einzel = annuitaeten_objekt_map[show_id]
+        #                     df_stacked = df_einzel[["Name", "Annuität_NK", "Annuität_NV", "Annuität_NB"]].melt(
+        #                         id_vars="Name",
+        #                         value_vars=["Annuität_NK", "Annuität_NV", "Annuität_NB"],
+        #                         var_name="Kostenart",
+        #                         value_name="Wert"
+        #                     )
+        #                     df_stacked["Kostenart"] = df_stacked["Kostenart"].replace({
+        #                         "Annuität_NK": "Kapitalgebundene Kosten",
+        #                         "Annuität_NV": "Bedarfsgebundene Kosten",
+        #                         "Annuität_NB": "Betriebsgebundene Kosten"
+        #                     })
+        #                     kostenart_order = ["Kapitalgebundene Kosten", "Bedarfsgebundene Kosten", "Betriebsgebundene Kosten"]
+        #                     df_stacked["Kostenart"] = pd.Categorical(df_stacked["Kostenart"], categories=kostenart_order, ordered=True)
+        #                     color_scale = alt.Scale(domain=kostenart_order, range=["#00386c", "#004c93", "#0069c8"])
+        #                     sortierte_names = df_einzel.sort_values("Annuität")["Name"]
                     
-                            st.markdown(f"#### Annualisierte Kosten für Objekt {show_id}")
-                            st.altair_chart(
-                                alt.Chart(df_stacked)
-                                .mark_bar()
-                                .encode(
-                                    x=alt.X("Wert:Q", title="Annualisierte Kosten (€)", stack="zero"),
-                                    y=alt.Y("Name:N", title="Heizsystem", sort=list(sortierte_names)),
-                                    color=alt.Color("Kostenart:N", scale=color_scale, title="Kostenart"),
-                                    tooltip=["Name", "Kostenart", "Wert"]
-                                ).properties(height=350, width=650),
-                                use_container_width=True
-                            )
-
-                except Exception as e:
-                    st.error(f"Fehler beim Einlesen/Berechnen: {e}")
+        #                     st.markdown(f"#### Annualisierte Kosten für Objekt {show_id}")
+        #                     st.altair_chart(
+        #                         alt.Chart(df_stacked)
+        #                         .mark_bar()
+        #                         .encode(
+        #                             x=alt.X("Wert:Q", title="Annualisierte Kosten (€)", stack="zero"),
+        #                             y=alt.Y("Name:N", title="Heizsystem", sort=list(sortierte_names)),
+        #                             color=alt.Color("Kostenart:N", scale=color_scale, title="Kostenart"),
+        #                             tooltip=["Name", "Kostenart", "Wert"]
+        #                         ).properties(height=350, width=650),
+        #                         use_container_width=True
+        #                     )
+
+        #         except Exception as e:
+        #             st.error(f"Fehler beim Einlesen/Berechnen: {e}")
             
-            st.markdown("---")
-            st.caption("Berechnung nach VDI 2067, Heizsystemauswahl gemäß DIN EN 15378.")
-        else:
-            st.warning("Bitte laden Sie eine CSV-Datei hoch", icon="⚠️")
+        #     st.markdown("---")
+        #     st.caption("Berechnung nach VDI 2067, Heizsystemauswahl gemäß DIN EN 15378.")
+        # else:
+        #     st.warning("Bitte laden Sie eine CSV-Datei hoch", icon="⚠️")