class ergebnis vollständig; Reserveregulierungen ergänzt

rieter_ekalk.py

@@ -912,6 +912,7 @@ class Turm():
 
 
 class EA():   
+
     stueckzahl = {
             "schaltschrank":1,
             # "bedienstation_1fach_Not_Aus": (1, 1),
@@ -962,7 +963,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 +1110,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 +1126,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 +1240,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,
+        "korrektur_et200_sp_base_unit_neue_last":-15, ### dann ist die anzahl aber bei -1!
-        # "et200_sp_base_unit_links_gebrueckt":0,
+        # "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 +1287,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,
@@ -1334,7 +1347,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 +1937,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,11 +1985,13 @@ 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
@@ -2139,7 +2156,7 @@ class HW():
 
 class Dienstleistung():
     # Angaben in h
-    mengen = {      ###m unauskommentierte alle nur bedingt änderbar
+    mengen = {     
         "Pflichtenheft_Autom_Schnittstellen": 0,
 
         ## Hardwareplanung
@@ -2221,10 +2238,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 +2295,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 +2340,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 +2373,38 @@ class EMO():
         
             
         return math.ceil((keys_1 + keys_2)) 
-    def mehraufwand_emo(self):
+    def dauer_emo_incl_mehrauwand(self):
-        return (self.dauer_emo() * 1.1)
+        return (self.dauer_emo() * (1 + self._mehraufwand))
 
 class Anschlussl():
     mengen = {
         #auskommentiert, was später berechnet wird
-        "Anschlussspannung":400,    #Volt
+        #"Anschlussspannung":400,    #Volt
-        "Motor_Art":0.12,    #kilo Watt
+        "Motor_Art":0.12,    #kilo Watt             ### dasselbe wie Antrieb? 
         #"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
+        #"cos_phi":0.77,       
-        "Versorgung_SPS_und_Peripherie":3,  #Ampere
+        #"Versorgung_SPS_und_Peripherie":3,  #Ampere
         #"Summe_Strom_Motot_SPS_Peripherie":29.4,    #Ampere
         #GZE
-        "GZE_Faktor":0.5,
+        #"GZE_Faktor":0.5,
-        "Res_Faktor":0.1,
+        #"Res_Faktor":0.1,
         #Res
         #gesamtstrom
         #spannung
-        #x strom
+        #"x_Wurzel_3":1.732
-        "x_Wurzel_3":1.732      ###m fester Wert
         #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 +2416,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._GZE_Faktor +\
-            self.mengen.get("Versorgung_SPS_und_Peripherie")
+            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["Leistung"] = self._Anschlussspannung *\
-        self._ANZAHL["x_Strom"] = anzahl.get("Gesamtstrom")
+            anzahl.get("Gesamtstrom") *\
-        self._ANZAHL["Leistung"] = anzahl.get("Spannung") *\
+            self._x_Wurzel_3 / 1000
-            anzahl.get("x_Strom") *\
-            self.mengen.get("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		
+    "SPS_Programmierung": 75,	
-    "PC_Programmierung_Visualisierung": 60,		
+    "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 +2465,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 +2491,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["Dienstleistung_in_LL"] = dl.stunden_diensleistung_hardwareplanung() * (1 + self._Abweichung_dienstleistung_in_LL)
-        self._anzahl["Pflichtenheft"] = 0 ###f immer 0?
+        self._anzahl["Pflichtenheft"] = self.eingaben_h.get("Pflichtenheft")
-        self._anzahl["SPS_Programmierung"] = 0 ###f immer reduziert?
+        self._anzahl["SPS_Programmierung"] = self.eingaben_h.get("SPS_Programmierung") * (1 + self._Abweichung_softwareerstellung)
-        self._anzahl["PC_Programmierung_Visualisierung"] = 0 ###f immer reduziert?
+        self._anzahl["PC_Programmierung_Visualisierung"] = anzahl_h.get("SPS_Programmierung") * self._Anteil_PC_Visualisierung_an_SPS
-        self._anzahl["Montage_elektrisch"] = emo.mehraufwand_emo() ###f mehraufwand einzeln nötig oder reicht am Schluss zur Übersichtlichkeit?
+        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["SPS_Inbetriebsetzung"] = self.eingaben_h.get("SPS_Inbetriebsetzung")
-        self._anzahl["PC_Inbetriebsetzung"] = 0 ###f immer 0 oder immer manuell anzuegebn?
+        self._anzahl["PC_Inbetriebsetzung"] = self.eingaben_h.get("PC_Inbetriebsetzung")
-        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["Inbetriebnahmeunterstützung_durch_Montage"] = anzahl_h.get("SPS_Inbetriebsetzung") * self._Anteil_Inbetriebnahmeunterstützung_durch_Montage ###f prozentualer anteil der inbetriebnahmeunterstützung durch montage###f bei PC Progammierung auch % wird aber nicht verwendet; absicht?
         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["Schulung_vor_Ort_beim_Kunden"] = self.eingaben_h.get("Schulung_vor_Ort_beim_Kunden")
-        self._anzahl["Abnahme"] = 0 ###f immer manuell?
+        self._anzahl["Abnahme"] = self.eingaben_h.get("Abnahme")
-        self._anzahl["SPS_Anlagenbetreuung"] = 0 ###f immer manuell?
+        self._anzahl["SPS_Anlagenbetreuung"] = self.eingaben_h.get("SPS_Anlagenbetreuung")
-        self._anzahl["PC_Anlagenbetreuung"] = 0 ###f immer manuell?
+        self._anzahl["PC_Anlagenbetreuung"] = self.eingaben_h.get("PC_Anlagenbetreuung")
-        self._anzahl["Anlagenbetreuung_durch_Montage"] = 0 ###f immer manuell?
+        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,11 +2551,10 @@ 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))
+
 class TestObjectMethods(unittest.TestCase):
     
     def test_eas(self):
-        # eas.gesamt_E()
-        # eas.gesamt_A()
 
         Anzahl_MG = {
                     "SYSTEM": "FA",
@@ -2744,11 +2813,19 @@ 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):
             
         Anzahl_MG = {
@@ -3112,9 +3189,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_vorort(), 19923.6)
-    #        self.assertEqual(hw.summe_gesamt(), 46356)
+        self.assertEqual(hw.summe_gesamt(), 47167.04)
-    #        self.assertEqual(hw.summe_in_LL(), 26432)
+        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 +3404,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,7 +3637,7 @@ 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_diensleistung_hardwareplanung(), 225.1)
         self.assertEqual(dl.stunden_elektrowerkstatt(), 196.83)
         self.assertEqual(dl.summe_stunden_dienstleistung_in_landsberg(), 421.93)
         self.assertEqual(dl.get_hours_of("Pflichtenheft_Autom_Schnittstellen"), 0)
@@ -3810,23 +3869,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 +3877,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._Anschlussspannung, 400)
-        self.assertAlmostEqual(al._ANZAHL.get("Spannung"), 400)
         self.assertAlmostEqual(al._ANZAHL.get("Leistung"), 12.345696)
         self.assertAlmostEqual(al._ANZAHL.get("Gesamtanschlussleistung"), 13)
        
@@ -4060,8 +4101,8 @@ class TestObjectMethods(unittest.TestCase):
         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("SPS_Programmierung"), 11250)
-        #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("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 +4115,7 @@ 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.17)
 
 def test_Unittests():
     unittest.main()