From 78e5e7084a7405b691326c2a112b47a5f6c625fa Mon Sep 17 00:00:00 2001 From: Simon Schmutzler Date: Thu, 11 Aug 2022 08:18:58 +0200 Subject: [PATCH] =?UTF-8?q?Zusatzaufwand=20f=C3=BCr=20Taschen=20wurde=20in?= =?UTF-8?q?=20BaaN=20Klasse=20=C3=BCbertragen,=20um=20alle=20Informationen?= =?UTF-8?q?=20der=20Baugruppen=20dort=20zu=20sammeln.=20Anpassung=20in=20d?= =?UTF-8?q?er=20Anordnung?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ils_kalk.py | 258 +++++++++++++++++++++++++++++++++------------------- 1 file changed, 166 insertions(+), 92 deletions(-) diff --git a/ils_kalk.py b/ils_kalk.py index b9e3335..1a10cbc 100644 --- a/ils_kalk.py +++ b/ils_kalk.py @@ -55,6 +55,9 @@ class Bereich(): "Separator_LP": 0, "Separator_SP": 0, "Ausschleuselement": 0, + "Ausschleuselement_30": 0, + "Einschleuselement": 0, + "Einschleuselement_30": 0, "BTMT_Entladung": 0, "BT_Beladung": 0, "MT_Beladung": 0, @@ -79,7 +82,9 @@ class Bereich(): self.bauteile["Scanner"] += k.anzahl_scanner pin = 0 - if(k.pin == True): pin = 1 + if(k.pin == True): + pin = 1 + self.bauteile["Inkrementalgeber"] += k.anzahl #für jeden Kreisel mit Pinband wird ein Inkrementalgeber gerechnet 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") +\ @@ -113,8 +118,12 @@ class Bereich(): #TODO: Ausschleuselement 30° wird hier nicht addiert? if(g.ausschleuselement_30_grad == False): self.bauteile["Ausschleuselement"] += g.anzahl - - + else: + self.bauteile["Ausschleuselement_30"] += g.anzahl + if(g.einschleuselement_30_grad == False): + self.bauteile["Einschleuselement"] += g.anzahl + else: + self.bauteile["Einschleuselement_30"] += g.anzahl hkAE = b.herstellkosten_mech_el("AE_ILS_20_(SMC)") @@ -209,77 +218,6 @@ class Bereich(): with open("Bereichszusammenfassung.json", "w") as file: file.write(json) -class Taschen(): - def __init__(self, baugruppensummen:type[dict]): - #Zusatzbauteile die für Taschentransport erforderlich sind - - self._Zusatzbauteile = { - #"Bezeichnung":[Einzelpreis, Montagedauer(h)], Teilenummer - "Fuehrung_an_AE": [22.0, 0.1], #829514073 - "Halter_Gegenleiste_an_AE": [0.6, 0.02], #829514071 - "Aluwinkel_40x20": [2.6, 0.02], #931011103 - "Halter_Gegenleiste_an_EE": [2.6, 0.02], #829514070 - "Alu_4kt_20x20": [4.7, 0.1], #931601003 - - "Rollenandruckleiste_Sep_LP": [45.0, 0.05], #829534007 - "Abhebeleiste_Sep_LP": [89.0, 0.5], #829534008 - "Zwangsfuehrung_Sep_SP": [34.0, 0.1], #829514072 - #Schrägkreisel und Noppenband wird nicht übernommen, da nicht mehr verwendet - } - self._Summen = { - #"Bezeichnung":[Summe Preis, Summe Montagedauer] - "Fuehrung_an_AE": [0, 0], #829514073 - "Halter_Gegenleiste_an_AE": [0, 0], #829514071 - "Aluwinkel_40x20": [0, 0], #931011103 - "Halter_Gegenleiste_an_EE": [0, 0], #829514070 - "Alu_4kt_20x20": [0, 0], #931601003 - - "Rollenandruckleiste_Sep_LP": [0, 0], #829534007 - "Abhebeleiste_Sep_LP": [0, 0], #829534008 - "Zwangsfuehrung_Sep_SP": [0, 0], #829514072 - } - - #Gesamtanzahl von AE, Sep_LP, Sep_SP und Scanner auslesen - - - summe_ausschleuselement = baugruppensummen.get("Ausschleuselement", 0) - summe_sepLP_scanner = baugruppensummen.get("Separator_LP", 0) + baugruppensummen.get("Scanner", 0) - summe_sepSP = baugruppensummen.get("Separator_SP", 0) - self._Summen["Fuehrung_an_AE"] = [round(self._Zusatzbauteile.get("Fuehrung_an_AE", [])[0] * summe_ausschleuselement,2), - round(self._Zusatzbauteile.get("Fuehrung_an_AE", [])[1] * summe_ausschleuselement,2)] - self._Summen["Halter_Gegenleiste_an_AE"] = [round(self._Zusatzbauteile.get("Halter_Gegenleiste_an_AE", [])[0] * summe_ausschleuselement,2), - round(self._Zusatzbauteile.get("Halter_Gegenleiste_an_AE", [])[1] * summe_ausschleuselement,2)] - self._Summen["Aluwinkel_40x20"] = [round(self._Zusatzbauteile.get("Aluwinkel_40x20", [])[0] * summe_ausschleuselement,2), - round(self._Zusatzbauteile.get("Aluwinkel_40x20", [])[1] * summe_ausschleuselement,2)] - self._Summen["Halter_Gegenleiste_an_EE"] = [round(self._Zusatzbauteile.get("Halter_Gegenleiste_an_EE", [])[0] * summe_ausschleuselement,2), - round(self._Zusatzbauteile.get("Halter_Gegenleiste_an_EE", [])[1] * summe_ausschleuselement,2)] - self._Summen["Alu_4kt_20x20"] = [round(self._Zusatzbauteile.get("Alu_4kt_20x20", [])[0] * summe_ausschleuselement, 2), - round(self._Zusatzbauteile.get("Alu_4kt_20x20", [])[1] * summe_ausschleuselement, 2)] - - self._Summen["Rollenandruckleiste_Sep_LP"] = [round(self._Zusatzbauteile.get("Rollenandruckleiste_Sep_LP", [])[0] * summe_sepLP_scanner * 0.2,2), #TODO: warum mit 0.2 multipliziert? - round(self._Zusatzbauteile.get("Rollenandruckleiste_Sep_LP", [])[1] * summe_sepLP_scanner * 0.2,2)] - self._Summen["Abhebeleiste_Sep_LP"] = [round(self._Zusatzbauteile.get("Abhebeleiste_Sep_LP", [])[0] * summe_sepLP_scanner * 0.2,2), - round(self._Zusatzbauteile.get("Abhebeleiste_Sep_LP", [])[1] * summe_sepLP_scanner * 0.2,2)] - self._Summen["Zwangsfuehrung_Sep_SP"] = [round(self._Zusatzbauteile.get("Zwangsfuehrung_Sep_SP", [])[0] * summe_sepSP * 0.5, 2), - round(self._Zusatzbauteile.get("Zwangsfuehrung_Sep_SP", [])[1] * summe_sepSP * 0.5, 2)] - - print(self._Summen) - - -class Deckblatt(): - def __init__(self, bereiche:type[list[Bereich]], taschentransport=False): - #zusatzbauteile/Aufwand wenn Taschen im System laufen - if(taschentransport): - i=0 - #Summe aller Baugruppen über alle Bereiche - self._Baugruppensummen = {} - for b in bereiche: - t = b.getBauteile() - t_count = Counter(t) - bgr_summen_count = Counter(self._Baugruppensummen) - sum_dict = t_count + bgr_summen_count - self._Baugruppensummen = dict(sum_dict) - class BaaN(): def __init__(self): @@ -309,21 +247,17 @@ class BaaN(): } self._Taschen = { - #zusatzaufwand, wenn Taschen im System laufen - # [Preis, Montagezeit] - "829514073_Führg_an_AE": [22.0,1], - "829514071_Halter_Gegenl_an_AE": [0.6, 0.02], - "931011103_Alu_Winkel_40x20": [2.6, 0.02], - "829514070_Halter_Gegenl_an_EE": [2.6, 0.02], - "931601003_Alu_4_kt_20x20": [4.7, 0.1], - "829534007_Andr_Rollenl_Sep_LP": [45, 0.05], - "829534008_Abh_Leiste_vor_Sep_LP": [89, 0.5], - "829514072_Zwangsführg_an_Sep_SP": [34, 0.1], - "829514068_Verb_Schrägkr_Mitte": [6.8, 0.02], - "829514069_Verb_Schrägkr_Ende": [11.4, 0.02], - "829514061_Rampe": [57, 0.1], - "829416031_Stauprofil": [14.5, 0.05], - "LP_oben_abschneiden": [1, 0], #Arbeitsgang + #"Bezeichnung":[Einzelpreis, Montagedauer(h)], Teilenummer + "Fuehrung_an_AE": [22.0, 0.1], #829514073 + "Halter_Gegenleiste_an_AE": [0.6, 0.02], #829514071 + "Aluwinkel_40x20": [2.6, 0.02], #931011103 + "Halter_Gegenleiste_an_EE": [2.6, 0.02], #829514070 + "Alu_4kt_20x20": [4.7, 0.1], #931601003 + + "Rollenandruckleiste_Sep_LP": [45.0, 0.05], #829534007 + "Abhebeleiste_Sep_LP": [89.0, 0.5], #829534008 + "Zwangsfuehrung_Sep_SP": [34.0, 0.1], #829514072 + #Schrägkreisel und Noppenband wird nicht übernommen, da nicht mehr verwendet #"829514075_Abstands_Band_Nop": [2.15, 0.01], #nicht mehr verwendet #"Aufpreis_Band_noppen": [0.6, 0] #nicht mehr verwendet } @@ -352,6 +286,126 @@ class BaaN(): l = self._Kosten.get(artikelbezeichnung, [0,0,0,0]) return l[1] + l[3] + +class Taschen(): + def __init__(self, baugruppensummen:type[dict]): + #Zusatzbauteile die für Taschentransport erforderlich sind + baan = BaaN() + + self._Summen = { + #"Bezeichnung":[Summe Preis, Summe Montagedauer] + "Fuehrung_an_AE": [0, 0], #829514073 + "Halter_Gegenleiste_an_AE": [0, 0], #829514071 + "Aluwinkel_40x20": [0, 0], #931011103 + "Halter_Gegenleiste_an_EE": [0, 0], #829514070 + "Alu_4kt_20x20": [0, 0], #931601003 + "Rollenandruckleiste_Sep_LP": [0, 0], #829534007 + "Abhebeleiste_Sep_LP": [0, 0], #829534008 + "Zwangsfuehrung_Sep_SP": [0, 0], #829514072 + } + self._Mengen = { + #"Bezeichnung":[Anzahl/Meter], Teilenummer + "Fuehrung_an_AE": 0, #829514073 + "Halter_Gegenleiste_an_AE": 0, #829514071 + "Aluwinkel_40x20": 0, #931011103 (Meter) + "Halter_Gegenleiste_an_EE": 0, #829514070 + "Alu_4kt_20x20": 0, #931601003 (Meter) + "Rollenandruckleiste_Sep_LP": 0, #829534007 + "Abhebeleiste_Sep_LP": 0, #829534008 + "Zwangsfuehrung_Sep_SP": 0, #829514072 + } + + #Gesamtanzahl von AE (standard & 30°), Sep_LP, Sep_SP und Scanner auslesen + def getAusschleuselemente(): + sum = 0 + sum += baugruppensummen.get("Ausschleuselement", 0) + sum += baugruppensummen.get("Ausschleuselement_30", 0) + return sum + + summe_ausschleuselement = getAusschleuselemente() + summe_sepLP = baugruppensummen.get("Separator_LP", 0) + summe_scanner =baugruppensummen.get("Scanner", 0) + summe_sepSP = baugruppensummen.get("Separator_SP", 0) + + self._Mengen["Fuehrung_an_AE"] = summe_ausschleuselement + self._Mengen["Halter_Gegenleiste_an_AE"] = summe_ausschleuselement + self._Mengen["Aluwinkel_40x20"] = summe_ausschleuselement + self._Mengen["Halter_Gegenleiste_an_EE"] = summe_ausschleuselement + self._Mengen["Alu_4kt_20x20"] = summe_ausschleuselement + self._Mengen["Rollenandruckleiste_Sep_LP"] = math.ceil(summe_sepLP * 0.2 + summe_scanner) #aufrunden auf ganzzahliges Ergebnis + self._Mengen["Abhebeleiste_Sep_LP"] = math.ceil(summe_sepLP * 0.2 + summe_scanner) #aufrunden auf ganzzahliges Ergebnis + self._Mengen["Zwangsfuehrung_Sep_SP"] = math.ceil(summe_sepSP * 0.5) #aufrunden auf ganzzahliges Ergebnis + + self._Summen["Fuehrung_an_AE"] = [round(baan._Taschen.get("Fuehrung_an_AE", [])[0] * summe_ausschleuselement,2), + round(baan._Taschen.get("Fuehrung_an_AE", [])[1] * summe_ausschleuselement,2)] + + self._Summen["Halter_Gegenleiste_an_AE"] = [round(baan._Taschen.get("Halter_Gegenleiste_an_AE", [])[0] * summe_ausschleuselement,2), + round(baan._Taschen.get("Halter_Gegenleiste_an_AE", [])[1] * summe_ausschleuselement,2)] + + self._Summen["Aluwinkel_40x20"] = [round(baan._Taschen.get("Aluwinkel_40x20", [])[0] * summe_ausschleuselement,2), + round(baan._Taschen.get("Aluwinkel_40x20", [])[1] * summe_ausschleuselement,2)] + self._Summen["Halter_Gegenleiste_an_EE"] = [round(baan._Taschen.get("Halter_Gegenleiste_an_EE", [])[0] * summe_ausschleuselement,2), + round(baan._Taschen.get("Halter_Gegenleiste_an_EE", [])[1] * summe_ausschleuselement,2)] + self._Summen["Alu_4kt_20x20"] = [round(baan._Taschen.get("Alu_4kt_20x20", [])[0] * summe_ausschleuselement, 2), + round(baan._Taschen.get("Alu_4kt_20x20", [])[1] * summe_ausschleuselement, 2)] + + self._Summen["Rollenandruckleiste_Sep_LP"] = [round(baan._Taschen.get("Rollenandruckleiste_Sep_LP", [])[0] * (summe_sepLP * 0.2 + summe_scanner),2), #TODO: warum mit 0.2 multipliziert? + round(baan._Taschen.get("Rollenandruckleiste_Sep_LP", [])[1] * (summe_sepLP * 0.2 + summe_scanner),2)] + self._Summen["Abhebeleiste_Sep_LP"] = [round(baan._Taschen.get("Abhebeleiste_Sep_LP", [])[0] * (summe_sepLP * 0.2 + summe_scanner),2), + round(baan._Taschen.get("Abhebeleiste_Sep_LP", [])[1] * (summe_sepLP * 0.2 + summe_scanner),2)] + self._Summen["Zwangsfuehrung_Sep_SP"] = [round(baan._Taschen.get("Zwangsfuehrung_Sep_SP", [])[0] * summe_sepSP * 0.5, 2), + round(baan._Taschen.get("Zwangsfuehrung_Sep_SP", [])[1] * summe_sepSP * 0.5, 2)] + + def get_mengen(self): + return self._Mengen + + def get_summen(self): + return self._Summen + +class Mengen(): + def __init__(self, bereiche:type[list[Bereich]]): + self._Bereiche = bereiche + self._Baugruppenmengen = {} + + #Summe aller Baugruppen über alle Bereiche + for b in self._Bereiche: + t = b.getBauteile() + t_count = Counter(t) + bgr_summen_count = Counter(self._Baugruppenmengen) + sum_dict = t_count + bgr_summen_count + self._Baugruppenmengen = dict(sum_dict) + + #TODO: Methoden in Kreisel und Bereichsklassen erstellen, um Mengen zurückzugeben und hier aufzusummieren + + + def get_mengen(self): + return self._Baugruppenmengen + +class Steuerung(): + def __init__(self): + pass + +class Deckblatt(): + def get_baugruppen_mengen(self): + return self._Mengen.get_mengen() + def get_taschenzusatz_mengen(self): + return self._Taschen.get_mengen() + def get_taschenzusatz_summen(self): + return self._Taschen.get_summen() + + def __init__(self, bereiche:type[list[Bereich]], taschentransport=False): + self._Bereiche = bereiche + self._Mengen = Mengen(bereiche) + self._Taschen = Taschen(self.get_baugruppen_mengen()) + + #zusatzbauteile/Aufwand wenn Taschen im System laufen + if(taschentransport): + i=0 + + + + + class TestObjects(unittest.TestCase): def test(self): baan = BaaN() @@ -366,16 +420,36 @@ class TestObjects(unittest.TestCase): kreisel.append(Kreisel("Einschleusung Puffer",6, 10, 0,2,1,True,2)) kreisel.append(Kreisel("Abzug Puffer",6,10,1,2,2)) kreisel.append(Kreisel("Abzug Gesamt",2,33.5,5,3,0)) - + gefaellestrecken = [] gefaellestrecken.append(Gefaellestrecke("Umschleusung",6, 10,2,0)) gefaellestrecken.append(Gefaellestrecke("Puffer", 72, 21,2,0)) + gefaellestrecken.append(Gefaellestrecke("Überführung", 1, 18,1,0,1,1)) puffer = Bereich("Puffer",kreisel, gefaellestrecken,12, 6) puffer.resToFile() + + deckb = Deckblatt([puffer]) + print(deckb.get_taschenzusatz_mengen()) + print(deckb.get_taschenzusatz_summen()) + #print(deckb._Taschen._Summen) + #print(deckb.get_baugruppen_mengen()) - dblatt = Deckblatt([puffer, puffer]) - taschen = Taschen(dblatt._Baugruppensummen) + + + + def test_taschen(self): + #Test des Zusatzaufwands für Taschen, als Input zunächst Dict mit in der Klasse 'Taschen' verwendeten Baugruppen + baugruppen = {'Separator_LP': 57, 'Separator_SP': 200, 'Ausschleuselement': 120, 'Scanner': 34} + res = Taschen(baugruppen)._Summen + self.assertEqual(res["Fuehrung_an_AE"], [2640, 12]) + self.assertEqual(res["Halter_Gegenleiste_an_AE"], [72, 2.4]) + self.assertEqual(res["Aluwinkel_40x20"], [312, 2.4]) + self.assertEqual(res["Halter_Gegenleiste_an_EE"], [312, 2.4]) + self.assertEqual(res["Alu_4kt_20x20"], [564, 12]) + self.assertEqual(res["Rollenandruckleiste_Sep_LP"], [2043, 2.27]) + self.assertEqual(res["Abhebeleiste_Sep_LP"], [4040.6, 22.7]) + self.assertEqual(res["Zwangsfuehrung_Sep_SP"], [3400, 10])