engforge 0.3.0__py3-none-any.whl

engforge/test/test_airfilter.py

@@ -0,0 +1,91 @@
+"""tests airfilter system operation by solving for airflow between filter and and fan"""
+
+import unittest
+
+from engforge.configuration import forge
+from engforge.system import System
+from engforge.components import Component
+from engforge.attr_dynamics import Time
+from engforge.attr_solver import Solver
+from engforge.attr_signals import Signal
+from engforge.attr_slots import Slot
+from engforge.properties import *
+from engforge.attr_plotting import *
+from engforge.analysis import Analysis
+
+from engforge._testing_components import *
+
+from scipy.optimize import curve_fit, least_squares
+import numpy as np
+from matplotlib.pyplot import *
+
+import attrs
+
+
+class TestFilterSystem(unittest.TestCase):
+    def setUp(self):
+        self.af = Airfilter()
+
+    def test_plot(self):
+        N = 10
+        self.af.run(throttle=np.linspace(0, 1, N), combos="*", slv_vars="*")
+        fig = self.af.flow_curve()
+        self.assertIsNotNone(fig)
+
+        df = self.af.dataframe
+        self.assertEqual(df.shape[0], N)
+
+        dfv = self.af.dataframe_variants
+        self.assertEqual(dfv.shape[0], N)
+        self.assertIn("w", dfv.columns)
+        self.assertIn("throttle", dfv.columns)
+
+        dfc = self.af.dataframe_constants
+        self.assertIsInstance(dfc, dict)
+
+        self.assertEqual(df.shape[1], len(dfc) + dfv.shape[1])
+
+
+class TestAnalysis(unittest.TestCase):
+    def setUp(self):
+        self.af = AirFilterAnalysis()
+
+    def test_plot(self):
+        self.af.run(throttle=np.linspace(0, 1, 10), combos="*", slv_vars="*")
+        fig = self.af.system.flow_curve()
+        ofig = self.af._stored_plots["airfilteranalysis.airfilter.flow_curve"]
+        print(fig)
+        print(ofig)
+
+        self.assertIsNotNone(fig)
+        self.assertIsNotNone(ofig)
+
+
+# #Run the system
+# from matplotlib.pylab import *
+#
+#
+#
+# fan = Fan()
+# filt = Filter()
+# af = Airfilter(fan=fan,filt=filt)
+#
+# change_all_log_levels(af,20) #info
+#
+# af.run(throttle=list(np.arange(0.1,1.1,0.1)),combos='*')
+#
+# df = af.dataframe
+#
+# fig,(ax,ax2) = subplots(2,1)
+# ax.plot(df.throttle*100,df.w,'k--',label='flow')
+# ax2.plot(df.throttle*100,df.filt_dp_filter,label='filter')
+# ax2.plot(df.throttle*100,df.dp_parasitic,label='parasitic')
+# ax2.plot(df.throttle*100,df.fan_dp_fan,label='fan')
+# ax.legend(loc='upper right')
+# ax.set_title('flow')
+# ax.grid()
+# ax2.legend()
+# ax2.grid()
+# ax2.set_title(f'pressure')
+# ax2.set_xlabel(f'throttle%')        dfv = self.af.dataframe_variants
+# self.assertEqual(dfv.shape[0],N)

engforge/test/test_analysis.py

@@ -0,0 +1,3 @@
+from engforge.test.test_airfilter import *
+from engforge.analysis import Analysis
+from engforge.attr_slots import Slot

engforge/test/test_comp_iter.py

