Bereichsklasse fertiggestellt, damit lässt sich nun ein Json File ausgeben, um die Ergebnisse mit der Excel-Tabelle abzugleichen

.gitignore

@@ -152,3 +152,6 @@ cython_debug/
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
 #.idea/
 
+#json output
+Bereichszusammenfassung.json
+

ils_kalk.py

@@ -1,3 +1,4 @@
+import json
 import math
 import unittest
 
@@ -10,9 +11,9 @@ from numpy import array
 # BT Beladung, MT Beladung, Zuführung Klinkenförderer) zusammengefasst. Zusätzlicher Aufschlag für 30° Ausschleuselement/Einschleuselement
 class Kreisel():
     #standardkreisel ohne pin/rampe, bei Bedarf als Parameter übergeben
-    def __init__(self, anzahl, bezeichnung, laenge, anzahl_weichen, anzahl_separatoren, anzahl_scanner, pin=False, anzahl_rampen=0):
+    def __init__(self, bezeichnung, anzahl, laenge, anzahl_weichen, anzahl_separatoren, anzahl_scanner, pin=False, anzahl_rampen=0):
-        self.anzahl = anzahl
         self.bezeichnung = bezeichnung
+        self.anzahl = anzahl
         self.laenge = laenge
         self.pin = pin #bool
         self.anzahl_rampen = anzahl_rampen
@@ -22,9 +23,9 @@ class Kreisel():
 
 class Gefaellestrecke():
     #standardgefällestrecke ohne 30° EE/AE, bei Bedarf als Parameter übergeben
-    def __init__(self, anzahl, bezeichnung, laenge, anzahl_separatoren, anzahl_scanner, einschleuselement_30_grad=False, ausschleuselement_30_grad=False):
+    def __init__(self, bezeichnung, anzahl, laenge, anzahl_separatoren, anzahl_scanner, einschleuselement_30_grad=False, ausschleuselement_30_grad=False):
-        self.anzahl = anzahl
         self.bezeichnung = bezeichnung
+        self.anzahl = anzahl
         self.laenge = laenge #TODO: minimum, maximum?
         self.anzahl_separatoren = anzahl_separatoren
         self.anzahl_scanner = anzahl_scanner
@@ -32,9 +33,9 @@ class Gefaellestrecke():
         self.ausschleuselement_30_grad = ausschleuselement_30_grad #bool
 
 class Bereich():
-    def __init__(self, bezeichnung, kreisel:list[Kreisel], gefaellestrecken:list[Gefaellestrecke], anzahl_etagenfoerderer=0, anzahl_bt_mt_entladung=0,
+    def __init__(self,bezeichnung, kreisel:list[Kreisel], gefaellestrecken:list[Gefaellestrecke],anzahl_eckraeder=0, anzahl_etagenfoerderer=0, anzahl_bt_mt_entladung=0,
-    anzahl_bt_beladung=0, anzahl_mt_beladung=0, anzahl_zufuehrung_klinkenf=0,):
+    anzahl_bt_beladung=0, anzahl_mt_beladung=0, anzahl_zufuehrung_klinkenf=0, laenge_zufuehrung_klinkenf=0):
-        self.bezeichnung = bezeichnung
+        self._bezeichnung = bezeichnung
         #für jede instanz der kreiselklasse in der Liste 'kreisel' muss ein Materialpreis und Montagestunden berechnet werden
         #Äquivalent dazu Gefällestrecken, ETF, So-Förderer und Umbügeln berechnen
 
@@ -48,25 +49,105 @@ class Bereich():
 
         # BaaN => Montagezeit und Herstellkosten einzelner Baugruppen
         b = BaaN()
-        self.hk_mech_el = 0
+        self._kreisel = {}
-        self.mont_mech_el = 0
+        kreisel_hk_mech_el_summe = 0
+        kreisel_mont_mech_el_summe = 0
         for k in kreisel:
             pin = 0
             if(k.pin == True): pin = 1
