engforge 0.3.0__py3-none-any.whl

engforge/test/test_performance.py

@@ -0,0 +1,93 @@
+# TODO:
+# 1. ensure total evaluation time is not in Refs
+# 2. minimize call redundancy (how)
+# 3. validate caching performance and safe reset of values
+
+from engforge._testing_components import *
+from engforge.logging import LoggingMixin
+from cProfile import Profile
+from pstats import Stats
+import unittest
+import time
+
+
+class PerfTest(LoggingMixin):
+    pass
+
+
+log = PerfTest()
+
+
+def eval_steady_state(dxdt=0):
+    """test that the ss answer is equal to the result with damping"""
+    sm = SpringMass()
+    sm.run(dxdt=dxdt, combos="time")
+    df = sm.dataframe
+
+
+def eval_transient(endtime=10, dt=0.001, run_solver=False):
+    """test that the ss answer is equal to the result with damping"""
+    sm = SpringMass()
+    df = sm.simulate(dt=dt, endtime=endtime, run_solver=run_solver)
+
+
+class TestPerformance(unittest.TestCase):
+    def test_steady_state(self):
+        with Profile() as pr:
+            start = time.time()
+            eval_steady_state()
+
+        stats = Stats(pr)
+        stats.sort_stats("tottime").print_stats(10)
+
+        end = time.time()
+        self.assertLessEqual((end - start), 1.0)
+
+    def test_transient(self):
+        endtime = 10
+        with Profile() as pr:
+            start = time.time()
+            eval_transient(endtime=endtime, dt=0.001, run_solver=False)
+
+        stats = Stats(pr)
+        stats.sort_stats("tottime").print_stats(10)
+        end = time.time()
+        self.assertLessEqual((end - start), endtime)
+
+
+if __name__ == "__main__":
+    import sys
+    import argparse
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "-ss",
+        "--steady-state",
+        action="store_true",
+        dest="steady_state",
+        help="run the steady state test",
+    )
+    parser.add_argument(
+        "-tr",
+        "--transient",
+        action="store_true",
+        dest="transient",
+        help="run the transient test",
+    )
+    parser.add_argument(
+        "-a", "--all", action="store_true", dest="all", help="run all tests"
+    )
+    parser.add_argument("-b", "--base", action="store_true", help="run all tests")
+
+    args = parser.parse_args()
+
+    run_all = True if not sys.argv else args.all
+
+    if not args.base:
+        log.info(f"running all: {run_all} | {sys.argv}")
+        if args.steady_state or run_all:
+            log.info(f"running steady state test")
+            eval_steady_state()
+        if args.transient or run_all:
+            log.info(f"running transient integration test")
+            eval_transient()

engforge/test/test_pipes.py

