Ausgabe dictionary

rieter_ekalk.py

@@ -627,8 +627,6 @@ class Flyer_F40_EJet_inc_Putz():
         else:
             self._Mengen["RRA_BI_abhebbar"] = anzahl.get("RRA_BI_abhebbar_Korrektur", 0)
         self._Mengen["RRA_BI_abhebbar_Korrektur"] = self.mengen.get("RRA_BI_abhebbar_Korrektur", 0)
-###f bei utztex auch bei false 1 * anzahl Flyer und hier 0*...
-###f warum bei allen antrieben hier immer entweder anzahl oder korrektur abhängig von true or false entweder anzahl oder korrekturfaktor und bei utztex beides addiert? 
         self._Mengen["RRA_bi"] = self.mengen.get("RRA_bi", 0)
 
         if (anzahl.get("Single_Line_Durchfahrt", False)):
@@ -912,6 +910,7 @@ class Turm():
 
 
 class EA():   
+
     stueckzahl = {
             "schaltschrank":1,
             # "bedienstation_1fach_Not_Aus": (1, 1),
@@ -962,7 +961,7 @@ class EA():
         }
     def __init__(self, anzahl:dict, mg: type[MG]): 
         # Eingänge und Ausgänge jeder Hardwareeinheit
-        
+        self._reserve = 0.05
         self.EAs = {
             # Bedienelemente_Steuerschrank
             "Drucktaster_Anlage_AUS": (1, 0),
@@ -1109,6 +1108,11 @@ class EA():
     def __repr__(self):
         return repr(self._Anzahl)
 
+    def set_reserve(self, PS):
+        if PS > 1 or PS < 0:
+            raise Exception("Falscher Bereich")
+        self._reserve = PS
+    
 
     def gesamt_E(self):
         res = 0
@@ -1120,17 +1124,24 @@ class EA():
         for k,n in self._Anzahl.items():
             res += self.EAs[k][0] * n
         return res
-
+    def gesamt_E_incl_reserve(self):
+        return (math.ceil((self.gesamt_E() * (1 + self._reserve))))
     def gesamt_A(self):
         res = 0
         for k,n in self._Anzahl.items():
             res += self.EAs[k][1] * n
         return res
-
+    def gesamt_A_incl_reserve(self):
+        return (math.ceil((self.gesamt_A() * (1 + self._reserve))))
     def Anzahl_notwendigen_Siemens_EAKarten(self):
         SiemensS7_32DE = math.ceil(self.gesamt_E()/32)
         SiemensS7_32DA = math.ceil(self.gesamt_A()/32)
         return (SiemensS7_32DE, SiemensS7_32DA)
+    def Anzahl_Siemens_EAKarten_incl_reserve(self):
+        SiemensS7_32DE_incl_reserve = math.ceil(self.gesamt_E_incl_reserve()/32)
+        SiemensS7_32DA_incl_reserve = math.ceil(self.gesamt_A_incl_reserve()/32)
+        return (SiemensS7_32DE_incl_reserve, SiemensS7_32DA_incl_reserve)
+
 
 class HW():
             #TODO "bedienstation_1fach_Not_Aus" keine Anzahl manuelle eingabe aber dann noch bezüge in mengengerüst und hardware; muss noch eingepflegt werden
@@ -1227,8 +1238,8 @@ class HW():
         "korrektur_et200_sp_base_unit_neue_last_mit_potKlemmen":0,
         # "et200_sp_base_unit_links_gebrueckt_mit_pot_klemmen":0,
         # "et200_sp_base_unit_neue_last":0,
-        "korrektur_et200_sp_base_unit_neue_last":-15,
-        # "et200_sp_base_unit_links_gebrueckt":0,
+        "korrektur_et200_sp_base_unit_neue_last":-15, ### dann ist die anzahl aber bei -1!
+        # "et200_sp_base_unit_links_gebrueckt":0,    ### gesamtkosten müssten doch eigtl bei 11 sein oder?
         "korrektur_et200_sp_base_unit_links_gebrueckt":0,
 
         "SLIO":0,
@@ -1274,7 +1285,7 @@ class HW():
         # "kabel_fuer_klemmkasten_und_bts_60m":0,
         # "kabel_fuer_1fach_bts_zug_wechseln":0,
         # "zuleitung_75_m_unterverteiler_4x4mm2_400vac":0,
-        # "zuleitung_75_m_unterverteiler_12x4mm2_24_vdc":0,         ###m entweder "zuleitung_75_m_unterverteiler_12x4mm2_24_vdc" oder "zuleitung_75_m_unterverteiler_12x2_5mm2_24_vdc"
+        # "zuleitung_75_m_unterverteiler_12x4mm2_24_vdc":0,     ### anzahl ist -1
         "korrektur_zuleitung_75_m_unterverteiler_12x4mm2_24_vdc":-6,
         # "zuleitung_75_m_unterverteiler_12x2_5mm2_24_vdc":0,
         "korrektur_zuleitung_75_m_unterverteiler_12x2_5mm2_24_vdc": 0,
@@ -1295,7 +1306,7 @@ class HW():
         "speicherkarte_fuer_sps_512_kb": 172.5,                     # 708003012
         "sps_simatic_s7_cpu317_2_pn_dp": 3957,                    # 708003007
         "speicherkarte_fuer_sps2_mb": 246,                        # 708003027
-        "sps_simatic_s7_1515_2": 2173.5,                            # 790008100
+        "sps_simatic_s7_1515_2": 2173.9,                            # 790008100
         "sps_simatic_s7_1517_3": 3827.8,                            # 790008101
         "sps_simatic_s7_1518_4": 5892,                            # 6ES7518-4AP00-0AB0
         "sps_et200_1512sp": 705.75,                                  # 709000003
@@ -1334,7 +1345,7 @@ class HW():
         "unterverteiler_fuer_12_rsm_direct": 8258,                        # 790820302
         # korrektur_12_rsm_zusaetzlich_im_unterverteiler
 
-        "unterverteiler_fuer_8_rsm_direct": 6736,                         # 790820301
+        "unterverteiler_fuer_8_rsm_direct": 6736,                         # 790820301           ### immer 800 abgezogen? 
         # korrektur_8_rsm_zusaetzlich_im_unterverteiler
 
         "busverteiler_6_rsm_direct": 1747.53,                                # 790801002
@@ -1924,6 +1935,8 @@ class HW():
             anzahl.get("unterverteiler_fuer_8_rsm_direct", 0) +\
             anzahl.get("busverteiler_8_rsm_direct", 0) +\
             anzahl.get("korrektur_zuleitung_75_m_unterverteiler_12x2_5mm2_24_vdc", 0)
+        if self._anzahl["zuleitung_75_m_unterverteiler_12x4mm2_24_vdc"] > 0 and self._anzahl["zuleitung_75_m_unterverteiler_12x2_5mm2_24_vdc"] > 0:
+            raise Exception("12x4 and 12x2.5 mustn't be used simultanously")
         self._anzahl["korrektur_zuleitung_75_m_unterverteiler_12x2_5mm2_24_vdc"] = anzahl.get("korrektur_zuleitung_75_m_unterverteiler_12x2_5mm2_24_vdc", 0)
         if 'direct' in mg.get_deckblatt_value("SYSTEM"):
             self._anzahl["zuleitung_55_m_klemmkasten_rsm_mitte_14g1_5_mm"] = mg.get_deckblatt_value("RSM")
@@ -1970,13 +1983,16 @@ class HW():
     def summe_in_LL(self):
         res = 0
         for k,anz in self._anzahl.items():
-            if k not in self.ep:
+            if k in self.Keys_of_Vor_Ort:
                 continue
-            if k in self.Keys_of_Schaltschrank:
+            elif k not in self.ep:
+                continue
+            elif k in self.Keys_of_Schaltschrank:
                 preis = anz * self.ep[k] * self.anzahl("schaltschrank")
-            if k not in self.Keys_of_Schaltschrank and k not in self.Keys_of_Vor_Ort:
+            else:
                 preis = anz * self.ep[k]
             res += preis
+            
         return res
 
     def summe_vorort(self):
@@ -2139,7 +2155,7 @@ class HW():
 
 class Dienstleistung():
     # Angaben in h
-    mengen = {      ###m unauskommentierte alle nur bedingt änderbar
+    mengen = {     
         "Pflichtenheft_Autom_Schnittstellen": 0,
 
         ## Hardwareplanung
@@ -2203,13 +2219,13 @@ class Dienstleistung():
 
         self._Hours["Klemmkastenbau_je_2h"] = (hw.anzahl("klemmkasten_rsm") +
                                                hw.anzahl("klemmkasten_direct_in_rsm")) * 2
-        self._Hours["Bedientableaubau"] = round(hw.anzahl("bedienstation_1fach_kpl") * hw.zpe_e_werkstatt.get("bedienstation_1fach_kpl") / 60 +\
-            hw.anzahl("bedienst_2fach_wechs_bcd_10f") * hw.zpe_e_werkstatt.get("bedienst_2fach_wechs_bcd_10f") / 60 +\
-            hw.anzahl("bedienstation_2fach_kpl") * hw.zpe_e_werkstatt.get("bedienstation_2fach_kpl") / 60 +\
-            hw.anzahl("bedienstation_3fach_kpl") * hw.zpe_e_werkstatt.get("bedienstation_3fach_kpl") / 60 +\
-            hw.anzahl("bedienstation_4fach_kpl") * hw.zpe_e_werkstatt.get("bedienstation_4fach_kpl") / 60 +\
-            hw.anzahl("bedienstation_6fach_kpl") * hw.zpe_e_werkstatt.get("bedienstation_6fach_kpl") / 60 +\
-            hw.anzahl("drucktaster_automatische_umfahrung") * hw.zpe_e_werkstatt.get("drucktaster_automatische_umfahrung"), 2)
+        self._Hours["Bedientableaubau"] = hw.get_h_of("bedienstation_1fach_kpl") +\
+            hw.get_h_of("bedienst_2fach_wechs_bcd_10f")+\
+            hw.get_h_of("bedienstation_2fach_kpl") +\
+            hw.get_h_of("bedienstation_3fach_kpl") +\
+            hw.get_h_of("bedienstation_4fach_kpl") +\
+            hw.get_h_of("bedienstation_6fach_kpl") +\
+            hw.get_h_of("drucktaster_automatische_umfahrung")
         self._Hours["Vormontage_im_Haus"] = self.anzahl("Vormontage_im_Haus")
     def __repr__(self):
         return repr(self._Hours)
@@ -2221,10 +2237,10 @@ class Dienstleistung():
 
     def summe_stunden_dienstleistung_in_landsberg(self):
         """returns hours necessary"""
-        hours_necessary = self.stunden_hardwareplanung_test_installation() +\
+        hours_necessary = self.stunden_diensleistung_hardwareplanung() +\
             self.stunden_elektrowerkstatt()
         return hours_necessary
-    def stunden_hardwareplanung_test_installation(self):
+    def stunden_diensleistung_hardwareplanung(self):
         """return hours of hardware-bucheting, test and installation"""
         keys_hardwareplanung = [
             "Pflichtenheft_Autom_Schnittstellen", 
@@ -2278,6 +2294,7 @@ class EMO():
         }
     def __init__(self, ea: type[EA], hw: type[HW], mg: type[MG]):
         #für jede Zeile (Eintrag im dict 'mengen') muss ein Wert übergeben werden, der aus den Klassen HW(), MG() oder EA() stammt
+        self._mehraufwand = 0.1
         mengen = {
             "Schaltschrank_aufstellen": 0,
             "Unterverteiler_montieren": 0,
@@ -2322,7 +2339,10 @@ class EMO():
         self._Mengen["Blitzleuchte_installieren"] = ea.anzahl("Blitzleuchte_Stoerung")
         self._Mengen["Weiche_Stopper_anschliessen"] = hw.anzahl("stopper_weichenkabel_je_5m")
         self._Mengen["Erdung"] = self._Mengen.get("Unterverteiler_montieren") * 10
-
+    def set_mehraufwand(self, PS):
+        if PS > 1 or PS < 0:
+            raise Exception("Falsche Spanne")
+        self._mehraufwand = PS
     def dauer_emo(self):
         keys_tätigkeiten_1 = [
         "Unterverteiler_montieren",
@@ -2352,33 +2372,38 @@ class EMO():
         
             
         return math.ceil((keys_1 + keys_2)) 
-    def mehraufwand_emo(self):
-        return (self.dauer_emo() * 1.1)
+    def dauer_emo_incl_mehrauwand(self):
+        return (self.dauer_emo() * (1 + self._mehraufwand))
 
 class Anschlussl():
     mengen = {
         #auskommentiert, was später berechnet wird
-        "Anschlussspannung":400,    #Volt
-        "Motor_Art":0.12,    #kilo Watt
+        #"Anschlussspannung":400,    #Volt
+        "Motor_Art":0.12,    #kilo Watt             ### dasselbe wie Antrieb? und eigtl regelmäßig oder immer anders?
         #"Anzahl_Motor":48,
         "Antrieb":0.12, #kilo Watt
         "Strom_Motor":0.55,   #Ampere
         #"Summe_Strom_Motor":26.4,
-        "cos_phi":0.77,         ###m fester Wert
-        "Versorgung_SPS_und_Peripherie":3,  #Ampere
+        #"cos_phi":0.77,       
+        #"Versorgung_SPS_und_Peripherie":3,  #Ampere
         #"Summe_Strom_Motot_SPS_Peripherie":29.4,    #Ampere
         #GZE
-        "GZE_Faktor":0.5,
-        "Res_Faktor":0.1,
+        #"GZE_Faktor":0.5,
+        #"Res_Faktor":0.1,
         #Res
         #gesamtstrom
         #spannung
-        #x strom
-        "x_Wurzel_3":1.732      ###m fester Wert
+        #"x_Wurzel_3":1.732
         #leistung
         #gesamtanschlussleistung
     }
     def __init__(self, anzahl:dict, mg: type[MG]):
+        self._GZE_Faktor = 0.5
+        self._Res_Faktor = 0.1
+        self._Anschlussspannung = 400
+        self._cos_phi = 0.77            ### wird nicht verwendet
+        self._x_Wurzel_3 = 1.732
+        self._Versorgung_SPS_und_Peripherie = 3
         self._ANZAHL = anzahl
         self._ANZAHL["Anzahl_Motor"] = mg.zusammenfassung().get("RA_uni", 0) +\
              mg.zusammenfassung().get("RA_uni_abhebbar", 0) +\
@@ -2390,33 +2415,46 @@ class Anschlussl():
         self._ANZAHL["Summe_Strom_Motor"] = self.mengen.get("Strom_Motor") *\
             anzahl.get("Anzahl_Motor")
         self._ANZAHL["Summe_Strom_Motor_SPS_Peripherie"] = anzahl.get("Summe_Strom_Motor") +\
-            self.mengen.get("Versorgung_SPS_und_Peripherie")
+            self._Versorgung_SPS_und_Peripherie
         self._ANZAHL["GZF"] = anzahl.get("Summe_Strom_Motor") *\
-            self.mengen.get("GZE_Faktor") +\
-            self.mengen.get("Versorgung_SPS_und_Peripherie")
+            self._GZE_Faktor +\
+            self._Versorgung_SPS_und_Peripherie
         self._ANZAHL["Res"] = anzahl.get("GZF") *\
-            self.mengen.get("Res_Faktor")
+            self._Res_Faktor
         self._ANZAHL["Gesamtstrom"] = anzahl.get("GZF") +\
             anzahl.get("Res")
-        self._ANZAHL["Spannung"] = self.mengen.get("Anschlussspannung")
-        self._ANZAHL["x_Strom"] = anzahl.get("Gesamtstrom")
-        self._ANZAHL["Leistung"] = anzahl.get("Spannung") *\
-            anzahl.get("x_Strom") *\
-            self.mengen.get("x_Wurzel_3") / 1000
+        self._ANZAHL["Leistung"] = self._Anschlussspannung *\
+            anzahl.get("Gesamtstrom") *\
+            self._x_Wurzel_3 / 1000
         self._ANZAHL["Gesamtanschlussleistung"] = math.ceil((self._ANZAHL.get("Leistung")))
-
+    def set_Versorgung_SPS_und_Peripherie(self, Strom):
+        self._Versorgung_SPS_und_Peripherie = Strom
+    def set_x_Wurzel_3 (self, x):
+        self._x_Wurzel_3 = x
+    def set_cos_phi(self, cos):
+        self._cos_phi = cos
+    def set_Anschlussspannung(self, AS):
+        self._Anschlussspannung = AS
+    def set_GZE_Faktor(self, PS):
+        if PS > 1 or PS < 0:
+            raise Exception("Falsche Spanne")
+        self._GZE_Faktor = PS
+    def set_Res_Faktor(self, PS):
+        if PS > 1 or PS < 0:
+            raise Exception("Falsche Spanne")
+        self._Res_Faktor = PS
 class Ergebnis():           ###f was sind die grünen zahlen auf dem deckblatt?
     preis_kostenart_h = {
     "E_Werkstatt": 32,		
     "Schaltschrankbau_extern_Mehrkosten": 0,	#Wenn Schaltschrankbau extern die Mehrkosten eintragen Standard = 18 € Hier wird nur die Diverenz zwischen Kosten intern(32€) und dem externen Kosten eingetragen. Beispiel: extern = 50€  intern 32 € = Wert: 18€	
     "Dienstleistung_in_LL": 45,     #aufwandeduzierung oder mehraufwand
     "Pflichtenheft": 60,
-    "SPS_Programmierung": 75,   #aufwandreduzierung oder mehraufwand softwareerstellung		
-    "PC_Programmierung_Visualisierung": 60,		
+    "SPS_Programmierung": 75,	
+    "PC_Programmierung_Visualisierung": 75,
     "Montage_elektrisch": 36,		
     "Inbetriebnahmetest_Hardware_durch_Montage": 36,			
     "SPS_Inbetriebsetzung": 75,		
-    "PC_Inbetriebsetzung": 60,		
+    "PC_Inbetriebsetzung": 75,		
     "Inbetriebnahmeunterstützung_durch_Montage": 36,			
     "Dokumentation": 35,		
     "Bedienungsanleitung_Emmert": 75,		
@@ -2426,7 +2464,22 @@ class Ergebnis():           ###f was sind die grünen zahlen auf dem deckblatt?
     "PC_Anlagenbetreuung": 60,		
     "Anlagenbetreuung_durch_Montage": 36		
     }
+    eingaben_h = {
+        "Pflichtenheft":0,
+        "SPS_Programmierung":150,
+        "SPS_Inbetriebsetzung":130,
+        "PC_Inbetriebsetzung":0,
+        "Schulung_vor_Ort_beim_Kunden":0,
+        "Abnahme":0,
+        "SPS_Anlagenbetreuung":0,
+        "PC_Anlagenbetreuung":0,
+        "Anlagenbetreuung_durch_Montage":0
+    }
     def __init__(self, anzahl_h:dict, hw: type[HW], dl: type[Dienstleistung], emo: type[EMO]):
+        self._Anteil_Inbetriebnahmeunterstützung_durch_Montage = 1
+        self._Anteil_PC_Visualisierung_an_SPS = 0.3
+        self._Abweichung_softwareerstellung = 0
+        self._Abweichung_dienstleistung_in_LL = 0
         self._anzahl = anzahl_h
         self._anzahl["E_Werkstatt"] = dl.stunden_elektrowerkstatt()
         self._anzahl["Schaltschrankbau_extern_Mehrkosten"] = hw.get_h_of("unterverteiler_fuer_1neuenhauser_pm") +\
@@ -2437,22 +2490,38 @@ class Ergebnis():           ###f was sind die grünen zahlen auf dem deckblatt?
             hw.get_h_of("unterverteiler_fuer_puffer") +\
             hw.get_h_of("unterverteiler_fuer_10_rsm_fa") +\
             hw.get_h_of("unterverteiler_fuer_3_rsm_fa_mit_umfahrung_steckbar")
-        self._anzahl["Dienstleistung_in_LL"] = dl.stunden_hardwareplanung_test_installation()
-        self._anzahl["Pflichtenheft"] = 0 ###f immer 0?
-        self._anzahl["SPS_Programmierung"] = 0 ###f immer reduziert?
-        self._anzahl["PC_Programmierung_Visualisierung"] = 0 ###f immer reduziert?
-        self._anzahl["Montage_elektrisch"] = emo.mehraufwand_emo() ###f mehraufwand einzeln nötig oder reicht am Schluss zur Übersichtlichkeit?
+        self._anzahl["Dienstleistung_in_LL"] = dl.stunden_diensleistung_hardwareplanung() * (1 + self._Abweichung_dienstleistung_in_LL)
+        self._anzahl["Pflichtenheft"] = self.eingaben_h.get("Pflichtenheft")
+        self._anzahl["SPS_Programmierung"] = self.eingaben_h.get("SPS_Programmierung") * (1 + self._Abweichung_softwareerstellung)
+        self._anzahl["PC_Programmierung_Visualisierung"] = anzahl_h.get("SPS_Programmierung") * self._Anteil_PC_Visualisierung_an_SPS
+        self._anzahl["Montage_elektrisch"] = emo.dauer_emo_incl_mehrauwand()
         self._anzahl["Inbetriebnahmetest_Hardware_durch_Montage"] = anzahl_h.get("Montage_elektrisch") * 0.1
-        self._anzahl["SPS_Inbetriebsetzung"] = 130 ###f immer 130 oder immer extra anzugeben? Lässt sich das evtl vereinfachen?
-        self._anzahl["PC_Inbetriebsetzung"] = 0 ###f immer 0 oder immer manuell anzuegebn?
-        self._anzahl["Inbetriebnahmeunterstützung_durch_Montage"] = anzahl_h.get("SPS_Inbetriebsetzung") * 1 ###f prozentualer anteil der inbetriebnahmeunterstützung durch montage###f bei PC Progammierung auch % wird aber nicht verwendet; absicht?
+        self._anzahl["SPS_Inbetriebsetzung"] = self.eingaben_h.get("SPS_Inbetriebsetzung")
+        self._anzahl["PC_Inbetriebsetzung"] = self.eingaben_h.get("PC_Inbetriebsetzung")
+        self._anzahl["Inbetriebnahmeunterstützung_durch_Montage"] = anzahl_h.get("SPS_Inbetriebsetzung") * self._Anteil_Inbetriebnahmeunterstützung_durch_Montage
         self._anzahl["Dokumentation"] = dl.get_hours_of("Bedienerhandbuch")
         self._anzahl["Bedienungsanleitung_Emmert"] = dl.get_hours_of("SPS_Doku")
-        self._anzahl["Schulung_vor_Ort_beim_Kunden"] = 0 ###f immer manuell?
-        self._anzahl["Abnahme"] = 0 ###f immer manuell?
-        self._anzahl["SPS_Anlagenbetreuung"] = 0 ###f immer manuell?
-        self._anzahl["PC_Anlagenbetreuung"] = 0 ###f immer manuell?
-        self._anzahl["Anlagenbetreuung_durch_Montage"] = 0 ###f immer manuell?
+        self._anzahl["Schulung_vor_Ort_beim_Kunden"] = self.eingaben_h.get("Schulung_vor_Ort_beim_Kunden")
+        self._anzahl["Abnahme"] = self.eingaben_h.get("Abnahme")
+        self._anzahl["SPS_Anlagenbetreuung"] = self.eingaben_h.get("SPS_Anlagenbetreuung")
+        self._anzahl["PC_Anlagenbetreuung"] = self.eingaben_h.get("PC_Anlagenbetreuung")
+        self._anzahl["Anlagenbetreuung_durch_Montage"] = self.eingaben_h.get("Anlagenbetreuung_durch_Montage")
+    def set_Abweichung_dienstleistung_in_LL(self, PS):
+        if PS > 1 :
+            raise Exception("Falsche Spanne")
+        self._Abweichung_dienstleistung_in_LL = PS
+    def set_Abweichung_softwareerstellung(self, PS):
+        if PS > 1:
+            raise Exception("Falsche Spanne")
+        self._Abweichung_softwareerstellung = PS
+    def set_Anteil_PC_Visualisierung_an_SPS(self, Anteil):
+        if Anteil > 1 or Anteil < 0:
+            raise Exception("Falsche Spanne")
+        self._Anteil_PC_Visualisierung_an_SPS = Anteil
+    def set_Anteil_Inbetriebnahmeunterstützung_durch_Montage(self, Anteil):
+        if Anteil > 1 or Anteil < 0:
+            raise Exception("Falsche Spanne")
+        self._Anteil_Inbetriebnahmeunterstützung_durch_Montage = Anteil
     def get_sum_of_costs(self, hw: type[HW]):
         keys_costs = {
         "E_Werkstatt",		
@@ -2481,12 +2550,40 @@ class Ergebnis():           ###f was sind die grünen zahlen auf dem deckblatt?
         return (res + hw.summe_vorort() + hw.summe_in_LL())
     def get_cost_of(self, partname):
         return (self._anzahl.get(partname) * self.preis_kostenart_h.get(partname))
+    def summary_costs(self, hw):
+        summary = {}
+        keys_costs = {
+        "E_Werkstatt",		
+        "Schaltschrankbau_extern_Mehrkosten",		
+        "Dienstleistung_in_LL",		
+        "Pflichtenheft",		
+        "SPS_Programmierung",	
+        "PC_Programmierung_Visualisierung",
+        "Montage_elektrisch",		
+        "Inbetriebnahmetest_Hardware_durch_Montage",	
+        "SPS_Inbetriebsetzung", 		
+        "PC_Inbetriebsetzung",		
+        "Inbetriebnahmeunterstützung_durch_Montage",
+        "Dokumentation",		
+        "Bedienungsanleitung_Emmert",		
+        "Schulung_vor_Ort_beim_Kunden",		
+        "Abnahme",
+        "SPS_Anlagenbetreuung",		
+        "PC_Anlagenbetreuung",		
+        "Anlagenbetreuung_durch_Montage"		
+            }    
+        for k in keys_costs:
+            cost = self._anzahl[k] * self.preis_kostenart_h[k]
+            summary.update({k: round(cost, 2)})
+        summary.update({"Installationsmaterial_vor_Ort": round(hw.summe_vorort(), 2)})
+        summary.update({"Material_in_LL": round(hw.summe_in_LL(), 2)})
+        summary.update({"GESAMT": round(self.get_sum_of_costs(hw), 2)})
+        print(summary)
+
 class TestObjectMethods(unittest.TestCase):
     
     def test_eas(self):
-        # eas.gesamt_E()
-        # eas.gesamt_A()
-        
+
         Anzahl_MG = {
                     "SYSTEM": "FA",
                     "RSM":14,
@@ -2744,10 +2841,18 @@ class TestObjectMethods(unittest.TestCase):
         self.assertEqual(eas.gesamt_E(), 152)
         self.assertEqual(eas.gesamt_A(), 216)
 
+        self.assertEqual(eas.gesamt_E_incl_reserve(), 160)
+        self.assertEqual(eas.gesamt_A_incl_reserve(), 227)
+
         self.assertEqual(eas.get_SEA('Frequenzumrichter'), (0, 0))
         (eingänge, ausgänge) = eas.Anzahl_notwendigen_Siemens_EAKarten()
         self.assertEqual(eingänge, 5)
         self.assertEqual(ausgänge, 7)
+
+        (eingänge, ausgänge) = eas.Anzahl_Siemens_EAKarten_incl_reserve()
+        self.assertEqual(eingänge, 5)
+        self.assertEqual(ausgänge, 8)
+
    
     def test_HW(self):
             
@@ -2979,7 +3084,6 @@ class TestObjectMethods(unittest.TestCase):
         Anzahl_AL ={}
         al =  Anschlussl(Anzahl_AL, mg)
 
-
         self.assertEqual(hw.anzahl("schaltschrankgehaeuse_b1x1200_zubehoer"), 0)
         self.assertEqual(hw.anzahl("schaltschrankgehaeuse_b2x800_zubehoer"), 0)
         self.assertEqual(hw.anzahl("schaltschrankgehaeuse_b1x1200+1x800_zubehoer"), 1)
@@ -3112,9 +3216,9 @@ class TestObjectMethods(unittest.TestCase):
         self.assertEqual(hw.anzahl("korrektur_profinetkabel"), 0)
         self.assertEqual(hw.anzahl("schnittstellen_8x1mm2_30m"), 4)
 
-        self.assertAlmostEqual(hw.summe_vorort(), 19923.6)
-    #        self.assertEqual(hw.summe_gesamt(), 46356)
-    #        self.assertEqual(hw.summe_in_LL(), 26432)
+        self.assertEqual(hw.summe_vorort(), 19923.6)
+        self.assertAlmostEqual(hw.summe_gesamt(), 47167.04)
+        self.assertEqual(hw.summe_in_LL(), 27243.44)
         self.assertEqual(hw.summe_h_zeiten_hardwareplanung(), 167.0)
         self.assertEqual(hw.summe_h_unterverteiler_e_werkstatt(), 94.0)
     
@@ -3327,27 +3431,9 @@ class TestObjectMethods(unittest.TestCase):
         Anzahl_HW = {}
 
         hw =  HW(Anzahl_HW, mg, eas)
-        emo_eingabe = {
-                "Schaltschrank_aufstellen": 1,
-                "Unterverteiler_montieren": 4,
-                "Pritsche_montieren_umbauen_demontieren": 66,
-                "Pritsche_in_RSM_montieren": 0,
-                "Motor_verdrahten_und_anschliessen": 97,
-                "Tableau_befestigen_und_anschliessen": 15,
-                "Schnittstelle_Flyer_Putzmaschine": 1,
-                "Sensoren_montieren": 84,
-                "Seilzugschalter_installieren": 0,
-                "Blitzleuchte_installieren": 3,
-                "Weiche_Stopper_anschliessen": 244,
-                "Erdung": 40,
-                }
         emo =  EMO(eas, hw, mg)
-        Anzahl_DL = {}
-        dl =  Dienstleistung(Anzahl_DL, hw)
-        Anzahl_AL ={}
-        al =  Anschlussl(Anzahl_AL, mg)
         self.assertAlmostEqual(emo.dauer_emo(), 241)
-        self.assertAlmostEqual(emo.mehraufwand_emo(), 265.1)
+        self.assertAlmostEqual(emo.dauer_emo_incl_mehrauwand(), 265.1)
         
     def test_dienstleistung(self):
         Anzahl_MG = {
@@ -3578,9 +3664,9 @@ class TestObjectMethods(unittest.TestCase):
         dl =  Dienstleistung(Anzahl_DL, hw)
         Anzahl_AL ={}
         al =  Anschlussl(Anzahl_AL, mg)
-        self.assertEqual(dl.stunden_hardwareplanung_test_installation(), 225.1)
-        self.assertEqual(dl.stunden_elektrowerkstatt(), 196.83)
-        self.assertEqual(dl.summe_stunden_dienstleistung_in_landsberg(), 421.93)
+        self.assertEqual(dl.stunden_diensleistung_hardwareplanung(), 225.1)
+        self.assertEqual(dl.stunden_elektrowerkstatt(), 196.83333333333333333333333333)
+        self.assertEqual(dl.summe_stunden_dienstleistung_in_landsberg(), 421.9333333333333333333)
         self.assertEqual(dl.get_hours_of("Pflichtenheft_Autom_Schnittstellen"), 0)
         self.assertEqual(dl.get_hours_of("Erstellung_Steuerungslayout"), 41.75)
         self.assertEqual(dl.get_hours_of("Schaltplanerstellung_incl_Korrekturen"), 100.2)
@@ -3597,7 +3683,7 @@ class TestObjectMethods(unittest.TestCase):
         self.assertEqual(dl.get_hours_of("Schaltschrankbau"), 88)
         self.assertEqual(dl.get_hours_of("Unterverteilerbau"), 94)
         self.assertEqual(dl.get_hours_of("Klemmkastenbau_je_2h"), 4)
-        self.assertEqual(dl.get_hours_of("Bedientableaubau"), 10.83)
+        self.assertEqual(dl.get_hours_of("Bedientableaubau"), 10.833333333333333)
         self.assertEqual(dl.get_hours_of("Vormontage_im_Haus"), 0)
 
     def test_anschlussleistung(self):
@@ -3810,23 +3896,6 @@ class TestObjectMethods(unittest.TestCase):
         Anzahl_HW = {}
 
         hw =  HW(Anzahl_HW, mg, eas)
-        emo_eingabe = {
-                "Schaltschrank_aufstellen": 1,
-                "Unterverteiler_montieren": 4,
-                "Pritsche_montieren_umbauen_demontieren": 66,
-                "Pritsche_in_RSM_montieren": 0,
-                "Motor_verdrahten_und_anschliessen": 97,
-                "Tableau_befestigen_und_anschliessen": 15,
-                "Schnittstelle_Flyer_Putzmaschine": 1,
-                "Sensoren_montieren": 84,
-                "Seilzugschalter_installieren": 0,
-                "Blitzleuchte_installieren": 3,
-                "Weiche_Stopper_anschliessen": 244,
-                "Erdung": 40,
-                }
-        emo =  EMO(eas, hw, mg)
-        Anzahl_DL = {}
-        dl =  Dienstleistung(Anzahl_DL, hw)
         Anzahl_AL ={}
         al =  Anschlussl(Anzahl_AL, mg)
         self.assertEqual(al._ANZAHL.get("Anzahl_Motor"), 48)
@@ -3835,8 +3904,7 @@ class TestObjectMethods(unittest.TestCase):
         self.assertAlmostEqual(al._ANZAHL.get("GZF"), 16.2)
         self.assertAlmostEqual(al._ANZAHL.get("Res"), 1.62)
         self.assertAlmostEqual(al._ANZAHL.get("Gesamtstrom"), 17.82)
-        self.assertAlmostEqual(al._ANZAHL.get("x_Strom"), 17.82)
-        self.assertAlmostEqual(al._ANZAHL.get("Spannung"), 400)
+        self.assertAlmostEqual(al._Anschlussspannung, 400)
         self.assertAlmostEqual(al._ANZAHL.get("Leistung"), 12.345696)
         self.assertAlmostEqual(al._ANZAHL.get("Gesamtanschlussleistung"), 13)
        
@@ -4056,12 +4124,12 @@ class TestObjectMethods(unittest.TestCase):
         dl =  Dienstleistung(Anzahl_DL, hw)
         Anzahl_Ergebnis = {}
         erg = Ergebnis(Anzahl_Ergebnis, hw, dl, emo)
-        self.assertAlmostEqual(erg.get_cost_of("E_Werkstatt"), 6298.56)
+        self.assertAlmostEqual(erg.get_cost_of("E_Werkstatt"), 6298.6666666666667)
         self.assertEqual(erg.get_cost_of("Schaltschrankbau_extern_Mehrkosten"), 0)
         self.assertEqual(erg.get_cost_of("Dienstleistung_in_LL"), 10129.5)
         self.assertEqual(erg.get_cost_of("Pflichtenheft"), 0)
-        #self.assertEqual(erg.get_cost_of("SPS_Programmierung"), )      ###f die Gesamtkosten hier sind mauell einzugeben, warum werden sie nicht wie die anderen mit Stundensatz und Gesamtstunden berechnet? Lässt sich das irgendwie verallgemeinern? noch einzupflegen
-        #self.assertEqual(erg.get_cost_of("PC_Programmierung_Visualisierung"), )		###f bezieht sich nicht auf Stundensatz sondern auf mauell einzugebenden Prozentsatz von "SPS_Programmierung"; noch einzupflegen 
+        self.assertEqual(erg.get_cost_of("SPS_Programmierung"), 11250)
+        self.assertEqual(erg.get_cost_of("PC_Programmierung_Visualisierung"), 3375)		
         self.assertEqual(erg.get_cost_of("Montage_elektrisch"), 9543.6)
         self.assertAlmostEqual(erg.get_cost_of("Inbetriebnahmetest_Hardware_durch_Montage"), 954.36)
         self.assertEqual(erg.get_cost_of("SPS_Inbetriebsetzung"), 9750)
@@ -4074,7 +4142,8 @@ class TestObjectMethods(unittest.TestCase):
         self.assertEqual(erg.get_cost_of("SPS_Anlagenbetreuung"), 0)
         self.assertEqual(erg.get_cost_of("PC_Anlagenbetreuung"), 0)
         self.assertEqual(erg.get_cost_of("Anlagenbetreuung_durch_Montage"), 0)
-        self.assertEqual(erg.get_sum_of_costs(hw), 103957)
+        self.assertEqual(erg.get_sum_of_costs(hw), 104833.16666666666)
+        erg.summary_costs(hw)
 
 def test_Unittests():
     unittest.main()

test_jayjay.py

@@ -293,7 +293,7 @@ class TestObjectMethods(unittest.TestCase):
         self.assertEqual(mg.get_value_of_object('puffer', 'Hauptschalter_Ein-Meldung_Korrektur'), 0)
 
         zf = mg.zusammenfassung()
-        #self.assertEqual(zf['Gesamtanzahl_Antriebe'], 44)
+        self.assertEqual(zf['Gesamtanzahl_Antriebe'], 44)
         self.assertEqual(zf['Sensor_optisch_Traverse'], 68)
         self.assertEqual(zf['Sensor_induktiv_Spulenalter_Zug_positionierung'], 4)
         self.assertEqual(zf['Sensor_Spulenprüfung_voll_leer'], 0)

utztex_group.py

@@ -507,7 +507,7 @@ class RSM_FA():
             self._Mengen["Mit_Drucktaster"] = 0
         self._Mengen["Mit_Drucktaster_Korrektur"] = anzahl.get("Mit_Drucktaster_Korrektur",0)
         self._Mengen["Meldelampe_Überstrom"] = math.ceil(anzahl.get("Anzahl_RSM", 0)/3) + anzahl.get("Meldelampe_Überstrom_Korrektur", 0)
-        self._Mengen["Meldelampe_Überstrom_Korrektur"] = anzahl.get("Meldelampe_Überstrom_Korrektur", 0) ###f bei jayjay durch 10 statt 3... generelle änderung oder immer manuell?
+        self._Mengen["Meldelampe_Überstrom_Korrektur"] = anzahl.get("Meldelampe_Überstrom_Korrektur", 0)
         self._Mengen["Hauptschalter_Ein_Meldung"] = math.ceil(anzahl.get("Anzahl_RSM", 0)/3) + anzahl.get("Hauptschalter_Ein-Meldung_Korrektur", 0)
         self._Mengen["Hauptschalter_Ein-Meldung_Korrektur"] = anzahl.get("Hauptschalter_Ein-Meldung_Korrektur", 0)
         self._Mengen["Werma_Rundumleuchte_Störung"] = math.ceil(anzahl.get("Anzahl_RSM", 0)/10) + anzahl.get("Werma_Rundumleuchte_Störung_Korrektur", 0)
@@ -588,7 +588,7 @@ class Flyer_F40_EJet_inc_Putz():
             sensorfaktor_nachpuffer = 5
         self._Mengen["Sensor_optisch_Traverse"] = self._Flyer_Anzahl * (self._Mengen.get("Anzahl_Schienen", 0) + sensorfaktor_nachpuffer) + anzahl.get("Dreifachweiche", 0) * 2 + anzahl.get("Sensor_optisch_Traverse_Korrektur", 0)
         self._Mengen["Sensor_optisch_Traverse_Korrektur"] = self.mengen.get("Sensor_optisch_Traverse_Korrektur", 0)
-        self._Mengen["Sensor_induktiv_Spulenhalter"] = self._Flyer_Anzahl * 1 + anzahl.get("Sensor_induktiv_Spulenhalter_Korrektur", 0) ###f bei jayjay * 2
+        self._Mengen["Sensor_induktiv_Spulenhalter"] = self._Flyer_Anzahl * 1 + anzahl.get("Sensor_induktiv_Spulenhalter_Korrektur", 0) 
         self._Mengen["Sensor_induktiv_Spulenhalter_Korrektur"] = self.mengen.get("Sensor_induktiv_Spulenhalter_Korrektur", 0)
         self._Mengen["Bedientableau_2fach"] = self._Flyer_Anzahl + anzahl.get("Bedientableau_2fach_Korrektur", 0)
         self._Mengen["Bedientableau_2fach_Korrektur"] = self.mengen.get("Bedientableau_2fach_Korrektur", 0)
@@ -1274,7 +1274,7 @@ class HW():
         # "kabel_fuer_klemmkasten_und_bts_60m":0,
         # "kabel_fuer_1fach_bts_zug_wechseln":0,
         # "zuleitung_75_m_unterverteiler_4x4mm2_400vac":0,
-        # "zuleitung_75_m_unterverteiler_12x4mm2_24_vdc":0,         ###m entweder "zuleitung_75_m_unterverteiler_12x4mm2_24_vdc" oder "zuleitung_75_m_unterverteiler_12x2_5mm2_24_vdc"
+        # "zuleitung_75_m_unterverteiler_12x4mm2_24_vdc":0,       
         "korrektur_zuleitung_75_m_unterverteiler_12x4mm2_24_vdc":0,
         # "zuleitung_75_m_unterverteiler_12x2_5mm2_24_vdc":0,
         "korrektur_zuleitung_75_m_unterverteiler_12x2_5mm2_24_vdc": 0,
@@ -1556,7 +1556,7 @@ class HW():
         "schnittstellen_8x1mm2_30m"
     ]
     Keys_of_Schaltschrank = [
-        "schaltschrankgehaeuse_b1x1200_zubehoer",        ###f bezug zu anzahl schaltschrank?
+        "schaltschrankgehaeuse_b1x1200_zubehoer",        
         "schaltschrankgehaeuse_b2x800_zubehoer",
         "schaltschrankgehaeuse_b1x1200+1x800_zubehoer",
         "sps_simatic_s7_cpu315_2_pn_dp",
@@ -1924,6 +1924,8 @@ class HW():
             anzahl.get("unterverteiler_fuer_8_rsm_direct", 0) +\
             anzahl.get("busverteiler_8_rsm_direct", 0) +\
             anzahl.get("korrektur_zuleitung_75_m_unterverteiler_12x2_5mm2_24_vdc", 0)
+        if self._anzahl["zuleitung_75_m_unterverteiler_12x4mm2_24_vdc"] > 0 and self._anzahl["zuleitung_75_m_unterverteiler_12x2_5mm2_24_vdc"] > 0:
+            raise Exception("12x4 and 12x2.5 mustn't be used simultanously")
         self._anzahl["korrektur_zuleitung_75_m_unterverteiler_12x2_5mm2_24_vdc"] = anzahl.get("korrektur_zuleitung_75_m_unterverteiler_12x2_5mm2_24_vdc", 0)
         if 'direct' in mg.get_deckblatt_value("SYSTEM"):
             self._anzahl["zuleitung_55_m_klemmkasten_rsm_mitte_14g1_5_mm"] = mg.get_deckblatt_value("RSM")
@@ -2139,7 +2141,7 @@ class HW():
 
 class Dienstleistung():
     # Angaben in h
-    mengen = {      ###m unauskommentierte alle nur bedingt änderbar
+    mengen = {      
         "Pflichtenheft_Autom_Schnittstellen": 0,
 
         ## Hardwareplanung
@@ -2364,7 +2366,7 @@ class Anschlussl():
         "Antrieb":0.12, #kilo Watt
         "Strom_Motor":0.55,   #Ampere
         #"Summe_Strom_Motor":26.4,
-        "cos_phi":0.77,         ###m fester Wert
+        "cos_phi":0.77,   
         "Versorgung_SPS_und_Peripherie":3,  #Ampere
         #"Summe_Strom_Motot_SPS_Peripherie":29.4,    #Ampere
         #GZE
@@ -2374,7 +2376,7 @@ class Anschlussl():
         #gesamtstrom
         #spannung
         #x strom
-        "x_Wurzel_3":1.732      ###m fester Wert
+        "x_Wurzel_3":1.732 
         #leistung
         #gesamtanschlussleistung
     }