-            self.hk_mech_el += k.anzahl * (b.herstellkosten_mech_el("ANTRIEBSSTATION_800_ILS_20_(mit_Motor)") + b.herstellkosten_mech_el("SPANNSTATION_800_ILS_20") +\
+            kreisel_hk_mech_el = k.anzahl * (b.herstellkosten_mech_el("ANTRIEBSSTATION_800_ILS_20_(mit_Motor)") + b.herstellkosten_mech_el("SPANNSTATION_800_ILS_20") +\
                                     k.laenge * b.herstellkosten_mech_el("1_Meter_Kreisel_LP_20") + pin*k.laenge*b.herstellkosten_mech_el("Zusatzaufwand_für_Meter_Pinband") +\
                                     k.anzahl_rampen * b.herstellkosten_mech_el("Rampe_li_u_re_incl_LPhc_u_Zappler") + k.anzahl_weichen * b.herstellkosten_mech_el("Weiche_ILS_20") +\
                                     k.anzahl_separatoren * b.herstellkosten_mech_el("Sep_LP_ILS_20_(SMC)") + k.anzahl_scanner * b.herstellkosten_mech_el("SCANNER_FÜR_SEPARATOR") +\
                                     pin * b.herstellkosten_mech_el("Inkrementalgeber"))
 
-            self.mont_mech_el += k.anzahl * (b.montagestunden_mech_el("ANTRIEBSSTATION_800_ILS_20_(mit_Motor)") + b.montagestunden_mech_el("SPANNSTATION_800_ILS_20") +\
+            kreisel_mont_mech_el = k.anzahl * (b.montagestunden_mech_el("ANTRIEBSSTATION_800_ILS_20_(mit_Motor)") + b.montagestunden_mech_el("SPANNSTATION_800_ILS_20") +\
                                     k.laenge * b.montagestunden_mech_el("1_Meter_Kreisel_LP_20") + pin*k.laenge*b.montagestunden_mech_el("Zusatzaufwand_für_Meter_Pinband") +\
                                     k.anzahl_rampen * b.montagestunden_mech_el("Rampe_li_u_re_incl_LPhc_u_Zappler") + k.anzahl_weichen * b.montagestunden_mech_el("Weiche_ILS_20") +\
                                     k.anzahl_separatoren * b.montagestunden_mech_el("Sep_LP_ILS_20_(SMC)") + k.anzahl_scanner * b.montagestunden_mech_el("SCANNER_FÜR_SEPARATOR") +\
                                     pin * b.montagestunden_mech_el("Inkrementalgeber"))
             
+            kreisel_hk_mech_el_summe += kreisel_hk_mech_el
+            kreisel_mont_mech_el_summe += kreisel_mont_mech_el
+            self._kreisel[k.bezeichnung] ={"hk_summe": round(kreisel_hk_mech_el,2), "mont_summe": round(kreisel_mont_mech_el/60, 2)}
+
+        self._kreisel["_GESAMT_"] = {"hk_summe": round(kreisel_hk_mech_el_summe,2), "mont_summe": round(kreisel_mont_mech_el_summe/60,2)}
+
+        #TODO: Eckrad Montagestundenberechnung => *1.5?
+        self._eckraeder = {"hk_summe": round(anzahl_eckraeder*(b.herstellkosten_mech_el("ANTRIEBSSTATION_800_ILS_20_(mit_Motor)")),2), "mont_summe": round((anzahl_eckraeder*b.montagestunden_mech_el("ANTRIEBSSTATION_800_ILS_20_(mit_Motor)")*1.5)/60,2)}
+
+        # =D17*(Tabellen!J3+E17*Tabellen!L3+I17*Tabellen!M3+J17*Tabellen!R3)
+        # = Anzahl * (AE+EE                 + Länge *   mSP         + Separatoren * Sep         + Scanner   *   ScanSep)
+        # =           =BaaN!G19+BaaN!G20                =BaaN!G13                   =BaaN!G15                   =BaaN!G16
+        # Aufschlag AE/EE 30°: =BaaN!C24-BaaN!C19
+        gefaelle_hk_mech_el_summe = 0
+        gefaelle_mont_mech_el_summe = 0
+        self._gefaellestrecken = {}
+        for g in gefaellestrecken:
+            hkAE = b.herstellkosten_mech_el("AE_ILS_20_(SMC)")
+            montAE = b.montagestunden_mech_el("AE_ILS_20_(SMC)")
+            hkEE = b.herstellkosten_mech_el("EE")
+            montEE = b.montagestunden_mech_el("EE")
+
+            #TODO: Zusatzaufwand für 30° EE/AE bezieht sich ausschließlich auf Differenz zwischen Material mechanik(HK) zwischen AE und AE30°
+            #TODO: Montagezeit korrekt, allerdings wird für die Berechnung von Einschleuselementen ebenfalls Zahlen der AS verwendet
+            #TODO: keine Montagezeiten elektrik für AE/EE 30°!
+            # Hier: Berechnung entweder auf Grundlage von standard AE/EE oder mit 30° aus Klasse Baan()
+            if(g.ausschleuselement_30_grad):
+                hkAE = b.herstellkosten_mech_el("AS_ELEMENT_30_MIT_SMC_PNEUMATIK_F_SF_ILS")
+                montAE = b.montagestunden_mech_el("AS_ELEMENT_30_MIT_SMC_PNEUMATIK_F_SF_ILS")
+            if(g.einschleuselement_30_grad):
+                hkEE = b.herstellkosten_mech_el("ES_ELEMENT_30_F_SF_ILS")
+                montEE = b.montagestunden_mech_el("ES_ELEMENT_30_F_SF_ILS")
+
+            gefaelle_hk_mech_el = g.anzahl * (hkAE + hkEE + g.laenge * b.herstellkosten_mech_el("SP_ILS_20") +\
+                                    g.anzahl_separatoren * b.herstellkosten_mech_el("Sep_SP_HD_ILS_20_(SMC)") + g.anzahl_scanner *  b.herstellkosten_mech_el("SCANNER_FÜR_SEPARATOR"))
+
+            gefaelle_mont_mech_el = g.anzahl * (montAE + montEE + g.laenge * b.montagestunden_mech_el("SP_ILS_20") +\
+                                    g.anzahl_separatoren * b.montagestunden_mech_el("Sep_SP_HD_ILS_20_(SMC)") + g.anzahl_scanner *  b.montagestunden_mech_el("SCANNER_FÜR_SEPARATOR"))
+            gefaelle_hk_mech_el_summe += gefaelle_hk_mech_el
+            gefaelle_mont_mech_el_summe += gefaelle_mont_mech_el
+            self._gefaellestrecken[g.bezeichnung] = {"hk_summe": round(gefaelle_hk_mech_el,2), "mont_summe": round(gefaelle_mont_mech_el/60, 2)}
+
+        self._gefaellestrecken["_GESAMT_"] = {"hk_summe": round(gefaelle_hk_mech_el_summe,2), "mont_summe": round(gefaelle_mont_mech_el_summe/60,2)}
+        #Etagenförderer
+        etf_hk_mech_el = anzahl_etagenfoerderer * b.herstellkosten_mech_el("ETF_6m_Zw_Träger_ILS_20")
+        etf_mont_mech_el = anzahl_etagenfoerderer * b.montagestunden_mech_el("ETF_6m_Zw_Träger_ILS_20")
+        self._etagenfoerderer = {"hk_summe": round(etf_hk_mech_el,2), "mont_summe": round(etf_mont_mech_el/60,2)}
         #TODO: so-förderer
-        #TODO: tabellen -> baugruppen -> preise
+
+        #Umbügeln
+        self._btmt_entladung = {"hk_summe": round(anzahl_bt_mt_entladung * b.herstellkosten_mech_el("BT_MT_Entladg"),2), "mont_summe": round((anzahl_bt_mt_entladung*b.montagestunden_mech_el("BT_MT_Entladg"))/60,2)}
+        self._bt_beladung = {"hk_summe": round(anzahl_bt_beladung * b.herstellkosten_mech_el("BT_Beladg"),2), "mont_summe": round((anzahl_bt_beladung * b.montagestunden_mech_el("BT_Beladg"))/60,2)}
+        self._mt_beladung = {"hk_summe": round(anzahl_mt_beladung * b.herstellkosten_mech_el("MT_Beladg"),2), "mont_summe": round((anzahl_mt_beladung * b.montagestunden_mech_el("MT_Beladg"))/60,2)}
+        #zuführung klinkenförderer=D37*Tabellen!E62+D37*E37*Tabellen!F62 TODO: Keine Artikel hinterlegt, ausschließlich Zahlenwerte -> Überprüfen
+        # Klinkenförderer: Antrieb = 920, E-Material = 200, proMeter = 160, MontageAntrieb = 3(h), MontageMeter = 1(h)
+        self._zufuehrung_cpc = {"hk_summe": round(anzahl_zufuehrung_klinkenf * (920 + laenge_zufuehrung_klinkenf),2), "mont_summe": round((anzahl_zufuehrung_klinkenf * (3 + laenge_zufuehrung_klinkenf * 1))/60,2)}
+
+
+
+    def getResult(self):
+        res = {
+        "Kreisel": self._kreisel,
+        "Eckraeder": self._eckraeder,
+        "Gefaellestrecken": self._gefaellestrecken,
+        "Etagenfoerderer": self._etagenfoerderer,
+        "BTMT_Entladung": self._btmt_entladung,
+        "BT_Beladung": self._bt_beladung,
+        "MT_Beladung": self._mt_beladung,
+        "Zufuehrung_Klinke": self._zufuehrung_cpc,
+        }
+        return res
+
+    def tojson(self, input:dict):
+        return json.dumps(input, sort_keys=False, indent=4)
+
+    def resToFile(self):
+        json = self.tojson(self.getResult())
+        fname = "Bereich_" + self._bezeichnung + ".json"
+        with open("Bereichszusammenfassung.json", "w") as file:
+            file.write(json)
+
 
 
 class BaaN():
@@ -129,11 +210,25 @@ class TestObjects(unittest.TestCase):
         self.assertEqual(baan.herstellkosten_el("ES_ELEMENT_30_F_SF_ILS"), 45.7)
         self.assertEqual(baan.montagestunden_el("ES_ELEMENT_30_F_SF_ILS"), 0)
 
-        einschleusung_puffer = Kreisel(6, "Einschleusung Puffer", 10, 0,2,1,True,2)
+        
-        bereich = Bereich("Puffer", [einschleusung_puffer], [])
+        zufuehrung_puffer = Kreisel("Zufuehrung Richtung Puffer",2, 30, 4,4,4)
-        h = bereich.mont_mech_el/60
+        verbindung = Kreisel("Verbindung",3,4,0,0,0)
-        self.assertEqual(h, 294)
+        einschleusung_puffer = Kreisel("Einschleusung Puffer",6, 10, 0,2,1,True,2)
-        self.assertEqual(round(bereich.hk_mech_el, 1), 36501.6)
+        abzug_puffer = Kreisel("Abzug Puffer",6,10,1,2,2)
+        abzug_gesamt = Kreisel("Abzug Gesamt",2,33.5,5,3,0)
+
+        umschleusung_puffer = Gefaellestrecke("Umschleusung",6, 10,2,0)
+
+        puffer = Bereich("Puffer",[zufuehrung_puffer, verbindung, einschleusung_puffer, abzug_puffer, abzug_gesamt], [umschleusung_puffer],12, 6)
+        puffer.resToFile()
+        #minuten in stunden umrechnen
+        #self.assertEqual(puffer._kreisel["mont_summe"]/60, 294)
+        #self.assertEqual(puffer._gefaellestrecken["mont_summe"]/60, 45.5)
+        #self.assertEqual(round(puffer._kreisel["hk_summe"], 1), 36501.6)
+        #self.assertEqual(round(puffer._gefaellestrecken["hk_summe"], 1), 6166.2)
+        #self.assertEqual(round(puffer._etagenfoerderer["hk_summe"], 1), 16914)
+        #self.assertEqual(round(puffer._etagenfoerderer["mont_summe"]/60, 1), 84.0)
+