@@ -0,0 +1,49 @@
+from engforge.eng.pipes import *
+from engforge.eng.fluid_material import *
+
+import unittest
+
+
+class TestPipes(unittest.TestCase):
+    def test_pipe_analysis(self):
+        n1 = FlowInput(x=0, y=0, z=0, flow_in=-0.1)
+        n2 = PipeNode(x=10, y=0, z=0)
+        n3 = PipeNode(x=0, y=10, z=0)
+        n4 = PipeNode(x=10, y=10, z=0)
+        n5 = FlowInput(x=20, y=10, z=0, flow_in=0.1)
+
+        n2z = PipeNode(x=10, y=0, z=5, name="n2z")
+        n3z = PipeNode(x=0, y=10, z=5, name="n3z")
+        n4z = PipeNode(x=10, y=10, z=5, name="n4z")
+        n4zo = FlowInput(x=0, y=0, z=0, flow_in=-0.5)
+
+        n2za = PipeNode(x=10, y=0, z=10)
+        n3za = PipeNode(x=0, y=10, z=10)
+        n4za = PipeNode(x=10, y=10, z=10)
+        n2zoa = FlowInput(x=10, y=5, z=15, flow_in=0.6)
+
+        pipe1 = Pipe(v=random.random(), D=0.1 * random.random(), node_s=n1, node_e=n2)
+        pipe2 = Pipe(v=random.random(), D=0.1 * random.random(), node_s=n1, node_e=n3)
+        pipe3 = Pipe(v=random.random(), D=0.1, node_s=n2, node_e=n4)
+        pipe4 = Pipe(v=random.random(), D=0.1 * random.random(), node_s=n3, node_e=n4)
+        pipe5 = Pipe(v=random.random(), D=0.1 * random.random(), node_s=n4, node_e=n5)
+
+        pipe5 = Pipe(v=random.random(), D=0.1 * random.random(), node_s=n2z, node_e=n2)
+        pipe6 = Pipe(v=random.random(), D=0.1 * random.random(), node_s=n3, node_e=n3z)
+        pipe7 = Pipe(v=random.random(), D=0.1 * random.random(), node_s=n4, node_e=n4z)
+        pipe8 = Pipe(v=random.random(), D=0.1 * random.random(), node_s=n2, node_e=n4z)
+        pipe9 = Pipe(
+            v=random.random(), D=0.1 * random.random(), node_s=n4zo, node_e=n4z
+        )
+        pipe10 = Pipe(
+            v=random.random(), D=0.1 * random.random(), node_s=n3z, node_e=n2z
+        )
+
+        # pipe10 = Pipe(v=random.random(),D=0.1*random.random(),node_s=n3za,node_e=n4)
+        # pipe11 = Pipe(v=random.random(),D=0.1*random.random(),node_s=n2za,node_e=n2zoa)
+        # pipe12 = Pipe(v=random.random(),D=0.1*random.random(),node_s=n4za,node_e=n3z)
+        # pipe13 = Pipe(v=random.random(),D=0.1*random.random(),node_s=n3,node_e=n2za)
+        # pipe13 = Pipe(v=random.random(),D=0.1*random.random(),node_s=n1,node_e=n4z)
+
+        ps = PipeSystem(in_node=n1)
+        ps.draw()

engforge/test/test_problem.py

