From 65b6118655fd3a4a4f35b16ac344a3d863a77202 Mon Sep 17 00:00:00 2001 From: luise jedlitschka Date: Mon, 27 Feb 2023 17:45:13 +0100 Subject: [PATCH] =?UTF-8?q?class=20ergebnis=20vollst=C3=A4ndig;=20Reserver?= =?UTF-8?q?egulierungen=20erg=C3=A4nzt?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- rieter_ekalk.py | 237 ++++++++++++++++++++++++++++-------------------- 1 file changed, 139 insertions(+), 98 deletions(-) diff --git a/rieter_ekalk.py b/rieter_ekalk.py index 0ca34d6..905068b 100644 --- a/rieter_ekalk.py +++ b/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, - # "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 +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): - 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? #"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 +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.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 +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["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 ###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["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 +2551,11 @@ 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", "RSM":14, @@ -2744,10 +2813,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): @@ -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_gesamt(), 46356) - # self.assertEqual(hw.summe_in_LL(), 26432) + self.assertEqual(hw.summe_vorort(), 19923.6) + self.assertEqual(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 +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._ANZAHL.get("Spannung"), 400) + self.assertAlmostEqual(al._Anschlussspannung, 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("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 +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()