From fc70111a02a9057195ee14af09bbac45203c3210 Mon Sep 17 00:00:00 2001 From: Simon Schmutzler Date: Wed, 6 Apr 2022 17:29:06 +0200 Subject: [PATCH] =?UTF-8?q?Klassen=20f=C3=BCr=20Kreisel=20und=20Gef=C3=A4l?= =?UTF-8?q?lestrecken=20hinzugef=C3=BCgt,=20mit=20diesen=20in=20der=20Klas?= =?UTF-8?q?se=20'Bereich'=20Montagestunden=20und=20Herstellkosten=20aufsum?= =?UTF-8?q?miert=20werden?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ils_kalk.py | 113 +++++++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 108 insertions(+), 5 deletions(-) diff --git a/ils_kalk.py b/ils_kalk.py index f62bcf1..b14fe13 100644 --- a/ils_kalk.py +++ b/ils_kalk.py @@ -1,14 +1,18 @@ import math -from typing_extensions import Self import unittest +from numpy import array + #In einem 'Bereich' in der Kalkulationsübersicht werden verwendete Baugruppen nach örtlichen # oder logischen Kriterien der Anlage zusammengefasst #Innerhalb eines Bereichs werden Baugruppen mit Übergabeparametern (Kreisel, Gefällestrecke) und ohne Übergabeparametern (Eckrad, ETF, BT/MT Entladung, # BT Beladung, MT Beladung, Zuführung Klinkenförderer) zusammengefasst. Zusätzlicher Aufschlag für 30° Ausschleuselement/Einschleuselement class Kreisel(): - def __init__(self, laenge, pin, anzahl_rampen, anzahl_weichen, anzahl_separatoren, anzahl_scanner): + #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): + self.anzahl = anzahl + self.bezeichnung = bezeichnung self.laenge = laenge self.pin = pin #bool self.anzahl_rampen = anzahl_rampen @@ -17,22 +21,121 @@ class Kreisel(): self.anzahl_scanner = anzahl_scanner class Gefaellestrecke(): - def __init__(self, laenge, anzahl_separatoren, anzahl_scanner, einschleuselement_30_grad, ausschleuselement_30_grad): - self.laenge = laenge + #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): + self.anzahl = anzahl + self.bezeichnung = bezeichnung + self.laenge = laenge #TODO: minimum, maximum? self.anzahl_separatoren = anzahl_separatoren self.anzahl_scanner = anzahl_scanner self.einschleuselement_30_grad = einschleuselement_30_grad #bool self.ausschleuselement_30_grad = ausschleuselement_30_grad #bool class Bereich(): - def __init__(self, kreisel:list, gefaellestrecken:list, anzahl_etagenfoerderer, anzahl_bt_mt_entladung, anzahl_bt_beladung, anzahl_mt_beladung, anzahl_zufuehrung_klinkenf,): + def __init__(self, bezeichnung, kreisel:list[Kreisel], gefaellestrecken:list[Gefaellestrecke], anzahl_etagenfoerderer=0, anzahl_bt_mt_entladung=0, + anzahl_bt_beladung=0, anzahl_mt_beladung=0, anzahl_zufuehrung_klinkenf=0,): + 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 + + #Summe aller Baugruppen eines Kreisel + # Materialpreis mech+el=D3*( Tabellen!C3 + E3*Tabellen!D3 + F3*E3*Tabellen!E3 + G3*Tabellen!F3 + H3*Tabellen!H3 + I3*Tabellen!I3 + J3*Tabellen!R3 + F3*Tabellen!G3) + # Anzahl_Kreisel*((PreisAntr+Spannstation) + Länge*PreismKreisel + Pin*Länge*Aufpr.Pin + Rampen*PreisRampe + Weichen*PreisWeiche + Separatoren*PreisSepLP + Scanner*PreisScanSep + Pin*PreisInkGeber) + # Anzahl_Kreisel*((=BaaN!G3+BaaN!G5) + Länge*(=BaaN!G8) + Pin*Länge*(=BaaN!G10) + Rampen*(=BaaN!G11) + Weichen*(=BaaN!G12) + Separatoren*(=BaaN!G14) + Scanner*(=BaaN!G16) + Pin*(=BaaN!E29)) + + # Montagestunden + # =D3*( Tabellen!C30 + E3*Tabellen!D30 + F3*E3*Tabellen!E30 + G3*Tabellen!F30 + H3*Tabellen!H30 + I3*Tabellen!I30 + J3*Tabellen!R30 + F3*Tabellen!G30) + + # BaaN => Montagezeit und Herstellkosten einzelner Baugruppen + b = BaaN() + self.hk_mech_el = 0 + self.mont_mech_el = 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") +\ + 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") +\ + 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")) + #TODO: so-förderer #TODO: tabellen -> baugruppen -> preise +class BaaN(): + def __init__(self): + self._Kosten = { + #[HK mechanik, Montage mechanik(min), HK elektrik, Montage elektrik(min)] + "ANTRIEBSSTATION_800_ILS_20_(mit_Motor)":[1580,360,233,240], + "SPANNSTATION_800_ILS_20":[1110,360,24,120], + "1_Meter_Kreisel_LP_20":[75,90,0,0], + "Zusatzaufwand_für_Meter_Pinband":[3,30,0,0], + "Rampe_li_u_re_incl_LPhc_u_Zappler":[202,60,76.3,45], + "Weiche_ILS_20":[225,60,52.2,30], + "SP_ILS_20":[22,20,0,0], + "Sep_LP_ILS_20_(SMC)":[206,45,109,60], + "Sep_SP_HD_ILS_20_(SMC)":[217,45,53.1,30], + "SCANNER_FÜR_SEPARATOR":[0,0,740,60], + "HANDSCANNER_FÜR_WARE":[0,0,1860,60], + "SCANNER_FÜR_WARE_AUTOMATISCH":[0,0,7470,120], + "AE_ILS_20_(SMC)":[152,45,47.5,30], + "EE":[68,30,0,0], + "BT_MT_Entladg":[450,180,65,120], + "BT_Beladg":[1075,240,1125,120], + "MT_Beladg":[1300,240,277,120], + "AS_ELEMENT_30_MIT_SMC_PNEUMATIK_F_SF_ILS":[300,180,55.7,0], + "ES_ELEMENT_30_F_SF_ILS":[240,180,45.7,0], + "ETF_6m_Zw_Träger_ILS_20":[2750,720,69,120], + "Inkrementalgeber":[0,0,430,180], + } + + def herstellkosten_mech(self, artikelbezeichnung): + l = self._Kosten.get(artikelbezeichnung, [0,0,0,0]) + return l[0] + + def montagestunden_mech(self, artikelbezeichnung): + l = self._Kosten.get(artikelbezeichnung, [0,0,0,0]) + return l[1] + + def herstellkosten_el(self, artikelbezeichnung): + l = self._Kosten.get(artikelbezeichnung, [0,0,0,0]) + return l[2] + + def montagestunden_el(self, artikelbezeichnung): + l = self._Kosten.get(artikelbezeichnung, [0,0,0,0]) + return l[3] + + def herstellkosten_mech_el(self, artikelbezeichnung): + l = self._Kosten.get(artikelbezeichnung, [0,0,0,0]) + return l[0] + l[2] + + def montagestunden_mech_el(self, artikelbezeichnung): + l = self._Kosten.get(artikelbezeichnung, [0,0,0,0]) + return l[1] + l[3] + class TestObjects(unittest.TestCase): def test(self): self.assertEqual(1,1) + baan = BaaN() + self.assertEqual(baan.herstellkosten_mech("ES_ELEMENT_30_F_SF_ILS"), 240) + self.assertEqual(baan.montagestunden_mech("ES_ELEMENT_30_F_SF_ILS"), 180) + 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], []) + h = bereich.mont_mech_el/60 + self.assertEqual(h, 294) + self.assertEqual(round(bereich.hk_mech_el, 1), 36501.6) + + if __name__ == '__main__': unittest.main() \ No newline at end of file