@@ -0,0 +1,411 @@
+import unittest
+from engforge.problem_context import *
+from engforge.system import System, forge
+from engforge._testing_components import *
+import random
+
+
+@forge(auto_attribs=True)
+class SimpleContext(System):
+    one: int = 1
+    two: int = 2
+
+    def set_rand(self):
+        self.one = random.random()
+        self.two = random.random()
+
+    def __str__(self):
+        return f"{self.one}_{self.two}"
+
+
+chk = lambda d, k: set(d.get(k)) if k in d else set()
+
+
+class TestSession(unittest.TestCase):
+    """Test lifecycle of a problem and IO of the context"""
+
+    def test_system_last_context(self):
+        sm = SpringMass(Fa=0, u=5)
+        sm.run(dxdt=0, combos="time")
+        ssid = sm.last_context.session_id
+        sm.run(dxdt=0, combos="time")
+        trid = sm.last_context.session_id
+        self.assertNotEqual(ssid, trid, "Session ID should change after a run")
+
+    def test_system_change_context(self):
+        sm = SpringMass(Fa=0, u=5)
+        sm.run(dxdt=0, combos="time")
+        ssid = sm.last_context.session_id
+        trsm, df = sm.simulate(dt=0.01, endtime=0.1, return_all=True)
+        trid = trsm.last_context.session_id
+        self.assertNotEqual(ssid, trid, "Session ID should change after a run")
+
+    def test_slide_crank_empty(self):
+        sm = SliderCrank(Tg=0)
+        pbx = ProblemExec(sm, {"combos": "", "slv_vars": "", "dxdt": None})
+        atx = pbx.ref_attrs
+        self.assertEqual(chk(atx, "solver.var"), set())
+        self.assertEqual(chk(atx, "solver.obj"), set())
+        self.assertEqual(chk(atx, "solver.ineq"), set())
+        self.assertEqual(chk(atx, "solver.eq"), set())
+        self.assertEqual(chk(atx, "dynamics.output"), set())
+        self.assertEqual(chk(atx, "dynamics.rate"), set())
+        self.assertEqual(chk(atx, "dynamics.state"), set())
+        self.assertEqual(chk(atx, "dynamics.input"), set())
+
+        cons = pbx.constraints
+        self.assertEqual(cons["constraints"], [])
+        self.assertEqual(len(cons["bounds"]), len(atx["solver.var"]))
+
+    def test_slide_crank_dflt(self):
+        sm = SliderCrank(Tg=0)
+        pbx = ProblemExec(sm, {"dxdt": None})
+        atx = pbx.ref_attrs
+        self.assertEqual(chk(atx, "solver.var"), set())
+        self.assertEqual(chk(atx, "solver.obj"), set())
+        self.assertEqual(chk(atx, "solver.ineq"), set())
+        self.assertEqual(chk(atx, "solver.eq"), set())
+        self.assertEqual(chk(atx, "dynamics.output"), set())
+        self.assertEqual(chk(atx, "dynamics.rate"), set())
+        self.assertEqual(chk(atx, "dynamics.state"), set())
+        self.assertEqual(chk(atx, "dynamics.input"), set())
+
+        cons = pbx.constraints
+        self.assertEqual(len(cons["constraints"]), 0)
+        self.assertEqual(len(cons["bounds"]), 0)
+
+    def test_slide_crank_dxdt_true(self):
+        sm = SliderCrank(Tg=0)
+        pbx = ProblemExec(sm, {"dxdt": True})
+        atx = pbx.ref_attrs
+        self.assertEqual(chk(atx, "solver.var"), set())
+        self.assertEqual(chk(atx, "solver.obj"), set())
+        self.assertEqual(chk(atx, "solver.ineq"), set())
+        self.assertEqual(chk(atx, "solver.eq"), set())
+        self.assertEqual(chk(atx, "dynamics.output"), set())
+        self.assertEqual(chk(atx, "dynamics.rate"), set(("omega", "theta")))
+        self.assertEqual(chk(atx, "dynamics.state"), set(("omega", "theta")))
+        self.assertEqual(chk(atx, "dynamics.input"), set(("Tg",)))
+
+        cons = pbx.constraints
+        self.assertEqual(cons["constraints"], [])
+        self.assertEqual(len(cons["bounds"]), len(atx["solver.var"]))
+
+    def test_slide_crank_dxdt_zero(self):
+        sm = SliderCrank(Tg=0)
+        pbx = ProblemExec(sm, {"dxdt": 0})
+        atx = pbx.ref_attrs
+        self.assertEqual(chk(atx, "solver.var"), set())
+        self.assertEqual(chk(atx, "solver.obj"), set())
+        self.assertEqual(chk(atx, "solver.ineq"), set())
+        self.assertEqual(chk(atx, "solver.eq"), set())
+        self.assertEqual(chk(atx, "dynamics.output"), set())
+        self.assertEqual(chk(atx, "dynamics.rate"), set(("omega", "theta")))
+        self.assertEqual(chk(atx, "dynamics.state"), set(("omega", "theta")))
+        self.assertEqual(chk(atx, "dynamics.input"), set(("Tg",)))
+
+        cons = pbx.constraints
+        self.assertEqual(len(cons["constraints"]), 2)
+        self.assertEqual(len(cons["bounds"]), 2)
+
+    def test_slide_crank_design(self):
+        sm = SliderCrank(Tg=0)
+        pbx = ProblemExec(sm, {"combos": "design,cost", "dxdt": None})
+        atx = pbx.ref_attrs
+        self.assertEqual(
+            chk(atx, "solver.var"),
+            set(("Lo", "Rc", "Ro", "x_offset", "y_offset")),
+        )
+        self.assertEqual(chk(atx, "solver.obj"), set(("cost_slv",)))
+        self.assertEqual(
+            chk(atx, "solver.ineq"),
+            set(("crank_pos_slv", "gear_pos_slv", "motor_pos_slv")),
+        )
+        self.assertEqual(chk(atx, "solver.eq"), set(()))
+        self.assertEqual(chk(atx, "dynamics.output"), set())
+        self.assertEqual(chk(atx, "dynamics.rate"), set())
+        self.assertEqual(chk(atx, "dynamics.state"), set())
+        self.assertEqual(chk(atx, "dynamics.input"), set())
+
+        cons = pbx.constraints
+        self.assertEqual(len(cons["constraints"]), 4)
+        self.assertEqual(len(cons["bounds"]), 5)
+
+    def test_slide_crank_design_one_match(self):
+        sm = SliderCrank(Tg=0)
+        pbx = ProblemExec(sm, {"combos": "design", "dxdt": None, "both_match": False})
+        atx = pbx.ref_attrs
+        self.assertEqual(
+            chk(atx, "solver.var"),
+            set(("Lo", "Rc", "Ro", "x_offset", "y_offset", "X_spring_center")),
+        )
+        self.assertEqual(chk(atx, "solver.obj"), set(("cost_slv", "sym_slv")))
+        self.assertEqual(
+            chk(atx, "solver.ineq"),
+            set(("crank_pos_slv", "gear_pos_slv", "motor_pos_slv", "size")),
+        )
+        self.assertEqual(chk(atx, "solver.eq"), set(("gear_speed_slv", "range_slv")))
+        self.assertEqual(chk(atx, "dynamics.output"), set())
+        self.assertEqual(chk(atx, "dynamics.rate"), set())
+        self.assertEqual(chk(atx, "dynamics.state"), set())
+        self.assertEqual(chk(atx, "dynamics.input"), set())
+
+        cons = pbx.constraints
+        self.assertEqual(len(cons["constraints"]), 7)
+        self.assertEqual(len(cons["bounds"]), 6)
+
+    def test_slide_crank_design_slv_design(self):
+        sm = SliderCrank(Tg=0)
+        pbx = ProblemExec(sm, {"combos": "design", "slv_vars": "*slv", "dxdt": None})
+        atx = pbx.ref_attrs
+        self.assertEqual(chk(atx, "solver.var"), set())
+        self.assertEqual(chk(atx, "solver.obj"), set(()))
+        self.assertEqual(
+            chk(atx, "solver.ineq"),
+            set(("crank_pos_slv", "gear_pos_slv", "motor_pos_slv")),
+        )
+        self.assertEqual(chk(atx, "solver.eq"), set(()))
+        self.assertEqual(chk(atx, "dynamics.output"), set())
+        self.assertEqual(chk(atx, "dynamics.rate"), set())
+        self.assertEqual(chk(atx, "dynamics.state"), set())
+        self.assertEqual(chk(atx, "dynamics.input"), set())
+
+        cons = pbx.constraints
+        self.assertEqual(len(cons["constraints"]), 3)
+        self.assertEqual(len(cons["bounds"]), 0)
+
+    def test_slide_crank_design_slv(self):
+        sm = SliderCrank(Tg=0)
+        pbx = ProblemExec(
+            sm,
+            {
+                "combos": "design,cost,speed_goal,range_goal",
+                "ign_combos": "max*",
+                "slv_vars": "*slv",
+                "dxdt": None,
+            },
+        )
+        atx = pbx.ref_attrs
+        self.assertEqual(chk(atx, "solver.var"), set())
+        self.assertEqual(chk(atx, "solver.obj"), set(("cost_slv",)))
+        self.assertEqual(
+            chk(atx, "solver.ineq"),
+            set(("crank_pos_slv", "gear_pos_slv", "motor_pos_slv")),
+        )
+        self.assertEqual(chk(atx, "solver.eq"), set(("gear_speed_slv", "range_slv")))
+        self.assertEqual(chk(atx, "dynamics.output"), set())
+        self.assertEqual(chk(atx, "dynamics.rate"), set())
+        self.assertEqual(chk(atx, "dynamics.state"), set())
+        self.assertEqual(chk(atx, "dynamics.input"), set())
+
+        cons = pbx.constraints
+        self.assertEqual(len(cons["constraints"]), 5)
+        self.assertEqual(len(cons["bounds"]), len(atx["solver.var"]))
+
+    def test_slide_crank_design_slv_one_match(self):
+        sm = SliderCrank(Tg=0)
+        pbx = ProblemExec(
+            sm,
+            {
+                "combos": "design",
+                "ign_combos": "max*",
+                "slv_vars": "*slv",
+                "dxdt": None,
+                "both_match": False,
+            },
+        )
+        atx = pbx.ref_attrs
+        self.assertEqual(
+            chk(atx, "solver.var"),
+            set(("Lo", "Rc", "Ro", "x_offset", "y_offset")),
+        )
+        self.assertEqual(chk(atx, "solver.obj"), set(("cost_slv", "sym_slv")))
+        self.assertEqual(
+            chk(atx, "solver.ineq"),
+            set(("crank_pos_slv", "gear_pos_slv", "motor_pos_slv")),
+        )
+        self.assertEqual(chk(atx, "solver.eq"), set(("gear_speed_slv", "range_slv")))
+        self.assertEqual(chk(atx, "dynamics.output"), set())
+        self.assertEqual(chk(atx, "dynamics.rate"), set())
+        self.assertEqual(chk(atx, "dynamics.state"), set())
+        self.assertEqual(chk(atx, "dynamics.input"), set())
+
+        cons = pbx.constraints
+        self.assertEqual(len(cons["constraints"]), 6)
+        self.assertEqual(len(cons["bounds"]), len(atx["solver.var"]))
+
+    def test_slide_crank_add_var(self):
+        sc = SliderCrank()
+        out = sc.run(
+            combos="design,speed_goal,range_goal",
+            slv_vars="*",
+            revert_last=False,
+            add_vars="*gear*",
+            both_match=False,
+        )
+        # self.assertEqual(len(out['gear_speed_slv']),0)
+        print(out)
+
+
+class TestContextExits(unittest.TestCase):
+    def tearDown(self) -> None:
+        self.assertFalse(
+            hasattr(ProblemExec.class_cache, "session"), msg="not cleaned!"
+        )
+
+    def test_error_exit(self):
+        tst = SimpleContext()
+
+        class TestError(Exception):
+            pass
+
+        with self.assertRaises(TestError):  # we should get an error
+            with ProblemExec(tst) as pb1:
+                tst.set_rand()
+                with ProblemExec(tst, level_name="2") as pb2:
+                    tst.set_rand()
+                    with ProblemExec(tst) as pb3:
+                        tst.set_rand()
+                        raise TestError(
+                            "pocket-sand"
+                        )  # TODO: INSERT KING OF THE HILL REFERENCE
+        self.assertFalse(hasattr(ProblemExec.class_cache, "session"))
+
+    def test_context_singularity(self):
+        tst = SimpleContext()
+
+        with ProblemExec(tst) as pb1:
+            self.assertEqual(pb1, tst.last_context)
+            self.assertTrue(pb1.entered)
+            self.assertFalse(pb1.exited)
+            with ProblemExec(tst, level_name="2") as pb2:
+                self.assertIs(pb1, pb2)
+                self.assertTrue(pb1.entered)
+                self.assertFalse(pb1.exited)
+                with ProblemExec(tst) as pb3:
+                    self.assertIs(pb1, pb3)
+                    self.assertTrue(pb3.entered)
+                    self.assertFalse(pb3.exited)
+                    pb3.exit_to_level("top", revert=True)
+                    raise Exception("Wrong Level")
+                raise Exception("Wrong Level")
+            raise Exception("Wrong Level")
+        self.assertEqual(pb1, tst.last_context)
+        self.assertTrue(pb1.entered)
+        self.assertTrue(pb1.exited)
+
+    def test_exit_top(self):
+        tst = SimpleContext()
+
+        with ProblemExec(tst) as pb1:
+            tst.set_rand()
+            with ProblemExec(tst, level_name="2") as pb2:
+                tst.set_rand()
+                with ProblemExec(tst) as pb3:
+                    tst.set_rand()
+                    pb3.exit_to_level("top", revert=True)
+                    raise Exception("Wrong Level")
+                raise Exception("Wrong Level")
+            raise Exception("Wrong Level")
+        self.assertEqual(tst.one, 1)
+        self.assertEqual(tst.two, 2)
+
+    def test_exit_top_with_state(self):
+        tst = SimpleContext()
+
+        with ProblemExec(tst, level_name="super") as pb1:
+            tst.set_rand()
+            with ProblemExec(tst, level_name="2") as pb2:
+                tst.set_rand()
+                with ProblemExec(tst) as pb3:
+                    tst.set_rand()
+                    final_one = tst.one
+                    final_two = tst.two
+                    pb3.exit_to_level("top", revert=False)
+                    raise Exception("Wrong Level")
+                raise Exception("Wrong Level")
+            raise Exception("Wrong Level")
+        self.assertEqual(tst.one, final_one)
+        self.assertEqual(tst.two, final_two)
+
+    def test_exit_2_with_state(self):
+        tst = SimpleContext()
+
+        with ProblemExec(tst) as pb1:
+            tst.set_rand()
+            with ProblemExec(tst, level_name="2") as pb2:
+                tst.set_rand()
+                with ProblemExec(tst) as pb3:
+                    tst.set_rand()
+                    final_one = tst.one
+                    final_two = tst.two
+                    pb3.exit_to_level("2", revert=False)
+                    raise Exception("Wrong Level")
+            self.assertEqual(tst.one, final_one)
+            self.assertEqual(tst.two, final_two)
+        self.assertEqual(tst.one, 1)
+        self.assertEqual(tst.two, 2)
+
+    def test_exit_2_wo_state(self):
+        tst = SimpleContext()
+        with ProblemExec(tst) as pb1:
+            tst.set_rand()
+            final_one = tst.one
+            final_two = tst.two
+            with ProblemExec(tst, level_name="2") as pb2:
+                tst.set_rand()
+                with ProblemExec(tst) as pb3:
+                    tst.set_rand()
+                    pb3.exit_to_level("2", revert=True)
+                    raise Exception("Wrong Level")
+            self.assertEqual(tst.one, final_one)
+            self.assertEqual(tst.two, final_two)
+        self.assertEqual(tst.one, 1)
+        self.assertEqual(tst.two, 2)
+
+    def test_exit_with_state(self):
+        tst = SimpleContext()
+
+        with ProblemExec(tst) as pb1:
+            tst.set_rand()
+            mid_one = tst.one
+            mid_two = tst.two
+            with ProblemExec(tst, level_name="2") as pb2:
+                tst.set_rand()
+                final_one = tst.one
+                final_two = tst.two
+                with ProblemExec(tst) as pb3:
+                    tst.set_rand()
+                    final_one = tst.one
+                    final_two = tst.two
+                    pb3.exit_with_state()
+                    raise Exception("Wrong Level")
+                self.assertEqual(tst.one, final_one)
+                self.assertEqual(tst.two, final_two)
+            self.assertEqual(tst.one, mid_one)
+            self.assertEqual(tst.two, mid_two)
+        self.assertEqual(tst.one, 1)
+        self.assertEqual(tst.two, 2)
+
+    def test_exit_and_revert(self):
+        tst = SimpleContext()
+
+        with ProblemExec(tst) as pb1:
+            tst.set_rand()
+            mid_one = tst.one
+            mid_two = tst.two
+            with ProblemExec(tst, level_name="2") as pb2:
+                tst.set_rand()
+                final_one = tst.one
+                final_two = tst.two
+                with ProblemExec(tst) as pb3:
+                    tst.set_rand()
+
+                    pb3.exit_and_revert()
+                    raise Exception("Wrong Level")
+                self.assertEqual(tst.one, final_one)
+                self.assertEqual(tst.two, final_two)
+            self.assertEqual(tst.one, mid_one)
+            self.assertEqual(tst.two, mid_two)
+        self.assertEqual(tst.one, 1)
+        self.assertEqual(tst.two, 2)

