ILS-Kalk/ils_kalk.py

import math
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, 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
        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, 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, 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()