@@ -0,0 +1,196 @@
+from engforge.components import Component
+from engforge.component_collections import ComponentDict, ComponentIter
+from engforge.system import System
+from engforge.attr_slots import Slot
+from engforge.configuration import forge
+from engforge.tabulation import system_property
+
+import attrs, attr
+
+import random
+import unittest
+import itertools
+
+# from engforge.logging import LoggingMixin, change_all_log_levels
+# change_all_log_levels(10)
+
+
+@forge
+class TestConfig(Component):
+    attrs_prop: float = attr.ib(1.0)
+    attrs_str: str = attr.ib("hey now")
+
+    @system_property
+    def test_one(self) -> int:
+        return 1
+
+    @system_property(stochastic=True)
+    def test_two(self) -> float:
+        return random.random()
+
+    @system_property
+    def test_three(self) -> int:
+        return 2
+
+    @system_property(stochastic=True)
+    def test_four(self) -> float:
+        return random.random()
+
+
+@forge
+class DictComp(ComponentDict):
+    component_type = TestConfig
+
+
+@forge
+class ListComp(ComponentDict):
+    component_type = TestConfig
+
+
+@forge
+class WideSystem(System):
+    cdict = Slot.define_iterator(DictComp)
+    citer = Slot.define_iterator(ComponentIter)
+
+
+@forge
+class NarrowSystem(System):
+    cdict = Slot.define_iterator(DictComp, wide=False)
+    citer = Slot.define_iterator(ComponentIter, wide=False)
+
+
+class TestWide(unittest.TestCase):
+    def setUp(self):
+        self.item_in = {i: "hey" * (i + 1) for i in range(5)}
+
+        lc = ListComp(component_type=TestConfig)
+        for i, v in self.item_in.items():
+            lc[i] = TestConfig(name=f"citer_{i}", attrs_prop=i, attrs_str=v)
+
+        dc = DictComp(component_type=TestConfig)
+        for i, v in self.item_in.items():
+            dc[v] = TestConfig(name=f"cdict_{i}", attrs_prop=i, attrs_str=v)
+
+        self.system = WideSystem(cdict=dc, citer=lc)
+
+    def test_keys(self):
+        self.assertFalse(len(self.system.dataframe))
+
+        dat = self.system.data_dict
+
+        all_keys = set(dat.keys())
+
+        comps = {
+            "cdict": ["hey" * (i + 1) for i in range(5)],
+            "citer": list(range(5)),
+        }
+
+        props = [
+            "test_one",
+            "test_two",
+            "test_three",
+            "test_four",
+            "name",
+            "attrs_prop",
+            "attrs_str",
+        ]
+
+        should_keys = set()
+        dataframe_keys = set()
+        for ck, vlist in comps.items():
+            for v in vlist:
+                for p in props:
+                    tkn = f"{ck}.{v}.{p}"
+                    should_keys.add(tkn)
+                    dataframe_keys.add(tkn)
+
+        sys_key = set(self.system.data_dict.keys())
+        mtch = should_keys.issubset(sys_key)
+        self.system.debug(f"keys: {should_keys} vs {sys_key}")
+        self.assertTrue(mtch, msg=f"missing keys: {should_keys - sys_key}")
+
+        # save the data to table
+        self.system.run(revert_last=False, revert_every=False, save_on_exit=True)
+
+        df = self.system.last_context.dataframe
+        self.assertTrue(len(df) == 1, msg=f"len: {len(df)}|\n{str(df)}")
+        self.assertTrue(dataframe_keys.issubset(set(df.iloc[0].keys())))
+        self.assertTrue(dataframe_keys.issubset(set(df.keys())))
+
+
+class TestNarrow(unittest.TestCase):
+    def setUp(self):
+        self.item_in = {i: "hey" * (i + 1) for i in range(5)}
+
+        lc = ListComp(component_type=TestConfig)
+        for i, v in self.item_in.items():
+            lc[i] = TestConfig(name=f"citer_{i}", attrs_prop=i, attrs_str=v)
+
+        dc = DictComp(component_type=TestConfig)
+        for i, v in self.item_in.items():
+            dc[v] = TestConfig(name=f"cdict_{i}", attrs_prop=i, attrs_str=v)
+
+        self.system = NarrowSystem(cdict=dc, citer=lc)
+
+    def test_keys(self):
+        self.assertFalse(len(self.system.dataframe) > 0)
+
+        dat = self.system.data_dict
+
+        all_keys = set(dat.keys())
+
+        comps = {
+            "cdict": ["hey" * (i + 1) for i in range(5)],
+            "citer": list(range(5)),
+        }
+
+        props = [
+            "test_one",
+            "test_two",
+            "test_three",
+            "test_four",
+            "name",
+            "attrs_prop",
+            "attrs_str",
+        ]
+
+        should_keys = set()
+        dataframe_keys = set()
+        for ck, vlist in comps.items():
+            # for v in vlist:
+            for p in props:
+                tkn = f"{ck}.{p}"
+                should_keys.add(tkn)
+                dataframe_keys.add(tkn)
+
+        sys_key = set(self.system.data_dict.keys())
+        mtch = should_keys.issubset(sys_key)
+        self.system.info(f"keys: {should_keys} vs {sys_key}")
+        self.assertTrue(mtch, msg=f"missing keys: {should_keys - sys_key}")
+
+        # save the data to table
+        self.system.run()
+
+        df = self.system.last_context.dataframe
+        self.assertTrue(len(df) == 5 ** len(comps))
+        self.assertTrue(dataframe_keys.issubset(set(df.iloc[0].keys())))
+        self.assertTrue(dataframe_keys.issubset(set(df.keys())))
+
+        # test item existence
+        v1 = set(self.system.dataframe["cdict.current_item"])
+        v2 = set(comps["cdict"])
+
+        self.assertEqual(v1, v2)
+
+        d1 = set(self.system.dataframe["citer.current_item"])
+        d2 = set(comps["citer"])
+
+        self.assertEqual(d1, d2)
+
+        dvs = self.system.dataframe["cdict.current_item"]
+        cvs = self.system.dataframe["citer.current_item"]
+
+        al = set(zip(dvs, cvs))
+        sh = set(itertools.product(v2, d2))
+
+        self.assertEqual(al, sh)

engforge/test/test_composition.py