engforge/test/test_problem_deepscoping.py

@@ -0,0 +1,68 @@
+from engforge import *
+
+import unittest
+import attrs
+import random
+
+
+def test_obj(sys, prob):
+    # print('obj',sys, prob)
+    comp = sys
+    assert comp is not prob.system, f"{comp} is problems system, in sub comp"
+    return comp.val - comp.comp_val
+
+
+def test_con(sys, prob):
+    # print('con',sys, prob)
+    comp = sys
+    assert comp is not prob.system, f"{comp} is problems system, in sub comp"
+    return -1
+
+
+def test_zero(sys, prob):
+    # print('zero',sys, prob)
+    comp = sys
+    assert comp is not prob.system, f"{comp} is problems system, in sub comp"
+    return 0
+
+
+@forge
+class TestComp(Component):
+    val = attrs.field(factory=random.random, type=float)
+    val_var = Solver.declare_var("val")
+
+    comp_val = attrs.field(default=0, type=float)
+    slv_var = Solver.declare_var("comp_val")
+    slv_var.add_var_constraint(1.0, kind="max")
+    slv_var.add_var_constraint(test_con, kind="min")
+
+    var_obj = Solver.objective(test_obj)
+    var_ineq = Solver.con_ineq(test_zero)
+    var_2ineq = Solver.con_ineq(test_zero, test_zero)
+    var_eq = Solver.con_eq(test_zero)
+    var_2eq = Solver.con_eq(test_zero, test_zero)
+
+
+@forge
+class DeepComp(TestComp):
+    comp = Slot.define(TestComp, default_ok=False, none_ok=True)
+
+
+@forge
+class DeepSys(System):
+    comp = Slot.define(DeepComp)
+
+
+class TestDeep(unittest.TestCase):
+    def test_one_deep(self):
+        comp = DeepComp(comp=None)
+        sys = DeepSys(comp=comp)
+
+        sys.run(combos="default", slv_vars="*")
+
+
+if __name__ == "__main__":
+    comp = DeepComp(comp=None)
+    sys = DeepSys(comp=comp)
+    # sys.change_all_log_lvl(1)
+    sys.run(combos="default", slv_vars="*")

