Simon Schmutzler
460 lines
25 KiB
Python
460 lines
25 KiB
Python
import json
|
|
import math
|
|
from typing import Counter
|
|
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():
|
|
#standardkreisel ohne pin/rampe, bei Bedarf als Parameter übergeben
|
|
def __init__(self, bezeichnung, anzahl, laenge, anzahl_weichen, anzahl_separatoren, anzahl_scanner, pin=False, anzahl_rampen=0):
|
|
self.bezeichnung = bezeichnung
|
|
self.anzahl = anzahl
|
|
self.laenge = laenge
|
|
self.pin = pin #bool
|
|
self.anzahl_rampen = anzahl_rampen
|
|
self.anzahl_weichen = anzahl_weichen
|
|
self.anzahl_separatoren = anzahl_separatoren
|
|
self.anzahl_scanner = anzahl_scanner
|
|
|
|
class Gefaellestrecke():
|
|
#standardgefällestrecke ohne 30° EE/AE, bei Bedarf als Parameter übergeben
|
|
def __init__(self, bezeichnung, anzahl, laenge, anzahl_separatoren, anzahl_scanner, einschleuselement_30_grad=False, ausschleuselement_30_grad=False):
|
|
self.bezeichnung = bezeichnung
|
|
self.anzahl = anzahl
|
|
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,bezeichnung, kreisel:list[Kreisel], gefaellestrecken:list[Gefaellestrecke],anzahl_eckraeder=0, anzahl_etagenfoerderer=0, anzahl_bt_mt_entladung=0,
|
|
anzahl_bt_beladung=0, anzahl_mt_beladung=0, anzahl_zufuehrung_klinkenf=0, laenge_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)
|
|
self.bauteile = {
|
|
"Antriebsstation": 0,
|
|
"Spannstation": 0,
|
|
"Rampe": 0,
|
|
"Weiche": 0,
|
|
"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,
|
|
"Etagenfoerderer": 0,
|
|
"Sonst_Foerderer": 0,
|
|
"Inkrementalgeber": 0,
|
|
"Scanner": 0,
|
|
}
|
|
self.bauteile["Antriebsstation"] += anzahl_eckraeder
|
|
|
|
# BaaN => Montagezeit und Herstellkosten einzelner Baugruppen
|
|
b = BaaN()
|
|
self._kreisel = {}
|
|
kreisel_hk_mech_el_summe = 0
|
|
kreisel_mont_mech_el_summe = 0
|
|
for k in kreisel:
|
|
self.bauteile["Antriebsstation"] += k.anzahl
|
|
self.bauteile["Spannstation"] += k.anzahl
|
|
self.bauteile["Rampe"] += k.anzahl_rampen
|
|
self.bauteile["Weiche"] += k.anzahl_weichen
|
|
self.bauteile["Separator_LP"] += k.anzahl_separatoren
|
|
self.bauteile["Scanner"] += k.anzahl_scanner
|
|
|
|
pin = 0
|
|
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") +\
|
|
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"))
|
|
|
|
kreisel_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"))
|
|
|
|
kreisel_hk_mech_el_summe += kreisel_hk_mech_el
|
|
kreisel_mont_mech_el_summe += kreisel_mont_mech_el
|
|
self._kreisel[k.bezeichnung] ={"hk_summe": round(kreisel_hk_mech_el,2), "mont_summe": round(kreisel_mont_mech_el/60, 2)}
|
|
|
|
self._kreisel["_GESAMT_"] = {"hk_summe": round(kreisel_hk_mech_el_summe,2), "mont_summe": round(kreisel_mont_mech_el_summe/60,2)}
|
|
|
|
#TODO: Eckrad Montagestundenberechnung => *1.5?
|
|
self._eckraeder = {"hk_summe": round(anzahl_eckraeder*(b.herstellkosten_mech_el("ANTRIEBSSTATION_800_ILS_20_(mit_Motor)")),2), "mont_summe": round((anzahl_eckraeder*b.montagestunden_mech_el("ANTRIEBSSTATION_800_ILS_20_(mit_Motor)")*1.5)/60,2)}
|
|
|
|
# =D17*(Tabellen!J3+E17*Tabellen!L3+I17*Tabellen!M3+J17*Tabellen!R3)
|
|
# = Anzahl * (AE+EE + Länge * mSP + Separatoren * Sep + Scanner * ScanSep)
|
|
# = =BaaN!G19+BaaN!G20 =BaaN!G13 =BaaN!G15 =BaaN!G16
|
|
# Aufschlag AE/EE 30°: =BaaN!C24-BaaN!C19
|
|
gefaelle_hk_mech_el_summe = 0
|
|
gefaelle_mont_mech_el_summe = 0
|
|
self._gefaellestrecken = {}
|
|
for g in gefaellestrecken:
|
|
self.bauteile["Separator_SP"] += g.anzahl_separatoren
|
|
#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)")
|
|
montAE = b.montagestunden_mech_el("AE_ILS_20_(SMC)")
|
|
hkEE = b.herstellkosten_mech_el("EE")
|
|
montEE = b.montagestunden_mech_el("EE")
|
|
|
|
#TODO: Zusatzaufwand für 30° EE/AE bezieht sich ausschließlich auf Differenz zwischen Material mechanik(HK) zwischen AE und AE30°
|
|
#TODO: Montagezeit korrekt, allerdings wird für die Berechnung von Einschleuselementen ebenfalls Zahlen der AS verwendet
|
|
#TODO: keine Montagezeiten elektrik für AE/EE 30°!
|
|
# Hier: Berechnung entweder auf Grundlage von standard AE/EE oder mit 30° aus Klasse Baan()
|
|
if(g.ausschleuselement_30_grad):
|
|
hkAE = b.herstellkosten_mech_el("AS_ELEMENT_30_MIT_SMC_PNEUMATIK_F_SF_ILS")
|
|
montAE = b.montagestunden_mech_el("AS_ELEMENT_30_MIT_SMC_PNEUMATIK_F_SF_ILS")
|
|
if(g.einschleuselement_30_grad):
|
|
hkEE = b.herstellkosten_mech_el("ES_ELEMENT_30_F_SF_ILS")
|
|
montEE = b.montagestunden_mech_el("ES_ELEMENT_30_F_SF_ILS")
|
|
|
|
gefaelle_hk_mech_el = g.anzahl * (hkAE + hkEE + g.laenge * b.herstellkosten_mech_el("SP_ILS_20") +\
|
|
g.anzahl_separatoren * b.herstellkosten_mech_el("Sep_SP_HD_ILS_20_(SMC)") + g.anzahl_scanner * b.herstellkosten_mech_el("SCANNER_FÜR_SEPARATOR"))
|
|
|
|
gefaelle_mont_mech_el = g.anzahl * (montAE + montEE + g.laenge * b.montagestunden_mech_el("SP_ILS_20") +\
|
|
g.anzahl_separatoren * b.montagestunden_mech_el("Sep_SP_HD_ILS_20_(SMC)") + g.anzahl_scanner * b.montagestunden_mech_el("SCANNER_FÜR_SEPARATOR"))
|
|
gefaelle_hk_mech_el_summe += gefaelle_hk_mech_el
|
|
gefaelle_mont_mech_el_summe += gefaelle_mont_mech_el
|
|
self._gefaellestrecken[g.bezeichnung] = {"hk_summe": round(gefaelle_hk_mech_el,2), "mont_summe": round(gefaelle_mont_mech_el/60, 2)}
|
|
|
|
self._gefaellestrecken["_GESAMT_"] = {"hk_summe": round(gefaelle_hk_mech_el_summe,2), "mont_summe": round(gefaelle_mont_mech_el_summe/60,2)}
|
|
#Etagenförderer
|
|
etf_hk_mech_el = anzahl_etagenfoerderer * b.herstellkosten_mech_el("ETF_6m_Zw_Träger_ILS_20")
|
|
etf_mont_mech_el = anzahl_etagenfoerderer * b.montagestunden_mech_el("ETF_6m_Zw_Träger_ILS_20")
|
|
self._etagenfoerderer = {"hk_summe": round(etf_hk_mech_el,2), "mont_summe": round(etf_mont_mech_el/60,2)}
|
|
#TODO: so-förderer
|
|
|
|
#Umbügeln
|
|
self._btmt_entladung = {"hk_summe": round(anzahl_bt_mt_entladung * b.herstellkosten_mech_el("BT_MT_Entladg"),2), "mont_summe": round((anzahl_bt_mt_entladung*b.montagestunden_mech_el("BT_MT_Entladg"))/60,2)}
|
|
self._bt_beladung = {"hk_summe": round(anzahl_bt_beladung * b.herstellkosten_mech_el("BT_Beladg"),2), "mont_summe": round((anzahl_bt_beladung * b.montagestunden_mech_el("BT_Beladg"))/60,2)}
|
|
self._mt_beladung = {"hk_summe": round(anzahl_mt_beladung * b.herstellkosten_mech_el("MT_Beladg"),2), "mont_summe": round((anzahl_mt_beladung * b.montagestunden_mech_el("MT_Beladg"))/60,2)}
|
|
#zuführung klinkenförderer=D37*Tabellen!E62+D37*E37*Tabellen!F62 TODO: Keine Artikel hinterlegt, ausschließlich Zahlenwerte -> Überprüfen
|
|
# Klinkenförderer: Antrieb = 920, E-Material = 200, proMeter = 160, MontageAntrieb = 3(h), MontageMeter = 1(h)
|
|
self._zufuehrung_cpc = {"hk_summe": round(anzahl_zufuehrung_klinkenf * (920 + laenge_zufuehrung_klinkenf),2), "mont_summe": round((anzahl_zufuehrung_klinkenf * (3 + laenge_zufuehrung_klinkenf * 1))/60,2)}
|
|
|
|
def getBauteile(self):
|
|
return self.bauteile
|
|
|
|
def getResult(self):
|
|
res = {
|
|
"Kreisel": self._kreisel,
|
|
"Eckraeder": self._eckraeder,
|
|
"Gefaellestrecken": self._gefaellestrecken,
|
|
"Etagenfoerderer": self._etagenfoerderer,
|
|
"BTMT_Entladung": self._btmt_entladung,
|
|
"BT_Beladung": self._bt_beladung,
|
|
"MT_Beladung": self._mt_beladung,
|
|
"Zufuehrung_Klinke": self._zufuehrung_cpc,
|
|
}
|
|
return res
|
|
|
|
def getSummenBereich(self):
|
|
hk_sum = 0
|
|
mont_sum = 0
|
|
|
|
hk_sum += self._kreisel.get("_GESAMT_", {}).get("hk_summe", 0)
|
|
hk_sum += self._gefaellestrecken.get("_GESAMT_", {}).get("hk_summe", 0)
|
|
hk_sum += self._eckraeder.get("hk_summe", 0)
|
|
hk_sum += self._etagenfoerderer.get("hk_summe", 0)
|
|
#TODO: So Förderer
|
|
hk_sum += self._btmt_entladung.get("hk_summe", 0)
|
|
hk_sum += self._bt_beladung.get("hk_summe", 0)
|
|
hk_sum += self._mt_beladung.get("hk_summe", 0)
|
|
hk_sum += self._zufuehrung_cpc.get("hk_summe", 0)
|
|
|
|
mont_sum += self._kreisel.get("_GESAMT_", {}).get("mont_summe", 0)
|
|
mont_sum += self._gefaellestrecken.get("_GESAMT_", {}).get("mont_summe", 0)
|
|
mont_sum += self._eckraeder.get("mont_summe", 0)
|
|
mont_sum += self._etagenfoerderer.get("mont_summe", 0)
|
|
#TODO: So Förderer
|
|
mont_sum += self._btmt_entladung.get("mont_summe", 0)
|
|
mont_sum += self._bt_beladung.get("mont_summe", 0)
|
|
mont_sum += self._mt_beladung.get("mont_summe", 0)
|
|
mont_sum += self._zufuehrung_cpc.get("mont_summe", 0)
|
|
|
|
return {"Materialkosten": round(hk_sum, 2), "Montagezeit": round(mont_sum, 2)} #Ohne Aufschläge, reine HK Kosten bzw Montagezeiten
|
|
|
|
|
|
def tojson(self, input:dict):
|
|
return json.dumps(input, sort_keys=False, indent=4)
|
|
|
|
def resToFile(self):
|
|
json = self.tojson(self.getResult())
|
|
fname = "Bereich_" + self._bezeichnung + ".json"
|
|
with open("Bereichszusammenfassung.json", "w") as file:
|
|
file.write(json)
|
|
|
|
|
|
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],
|
|
}
|
|
|
|
self._Taschen = {
|
|
#"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
|
|
}
|
|
|
|
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 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()
|
|
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)
|
|
|
|
kreisel = []
|
|
kreisel.append(Kreisel("Zufuehrung Richtung Puffer",2, 30, 4,4,4))
|
|
kreisel.append(Kreisel("Verbindung",3,4,0,0,0))
|
|
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())
|
|
|
|
|
|
|
|
|
|
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])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main() |