@@ -0,0 +1,139 @@
+import unittest
+
+from engforge.configuration import forge
+from engforge.system import System
+from engforge.components import Component
+from engforge.attr_dynamics import Time
+from engforge.attr_solver import Solver
+from engforge.attr_signals import Signal
+from engforge.attr_slots import Slot
+from engforge.properties import *
+from engforge.problem_context import ProblemExec
+
+import attrs
+
+
+@forge
+class MockComponent(Component):
+    input: float = attrs.field(default=0)
+    # use to test input from system
+    aux: float = attrs.field(default=0)
+
+    comp = Slot.define(Component, none_ok=True)
+
+    @system_property
+    def output(self) -> float:
+        return self.input * self.input
+
+
+def limit_max(system, prb):
+    return 4 - system.input
+
+
+@forge
+class MockSystem(System):
+    input: float = attrs.field(default=0)
+    output: float = attrs.field(default=0)
+
+    in2: float = attrs.field(default=1)
+
+    x: float = attrs.field(default=0)
+
+    # move system input to component
+    pre_sig = Signal.define("comp.input", "input", mode="pre")
+    # move component output to system
+    post_sig = Signal.define("output", "comp.output", mode="both")
+
+    Solver.constraint_equality("in_out_diff")
+    Solver.constraint_equality("in2out2")
+
+    var_in = Solver.declare_var("input")
+    var_in.add_var_constraint(kind="min", value=0)
+    var_in.add_var_constraint(kind="max", value=1)
+
+    sol2 = Solver.declare_var("in2")
+    sol2.add_var_constraint(kind="max", value=limit_max)
+    sol2.add_var_constraint(kind="min", value=0)
+
+    comp = Slot.define(MockComponent)
+
+    @system_property
+    def in_out_diff(self) -> float:
+        # Should solve= 0 when in2=input^2
+        return self.input + 1 - self.output - self.in2 * 0.1
+
+    @system_property
+    def in2out2(self) -> float:
+        return self.in2 - self.input * 2 + self.comp.aux / 10
+
+    @system_property
+    def dxdt(self) -> float:
+        # dxdt = (in - in**2)/1000.0
+        # Should converge to 1,0,-1
+        ans = (self.input - self.in2) / 2
+        if ans < 0 and self.input < 0:
+            return -1 * ans
+        return ans
+
+
+class TestComposition(unittest.TestCase):
+    def setUp(self) -> None:
+        self.comp2 = MockComponent()
+        self.comp = MockComponent(comp=self.comp2)
+        self.system = MockSystem(input=5, comp=self.comp)
+
+    def test_signals(self):
+        self.system.post_sig.signal.mode = "post"  # usually its both
+
+        # Pre Signals Test
+        outsys = self.system.output
+        outcomp = self.system.comp.output
+        sysstart = self.system.input
+        compstart = self.system.comp.input
+        self.assertNotEqual(sysstart, compstart)  # no signals transfering input
+
+        log.warning(f"test signals: {sysstart} {compstart}| {outsys} {outcomp}")
+        with ProblemExec(self.system, {}, post_exec=True, pre_exec=True) as pbx:
+            sysend = self.system.input
+            compend = self.system.comp.input
+            self.assertEqual(sysend, compend)  # signals should work as defined
+            self.assertEqual(sysstart, sysend)  # input should remain the same
+            self.assertNotEqual(compstart, compend)  # input on comp changes
+
+            sysstart = self.system.output
+            compstart = self.system.comp.output
+            self.assertNotEqual(sysstart, compstart)  # they aren't aligned
+            log.info(f"pre-vert: {sysstart} {compstart}")
+
+            # preserve changes
+            pbx.exit_with_state()
+
+        # now post signals should be applied
+        sysend = self.system.output
+        compend = self.system.comp.output
+
+        log.info(f"final: {sysstart} {compstart}")
+
+        self.assertEqual(sysend, compend)  # signals should work
+        self.assertEqual(compstart, compend)  # output should change
+        self.assertNotEqual(sysstart, sysend)  # output should change
+
+    def test_input_and_run(self):
+        self.system.run(**{"comp.aux": 5, "comp.comp.aux": 6})
+        self.assertEqual(len(self.system.dataframe), 1, f"wrong run config")
+        self.assertEqual(set(self.system.dataframe["comp.aux"]), set([5]))
+        self.assertEqual(set(self.system.dataframe["comp.comp.aux"]), set([6]))
+
+        # internal storage
+        # self.assertEqual(set(self.system.comp.dataframe["aux"]), set([5]))
+        # self.assertEqual(set(self.system.comp.comp.dataframe["aux"]), set([6]))
+
+
+#         # solver constraints checking
+#         input = self.system.dataframe["input"][0]
+#         self.assertGreaterEqual(input, -1e3)  # min protection
+#         self.assertLessEqual(input, 1)  # max protection
+#
+#         in2 = self.system.dataframe["in2"][0]
+#         self.assertGreaterEqual(in2, -1e3)  # min protection
+#         self.assertLessEqual(in2, 4 - input)  # max protection