engforge/test/test_slider_crank.py

@@ -0,0 +1,51 @@
+import unittest
+import numpy as np
+
+from engforge._testing_components import *
+
+
+class TestSliderCrank(unittest.TestCase):
+    def test_optimization(self):
+        sc = SliderCrank()
+
+        out = sc.run(combos="design", slv_vars="*")
+
+    def test_design_multiobj(self):
+        sc = SliderCrank()
+
+        out = sc.run(
+            combos="design,*goal,*sym",
+            slv_vars="*",
+            k_spring=10,
+            revert_last=False,
+            revert_every=False,
+        )
+
+        out = out["output"][0]
+        Yobj = set(out["Yobj"])
+        self.assertEqual(set(("sym_slv",)), Yobj)
+
+        self.assertAlmostEqual(sc.dx_goal, 0.0, places=3)
+        self.assertAlmostEqual(sc.ds_goal, 0.0, places=3)
+
+
+# BUG:
+# ======================================================================
+# FAIL: test_design_objs (test_slider_crank.TestSliderCrank)
+# ----------------------------------------------------------------------
+# Traceback (most recent call last):
+#   File "/mnt/c/Users/Sup/Ottermatics Dropbox/Ottermatics/engforge/engforge/test/test_slider_crank.py", line 34, in test_design_objs
+#     self.assertEqual(set(('sym_slv',)),Yobj)
+# AssertionError: Items in the second set but not the first:
+# 'cost_slv'
+#     def test_design_objs(self):
+#         sc = SliderCrank()
+#
+#         out = sc.run(combos='design,*goal,*sym,*cost',slv_vars='*',k_spring=10,revert_last=False,revert_every=False)
+#
+#         out = out['output'][0]
+#         Yobj = set(out['Yobj'])
+#         self.assertEqual(set(('sym_slv',)),Yobj)
+#
+#         self.assertAlmostEqual(sc.dx_goal,0.0,places=3)
+#         self.assertAlmostEqual(sc.ds_goal,0.0,places=3)