From 6775dfcb272825f06bb3901efdbd96f0864545da Mon Sep 17 00:00:00 2001
From: Shrek Requiem <shrekrequiem@proton.me>
Date: Sun, 16 Feb 2025 13:44:09 -0500
Subject: [PATCH] mdl convert

---
 python/src/convert_mdl.py              |   3 +
 vensim/__pycache__/bes.cpython-312.pyc | Bin 0 -> 19707 bytes
 vensim/bes.py                          | 692 +++++++++++++++++++++++++
 3 files changed, 695 insertions(+)
 create mode 100644 python/src/convert_mdl.py
 create mode 100644 vensim/__pycache__/bes.cpython-312.pyc
 create mode 100644 vensim/bes.py

diff --git a/python/src/convert_mdl.py b/python/src/convert_mdl.py
new file mode 100644
index 0000000..b1d2523
--- /dev/null
+++ b/python/src/convert_mdl.py
@@ -0,0 +1,3 @@
+import pysd
+
+model = pysd.read_vensim('./vensim/bes.mdl')
diff --git a/vensim/__pycache__/bes.cpython-312.pyc b/vensim/__pycache__/bes.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5307576f7b164f4d770d471f7032cca8b4bbf84e
GIT binary patch
literal 19707
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
Qr6H9Mb54sz`i%Mi0LnUE?EnA(

literal 0
HcmV?d00001

diff --git a/vensim/bes.py b/vensim/bes.py
new file mode 100644
index 0000000..5b0ec92
--- /dev/null
+++ b/vensim/bes.py
@@ -0,0 +1,692 @@
+"""
+Python model 'bes.py'
+Translated using PySD
+"""
+
+from pathlib import Path
+import numpy as np
+
+from pysd.py_backend.statefuls import Integ
+from pysd import Component
+
+__pysd_version__ = "3.14.2"
+
+__data = {"scope": None, "time": lambda: 0}
+
+_root = Path(__file__).parent
+
+
+component = Component()
+
+#######################################################################
+#                          CONTROL VARIABLES                          #
+#######################################################################
+
+_control_vars = {
+    "initial_time": lambda: 0,
+    "final_time": lambda: 120,
+    "time_step": lambda: 1,
+    "saveper": lambda: time_step(),
+}
+
+
+def _init_outer_references(data):
+    for key in data:
+        __data[key] = data[key]
+
+
+@component.add(name="Time")
+def time():
+    """
+    Current time of the model.
+    """
+    return __data["time"]()
+
+
+@component.add(
+    name="FINAL TIME", units="Month", comp_type="Constant", comp_subtype="Normal"
+)
+def final_time():
+    """
+    The final time for the simulation.
+    """
+    return __data["time"].final_time()
+
+
+@component.add(
+    name="INITIAL TIME", units="Month", comp_type="Constant", comp_subtype="Normal"
+)
+def initial_time():
+    """
+    The initial time for the simulation.
+    """
+    return __data["time"].initial_time()
+
+
+@component.add(
+    name="SAVEPER",
+    units="Month",
+    limits=(0.0, np.nan),
+    comp_type="Auxiliary",
+    comp_subtype="Normal",
+    depends_on={"time_step": 1},
+)
+def saveper():
+    """
+    The frequency with which output is stored.
+    """
+    return __data["time"].saveper()
+
+
+@component.add(
+    name="TIME STEP",
+    units="Month",
+    limits=(0.0, np.nan),
+    comp_type="Constant",
+    comp_subtype="Normal",
+)
+def time_step():
+    """
+    The time step for the simulation.
+    """
+    return __data["time"].time_step()
+
+
+#######################################################################
+#                           MODEL VARIABLES                           #
+#######################################################################
+
+
+@component.add(
+    name="Noise", comp_type="Auxiliary", comp_subtype="Normal", depends_on={"time": 1}
+)
+def noise():
+    return float(np.random.uniform(0, 5, size=()))
+
+
+@component.add(
+    name="Demand",
+    units="loaves/Day",
+    comp_type="Auxiliary",
+    comp_subtype="Normal",
+    depends_on={"base_demand": 1, "noise": 1},
+)
+def demand():
+    return base_demand() + noise()
+
+
+@component.add(
+    name="Amplitude of Seasonal Variations",
+    units="loaves",
+    comp_type="Constant",
+    comp_subtype="Normal",
+)
+def amplitude_of_seasonal_variations():
+    return 30
+
+
+@component.add(name="phi", units="radians", comp_type="Constant", comp_subtype="Normal")
+def phi():
+    return 0
+
+
+@component.add(
+    name="Base Demand", units="loaves/Day", comp_type="Constant", comp_subtype="Normal"
+)
+def base_demand():
+    return 200
+
+
+@component.add(
+    name="Sigma", units="loaves/Day", comp_type="Constant", comp_subtype="Normal"
+)
+def sigma():
+    return 5
+
+
+@component.add(name="Period", units="days", comp_type="Constant", comp_subtype="Normal")
+def period():
+    return 7
+
+
+@component.add(
+    name="Available Workers",
+    units="workers",
+    comp_type="Constant",
+    comp_subtype="Normal",
+)
+def available_workers():
+    return 2
+
+
+@component.add(
+    name="Base Rate", units="loaves/Day", comp_type="Constant", comp_subtype="Normal"
+)
+def base_rate():
+    return 200
+
+
+@component.add(
+    name="Lead Time Sugar", units="days", comp_type="Constant", comp_subtype="Normal"
+)
+def lead_time_sugar():
+    return 1
+
+
+@component.add(
+    name="Bread Production",
+    units="loaves/Day",
+    comp_type="Auxiliary",
+    comp_subtype="Normal",
+    depends_on={"base_rate": 1, "minresource": 1, "labour_efficiency": 1},
+)
+def bread_production():
+    return float(np.minimum(base_rate(), minresource())) * labour_efficiency()
+
+
+@component.add(
+    name="Water Safety", units="litres", comp_type="Constant", comp_subtype="Normal"
+)
+def water_safety():
+    return 300
+
+
+@component.add(
+    name="Sugar Purchase",
+    units="kg",
+    comp_type="Auxiliary",
+    comp_subtype="Normal",
+    depends_on={
+        "bread_production": 1,
+        "suger_per_loaf": 1,
+        "sugar_safety": 1,
+        "sugar": 1,
+        "lead_time_sugar": 1,
+    },
+)
+def sugar_purchase():
+    return float(
+        np.maximum(
+            0,
+            (bread_production() * suger_per_loaf() + sugar_safety() - sugar())
+            / lead_time_sugar(),
+        )
+    )
+
+
+@component.add(
+    name="Flour per Loaf", units="kg/loaf", comp_type="Constant", comp_subtype="Normal"
+)
+def flour_per_loaf():
+    return 0.3
+
+
+@component.add(
+    name="Suger per Loaf", units="kg/loaf", comp_type="Constant", comp_subtype="Normal"
+)
+def suger_per_loaf():
+    return 0.02
+
+
+@component.add(
+    name="MinSugarWater",
+    comp_type="Auxiliary",
+    comp_subtype="Normal",
+    depends_on={"sugar": 1, "suger_per_loaf": 1, "water_per_loaf": 1, "water": 1},
+)
+def minsugarwater():
+    return float(np.minimum(sugar() / suger_per_loaf(), water() / water_per_loaf()))
+
+
+@component.add(
+    name="Yeast Purchase",
+    units="kg",
+    comp_type="Auxiliary",
+    comp_subtype="Normal",
+    depends_on={
+        "bread_production": 1,
+        "yeast_per_loaf": 1,
+        "yeast_safety": 1,
+        "yeast": 1,
+        "lead_time_yeast": 1,
+    },
+)
+def yeast_purchase():
+    return float(
+        np.maximum(
+            0,
+            (bread_production() * yeast_per_loaf() + yeast_safety() - yeast())
+            / lead_time_yeast(),
+        )
+    )
+
+
+@component.add(
+    name="Labour Efficiency",
+    units="Dmnl",
+    comp_type="Auxiliary",
+    comp_subtype="Normal",
+    depends_on={"available_workers": 1, "workers_required": 1},
+)
+def labour_efficiency():
+    return float(np.minimum(1, available_workers() / workers_required()))
+
+
+@component.add(
+    name="Water",
+    units="litres",
+    comp_type="Stateful",
+    comp_subtype="Integ",
+    depends_on={"_integ_water": 1},
+    other_deps={
+        "_integ_water": {
+            "initial": {},
+            "step": {"water_purchase": 1, "water_per_loaf": 1, "bread_production": 1},
+        }
+    },
+)
+def water():
+    return _integ_water()
+
+
+_integ_water = Integ(
+    lambda: water_purchase() - bread_production() * water_per_loaf(),
+    lambda: 2000,
+    "_integ_water",
+)
+
+
+@component.add(
+    name="Water Cost", units="$/litre", comp_type="Constant", comp_subtype="Normal"
+)
+def water_cost():
+    return 0.001
+
+
+@component.add(
+    name="Lead Time Water", units="days", comp_type="Constant", comp_subtype="Normal"
+)
+def lead_time_water():
+    return 1
+
+
+@component.add(
+    name="Lead Time Yeast", units="days", comp_type="Constant", comp_subtype="Normal"
+)
+def lead_time_yeast():
+    return 1
+
+
+@component.add(
+    name="Water Purchase",
+    units="litres",
+    comp_type="Auxiliary",
+    comp_subtype="Normal",
+    depends_on={
+        "bread_production": 1,
+        "water_per_loaf": 1,
+        "water_safety": 1,
+        "water": 1,
+        "lead_time_water": 1,
+    },
+)
+def water_purchase():
+    return float(
+        np.maximum(
+            0,
+            (bread_production() * water_per_loaf() + water_safety() - water())
+            / lead_time_water(),
+        )
+    )
+
+
+@component.add(
+    name="Workers Required",
+    units="workers",
+    comp_type="Constant",
+    comp_subtype="Normal",
+)
+def workers_required():
+    return 2
+
+
+@component.add(
+    name="MinFlourYeast",
+    comp_type="Auxiliary",
+    comp_subtype="Normal",
+    depends_on={"flour": 1, "flour_per_loaf": 1, "yeast_per_loaf": 1, "yeast": 1},
+)
+def minflouryeast():
+    return float(np.minimum(flour() / flour_per_loaf(), yeast() / yeast_per_loaf()))
+
+
+@component.add(
+    name="MinResource",
+    comp_type="Auxiliary",
+    comp_subtype="Normal",
+    depends_on={"minflouryeast": 1, "minsugarwater": 1},
+)
+def minresource():
+    return float(np.minimum(minflouryeast(), minsugarwater()))
+
+
+@component.add(
+    name="Water per Loaf",
+    units="litres/loaf",
+    comp_type="Constant",
+    comp_subtype="Normal",
+)
+def water_per_loaf():
+    return 0.2
+
+
+@component.add(
+    name="Waste Bread", units="loaves/Day", comp_type="Constant", comp_subtype="Normal"
+)
+def waste_bread():
+    return 2
+
+
+@component.add(
+    name="Raw Material Cost",
+    units="$",
+    comp_type="Auxiliary",
+    comp_subtype="Normal",
+    depends_on={
+        "flour_cost": 1,
+        "flour_purchase": 1,
+        "sugar_purchase": 1,
+        "sugar_cost": 1,
+        "yeast_purchase": 1,
+        "yeast_cost": 1,
+        "water_purchase": 1,
+        "water_cost": 1,
+    },
+)
+def raw_material_cost():
+    return (
+        flour_cost() * flour_purchase()
+        + sugar_cost() * sugar_purchase()
+        + yeast_cost() * yeast_purchase()
+        + water_cost() * water_purchase()
+    )
+
+
+@component.add(
+    name="Yeast Safety", units="kg", comp_type="Constant", comp_subtype="Normal"
+)
+def yeast_safety():
+    return 10
+
+
+@component.add(
+    name="Sugar Safety", units="kg", comp_type="Constant", comp_subtype="Normal"
+)
+def sugar_safety():
+    return 20
+
+
+@component.add(
+    name="Bread",
+    units="loaves",
+    comp_type="Stateful",
+    comp_subtype="Integ",
+    depends_on={"_integ_bread": 1},
+    other_deps={
+        "_integ_bread": {
+            "initial": {},
+            "step": {"bread_production": 1, "waste_bread": 1, "sales": 1},
+        }
+    },
+)
+def bread():
+    return _integ_bread()
+
+
+_integ_bread = Integ(
+    lambda: bread_production() - waste_bread() - sales(), lambda: 0, "_integ_bread"
+)
+
+
+@component.add(
+    name="Flour",
+    units="kg",
+    comp_type="Stateful",
+    comp_subtype="Integ",
+    depends_on={"_integ_flour": 1},
+    other_deps={
+        "_integ_flour": {
+            "initial": {},
+            "step": {"flour_purchase": 1, "flour_per_loaf": 1, "bread_production": 1},
+        }
+    },
+)
+def flour():
+    return _integ_flour()
+
+
+_integ_flour = Integ(
+    lambda: flour_purchase() - flour_per_loaf() * bread_production(),
+    lambda: 1000,
+    "_integ_flour",
+)
+
+
+@component.add(
+    name="Flour Cost", units="$/kg", comp_type="Constant", comp_subtype="Normal"
+)
+def flour_cost():
+    return 0.5
+
+
+@component.add(
+    name="Flour Purchase",
+    units="kg",
+    comp_type="Auxiliary",
+    comp_subtype="Normal",
+    depends_on={
+        "bread_production": 1,
+        "flour_per_loaf": 1,
+        "flour_safety": 1,
+        "flour": 1,
+        "lead_time_flour": 1,
+    },
+)
+def flour_purchase():
+    return float(
+        np.maximum(
+            0,
+            (bread_production() * flour_per_loaf() + flour_safety() - flour())
+            / lead_time_flour(),
+        )
+    )
+
+
+@component.add(
+    name="Flour Safety", units="kg", comp_type="Constant", comp_subtype="Normal"
+)
+def flour_safety():
+    return 200
+
+
+@component.add(
+    name="Labour Cost",
+    units="$",
+    comp_type="Auxiliary",
+    comp_subtype="Normal",
+    depends_on={"wage_rate": 1, "total_labour_hours": 1},
+)
+def labour_cost():
+    return wage_rate() * total_labour_hours()
+
+
+@component.add(
+    name="Lead Time Flour", units="days", comp_type="Constant", comp_subtype="Normal"
+)
+def lead_time_flour():
+    return 1
+
+
+@component.add(
+    name="Maintainance Cost",
+    units="$",
+    comp_type="Auxiliary",
+    comp_subtype="Normal",
+    depends_on={"maintainance_rate": 1, "money": 1},
+)
+def maintainance_cost():
+    return maintainance_rate() * money()
+
+
+@component.add(
+    name="Maintainance Rate",
+    units="fraction/Day",
+    comp_type="Constant",
+    comp_subtype="Normal",
+)
+def maintainance_rate():
+    return 0.002
+
+
+@component.add(
+    name="Money",
+    units="$",
+    comp_type="Stateful",
+    comp_subtype="Integ",
+    depends_on={"_integ_money": 1},
+    other_deps={
+        "_integ_money": {
+            "initial": {},
+            "step": {
+                "revenue": 1,
+                "labour_cost": 1,
+                "maintainance_cost": 1,
+                "raw_material_cost": 1,
+            },
+        }
+    },
+)
+def money():
+    return _integ_money()
+
+
+_integ_money = Integ(
+    lambda: revenue() - labour_cost() - maintainance_cost() - raw_material_cost(),
+    lambda: 100000,
+    "_integ_money",
+)
+
+
+@component.add(
+    name="Revenue",
+    units="$",
+    comp_type="Auxiliary",
+    comp_subtype="Normal",
+    depends_on={"sales_price": 1, "sales": 1},
+)
+def revenue():
+    return sales_price() * sales()
+
+
+@component.add(
+    name="Sales",
+    units="loaves/Day",
+    comp_type="Auxiliary",
+    comp_subtype="Normal",
+    depends_on={"bread": 1, "demand": 1},
+)
+def sales():
+    return float(np.minimum(bread(), demand()))
+
+
+@component.add(
+    name="Sales Price", units="$/loaf", comp_type="Constant", comp_subtype="Normal"
+)
+def sales_price():
+    return 4
+
+
+@component.add(
+    name="Sugar",
+    units="kg",
+    comp_type="Stateful",
+    comp_subtype="Integ",
+    depends_on={"_integ_sugar": 1},
+    other_deps={
+        "_integ_sugar": {
+            "initial": {},
+            "step": {"sugar_purchase": 1, "suger_per_loaf": 1, "bread_production": 1},
+        }
+    },
+)
+def sugar():
+    return _integ_sugar()
+
+
+_integ_sugar = Integ(
+    lambda: sugar_purchase() - bread_production() * suger_per_loaf(),
+    lambda: 100,
+    "_integ_sugar",
+)
+
+
+@component.add(
+    name="Sugar Cost", units="$/kg", comp_type="Constant", comp_subtype="Normal"
+)
+def sugar_cost():
+    return 0.8
+
+
+@component.add(
+    name="Total Labour Hours",
+    units="hours/Day",
+    comp_type="Constant",
+    comp_subtype="Normal",
+)
+def total_labour_hours():
+    return 16
+
+
+@component.add(
+    name="Wage Rate", units="$/Hour", comp_type="Constant", comp_subtype="Normal"
+)
+def wage_rate():
+    return 12
+
+
+@component.add(
+    name="Yeast",
+    units="kg",
+    comp_type="Stateful",
+    comp_subtype="Integ",
+    depends_on={"_integ_yeast": 1},
+    other_deps={
+        "_integ_yeast": {
+            "initial": {},
+            "step": {"yeast_purchase": 1, "yeast_per_loaf": 1, "bread_production": 1},
+        }
+    },
+)
+def yeast():
+    return _integ_yeast()
+
+
+_integ_yeast = Integ(
+    lambda: yeast_purchase() - bread_production() * yeast_per_loaf(),
+    lambda: 50,
+    "_integ_yeast",
+)
+
+
+@component.add(
+    name="Yeast Cost", units="$/kg", comp_type="Constant", comp_subtype="Normal"
+)
+def yeast_cost():
+    return 10
+
+
+@component.add(
+    name="Yeast per Loaf", units="kg/loaf", comp_type="Constant", comp_subtype="Normal"
+)
+def yeast_per_loaf():
+    return 0.01