engforge 0.3.0__py3-none-any.whl

engforge/test/test_costs.py

@@ -0,0 +1,338 @@
+"""Testing of costs reporting module
+- emphasis on recursive testing w/o double accounting on instance basis (id!)
+- emphasis on default / subclass adjustments
+"""
+
+import unittest
+from engforge.components import Component
+from engforge._testing_components import *
+
+
+class TestEconDefaults(unittest.TestCase):
+    def tearDown(self) -> None:
+        Comp1.reset_cls_costs()
+        EconDefault.reset_cls_costs()
+
+    def test_custom_costs(self):
+        ed = EconDefault()
+        self.assertNotIn("comp1", ed.internal_components())
+
+        ed.custom_cost("comp1", Comp1())
+        self.assertIn("comp1", ed.internal_components())
+
+    def test_non_costmodel_default(self):
+        EconDefault.default_cost("comp", Comp1(cost_per_item=10))
+        ed = EconDefault(comp=Component())
+        ed.run()
+        self.assertEqual(ed.combine_cost, 10)
+        self.assertEqual(ed.econ.combine_cost, 10)
+
+
+class TestCategoriesAndTerms(unittest.TestCase):
+    def tearDown(self) -> None:
+        Comp1.reset_cls_costs()
+        Comp2.reset_cls_costs()
+        EconRecursive.reset_cls_costs()
+        TermCosts.reset_cls_costs()
+
+    def test_itemized_costs(self):
+        tc = TermCosts()
+
+        ct = tc.costs_at_term(0)
+        self.assertEqual(ct["cost_init"], 100)
+        self.assertEqual(ct["cost_maintenance"], 0)
+        self.assertEqual(ct["cost_tax"], 1)
+        self.assertEqual(ct["cost_wage_tax"], 0)
+
+        ct = tc.costs_at_term(1)
+        self.assertEqual(ct["cost_init"], 00)
+        self.assertEqual(ct["cost_maintenance"], 10)
+        self.assertEqual(ct["cost_tax"], 1)
+        self.assertEqual(ct["cost_wage_tax"], 0)
+
+        ct = tc.costs_at_term(2)
+        self.assertEqual(ct["cost_init"], 00)
+        self.assertEqual(ct["cost_maintenance"], 10)
+        self.assertEqual(ct["cost_tax"], 1)
+        self.assertEqual(ct["cost_wage_tax"], 15)
+
+    def test_category_costs(self):
+        tc = TermCosts()
+        cc = tc.cost_categories_at_term(0)
+        self.assertEqual(cc["capex"], 100)
+        self.assertEqual(cc["opex"], 0)
+        self.assertEqual(cc["tax"], 1)
+
+        tc = TermCosts()
+        cc = tc.cost_categories_at_term(2)
+        self.assertEqual(cc["capex"], 0)
+        self.assertEqual(cc["opex"], 25)
+        self.assertEqual(cc["tax"], 16)
+
+    def test_econ(self):
+        tc = TermCosts()
+        Comp2.default_cost("comp1", 50)
+        c2 = Comp2(cost_per_item=10)
+        er = EconRecursive(comp1=tc, comp2=c2)
+        # inkw = {'econ_term_length':[1,5,10,50],'econ_discount_rate':[0,0.01,0.05,0.1]}
+        inkw = {}
+        er.run(revert_last=False, **inkw)
+
+        d = er.data_dict
+
+        self.assertEqual(d["econ.lifecycle.term_cost"], 161)
+        self.assertEqual(d["econ.summary.total_cost"], 161)
+        self.assertEqual(d["combine_cost"], 161)
+        self.assertEqual(d["sub_items_cost"], 161)
+
+    def test_econ_array(self):
+        tc = TermCosts()
+        Comp2.default_cost("comp1", 50)
+        c2 = Comp2(cost_per_item=10)
+        er = EconRecursive(comp1=tc, comp2=c2)
+        inkw = {"econ.term_length": [0, 5, 10, 15], "econ.fixed_output": 1}
+        # inkw = {}
+        er.run(revert_last=False, revert_every=False, **inkw)
+
+        df = er.dataframe
+        tc = (
+            df["econ.summary.total_cost"] == np.array([161.0, 220.0, 305.0, 390.0])
+        ).all()
+        self.assertTrue(tc)
+
+
+class TestEconomicsAccounting(unittest.TestCase):
+    def setUp(self) -> None:
+        pass
+
+    def tearDown(self) -> None:
+        Comp1.reset_cls_costs()
+        Comp2.reset_cls_costs()
+        EconRecursive.reset_cls_costs()
+
+    def test_econ_defaults(self):
+        Comp1.default_cost("norm", Norm(cost_per_item=10))
+        Comp2.default_cost("comp1", Comp1(cost_per_item=5))
+        EconRecursive.default_cost("comp2", Comp2(cost_per_item=3))
+        er = EconRecursive(cost_per_item=50)
+        # c2 = er.comp2
+        self.assertEqual(er.combine_cost, 78)
+        self.assertEqual(er.sub_items_cost, 28)
+
+        er.run()
+        d = er.data_dict
+        self.assertEqual(78, d["econ.summary.total_cost"])
+        self.assertEqual(78, d["econ.lifecycle.annualized.term_cost"])
+        self.assertEqual(78, d["econ.lifecycle.annualized.levelized_cost"])
+        self.assertEqual(78, d["econ.lifecycle.term_cost"])
+
+    def test_recursive_null(self, ANS=75):
+        Comp1.default_cost("norm", 5)
+        Comp2.default_cost("comp1", 10)
+        EconRecursive.default_cost("comp1", 3)
+        EconRecursive.default_cost("comp2", 7)
+        er = EconRecursive(cost_per_item=50, comp1=None, comp2=None)
+        er.run()
+        self.assertEqual(er.combine_cost, ANS)
+        self.assertEqual(er.econ.combine_cost, ANS)
+        self.assertEqual(er.comp1, None)
+        self.assertEqual(er.comp2, None)
+
+        d = er.data_dict
+        self.assertEqual(ANS, d["econ.combine_cost"])
+        self.assertEqual(ANS, d["combine_cost"])
+        self.assertEqual(3, d["econ.comp1.cost.item_cost"])
+        self.assertEqual(7, d["econ.comp2.cost.item_cost"])
+
+    def test_recursive_comp2(self, ANS=80):
+        Comp1.default_cost("norm", 5)
+        Comp2.default_cost("comp1", 10)
+        EconRecursive.default_cost("comp1", Comp1(cost_per_item=3))
+        EconRecursive.default_cost("comp2", Comp2(cost_per_item=7))
+        er = EconRecursive(cost_per_item=50, comp1=None, comp2=None)
+        er.run()
+        self.assertEqual(er.combine_cost, ANS)
+        self.assertEqual(er.econ.combine_cost, ANS)
+
+        d = er.data_dict
+        self.assertEqual(ANS, d["econ.combine_cost"])
+        self.assertEqual(ANS, d["combine_cost"])
+        self.assertEqual(3, d["econ.comp1.cost.item_cost"])
+        # self.assertEqual(10,d['econ_comp2.combine_cost'])
+
+    def test_recursive_all(self, ANS=80):
+        # FIXME: missing norm cost of -5
+
+        Comp1.default_cost("norm", 5)
+        Comp2.default_cost("comp1", 10)
+        EconRecursive.default_cost("comp1", Comp1(cost_per_item=3))
+        EconRecursive.default_cost("comp2", Comp2(cost_per_item=7))
+        er = EconRecursive(cost_per_item=50)
+        er.run()
+        self.assertEqual(er.combine_cost, ANS)
+        self.assertEqual(er.econ.combine_cost, ANS)
+
+        d = er.data_dict
+        self.assertEqual(ANS, d["econ.combine_cost"])
+        self.assertEqual(ANS, d["combine_cost"])
+        # self.assertEqual(5,d['econ_comp1.combine_cost'])
+        # self.assertEqual(10,d['econ_comp2.combine_cost'])
+        self.assertEqual(10, d["econ.comp2.comp1.cost.item_cost"])
+        self.assertEqual(5, d["econ.comp1.norm.cost.item_cost"])
+
+
+class TestCostModel(unittest.TestCase):
+    def setUp(self):
+        pass
+
+    def tearDown(self) -> None:
+        Comp1.reset_cls_costs()
+        Comp2.reset_cls_costs()
+
+    def test_comp1(self):
+        c0 = Comp1(cost_per_item=0)
+        self.assertEqual(c0.combine_cost, 0)
+
+        c1 = Comp1(cost_per_item=5)
+        self.assertEqual(c1.combine_cost, 5)
+
+        c2 = Comp1(cost_per_item=10)
+        self.assertEqual(c2.combine_cost, 10)
+
+    def test_comp2(self):
+        c1 = Comp1(cost_per_item=0)
+        c2 = Comp2(cost_per_item=0, comp1=c1)
+        self.assertEqual(c2.combine_cost, 0)
+
+        c1 = Comp1(cost_per_item=5)
+        c2 = Comp2(cost_per_item=5, comp1=c1)
+        self.assertEqual(c2.combine_cost, 10)
+
+        c1 = Comp1(cost_per_item=10)
+        c2 = Comp2(cost_per_item=10, comp1=c1)
+        self.assertEqual(c2.combine_cost, 20)
+
+    def test_default(self):
+        c1 = Comp1(cost_per_item=0)
+        self.assertEqual(c1.combine_cost, 0)
+
+        Comp1.default_cost("norm", 10)
+        c1 = Comp1(cost_per_item=0)
+        self.assertEqual(c1.combine_cost, 10)
+
+        c1 = Comp1(cost_per_item=0)
+        c1.custom_cost("norm", 20)
+        self.assertEqual(c1.combine_cost, 20)
+        self.assertEqual(Comp1._slot_costs["norm"], 10)
+
+    def test_ref_loop(self):
+        # Comp1.default_cost('norm',10)
+        c2 = Comp2(cost_per_item=5)
+        c1 = Comp1(cost_per_item=5, norm=c2)
+        c2.comp1 = c1
+        self.assertEqual(c1.combine_cost, 10)
+        self.assertEqual(c1.sub_items_cost, 10)
+
+    def test_override(self):
+        Comp1.default_cost("norm", 10)
+        # c2 = Comp2(cost_per_item=5)
+        c1 = Comp1(cost_per_item=5)  # ,norm=c2)
+        self.assertEqual(c1.combine_cost, 15)
+        self.assertEqual(c1.sub_items_cost, 10)
+
+        # Comp1.reset_cls_costs()
+        c2 = Comp2(cost_per_item=15)
+        c1 = Comp1(cost_per_item=15, norm=c2)
+        self.assertEqual(c1.combine_cost, 40)
+        self.assertEqual(c1.sub_items_cost, 25)
+
+    def test_defaults(self):
+        # Comp1.reset_cls_costs()
+        Comp1.default_cost("norm", Norm(cost_per_item=10))
+        Comp2.default_cost("comp1", Comp1(cost_per_item=5))
+        c2 = Comp2(cost_per_item=3)
+        self.assertEqual(c2.combine_cost, 18)
+        self.assertEqual(c2.sub_items_cost, 15)
+
+
+class TestFanSystemDataFrame(unittest.TestCase):
+    def test_dataframe(self):
+        # Create the FanSystem instance
+        fs = FanSystem(fan=Fan(), motor=Motor(), base=MetalBase())
+        fs.run(
+            **{
+                "econ.term_length": [1, 10, 20, 50],
+                "fan.V": [1, 5, 10],
+                "fan.area": [1, 5, 10],
+            },
+            base=[None, MetalBase()],
+        )
+
+        # Get the dataframe
+        df_complete = fs.last_context.dataframe
+
+        dfc = df_complete
+        match = (
+            dfc["fan.blade_cost"] + dfc["motor.motor_cost"]
+            == dfc["econ.lifecycle.category.capex"]
+        ).all()
+        self.assertTrue(match)
+
+        match = (
+            df_complete["fan.area"] * df_complete["fan.v"]
+            == df_complete["fan.volumetric_flow"]
+        ).all()
+        self.assertTrue(match)
+
+
+# TODO: get cost accounting working for ComponentIter components
+# @forge
+# class CompGroup(ComponentIterator):
+#     pass
+# # @forge
+# # class CostGroup(CompGroup,CostModel):
+# #     pass
+
+# @forge
+# class EconWide(System):
+#     econ = Slot.define(Economics)
+#     comp_set = Slot.define_iterator(CompGroup,wide=True)
+#
+# @forge
+# class EconNarrow(System):
+#     econ = Slot.define(Economics)
+#     comp_set = Slot.define_iterator(CompGroup,wide=False)
+
+# class TestEconomicsIter(unittest.TestCase):
+#
+#     def tearDown(self):
+#         Comp1.reset_cls_costs()
+#         Comp2.reset_cls_costs()
+#         EconWide.reset_cls_costs()
+#         EconNarrow.reset_cls_costs()
+#         CostGroup.reset_cls_costs()
+#
+#     def test_comp_wide(self):
+#
+#     def test_comp_narrow(self):
+#
+#     def test_cost_wide(self):
+#
+#     def test_comp_narrow(self):
+#         cg = CompGroup(component_type=Comp1)
+#         total = 0
+#         for i in range(11):
+#             cg.data.append(Comp1(cost_per_item=i))
+#             total += i
+#
+#         ew = EconNarrow(comp_set = cg)
+#         ew.run()
+#
+#         d = ew.data_dict
+#         self.assertEqual(d['econ_comp_set.item_cost'], ew.comp_set.current.item_cost)
+#         self.assertEqual(ew.econ.total_cost,total)
+#         self.assertEqual(ew.econ.total_cost,total)
+
+
+if __name__ == "__main__":
+    unittest.main()

engforge/test/test_dynamics.py

@@ -0,0 +1,109 @@
+"""test transient cases and match against real world results"""
+
+import unittest
+
+from engforge import *
+from engforge.attr_plotting import *
+from engforge._testing_components import SpringMass
+
+from scipy.optimize import curve_fit, least_squares
+import numpy as np
+from matplotlib.pyplot import *
+
+import attrs
+
+fit = lambda t, a, b, w: a * np.sin((2 * np.pi / w) * t) + b
+jac = lambda t, a, b, w: np.array(
+    [
+        np.sin(w * t),
+        1 * np.ones(t.shape),
+        a * w * np.cos(w * t),
+        0 * np.ones(t.shape),
+    ]
+).T
+ls = lambda x, t, y: (x[0] * np.sin(x[1] * t + x[3]) + x[2]) - y
+f = lambda x, t, y: (x[0] * np.sin(x[1] * t + x[3]) + x[2])
+
+
+class TestDynamics(unittest.TestCase):
+    def test_sim(self):
+        """tests free undamped motion"""
+
+        sm = SpringMass(Fa=0, u=0)
+
+        # the analytical answer
+        self.w_ans = np.sqrt(sm.k / sm.m)
+
+        dt = 0.001
+
+        df = sm.simulate(dt=dt, endtime=10)
+        # TODO: add passing flag to context
+        # self.assertTrue(sm.solved)
+        # self.assertTrue(sm.converged)
+
+        X = df.x
+        T = df.time
+        t = T[T < 2]
+        x = X[T < 2]
+
+        p0 = (x.max() - x.min(), self.w_ans + 0.01, x.mean(), -3.14)
+        # ans,cov = curve_fit(fit,t,x,p0=p0)
+        ans = least_squares(
+            ls,
+            p0,
+            args=(t, x),
+            ftol=1e-14,
+            jac="cs",
+            xtol=1e-14,
+            gtol=1e-14,
+            x_scale=2,
+        )
+        if not ans.success:
+            raise Exception("failure")
+
+        self.assertAlmostEqual(ans.x[1], self.w_ans, delta=0.01)
+
+    def test_damping(self):
+        """test that the ss answer is equal to the result with damping"""
+        sm = SpringMass(Fa=0, u=5)
+        sm.run(dxdt=0, combos="time")  # time captures integral via combos
+
+        dfss = sm.last_context.dataframe
+        trsm, df = sm.simulate(dt=0.001, endtime=10, return_all=True)
+
+        self.assertAlmostEqual(df.iloc[-1].x, dfss.iloc[0].x, delta=0.01)
+
+    def test_forcing(self):
+        """test that the ss answer is equal to the result with damping"""
+        sm = SpringMass(Fa=10, u=0, wo_f=1)
+        sm.wo_f = w_ans = np.sqrt(sm.k / sm.m) * 0.1  # very different frequency
+
+        sm.run(dxdt=0, combos="time")
+        dfss = sm.dataframe
+        sm.x = dfss.iloc[0].x  # no residual input
+
+        trsm, df = sm.simulate(
+            dt=0.001, endtime=10, run_solver=False, combos="*", return_all=True
+        )
+
+        X = df.x
+        T = df.time
+        t = T[T < 2]
+        x = X[T < 2]
+
+        p0 = (x.max() - x.min(), w_ans + 0.01, x.mean(), -3.14)
+        # ans,cov = curve_fit(fit,t,x,p0=p0)
+        ans = least_squares(
+            ls,
+            p0,
+            args=(t, x),
+            ftol=1e-14,
+            jac="cs",
+            xtol=1e-14,
+            gtol=1e-14,
+            x_scale=2,
+        )
+        if not ans.success:
+            raise Exception("failure")
+
+        self.assertAlmostEqual(ans.x[1], w_ans, delta=0.01)

engforge/test/test_dynamics_spaces.py

@@ -0,0 +1,39 @@
+from engforge._testing_components import *
+
+import numpy as np
+import unittest
+
+
+class TestDynamics(unittest.TestCase):
+    def test_dynamics(self, endtime=10, dt=0.01):
+        dc = DynamicComponent()
+        ds = DynamicSystem(comp=dc)
+
+        min_kw = {"normalize": np.array([1 / 1000])}
+        sim, df = ds.simulate(dt, endtime, run_solver=False, return_all=True)
+
+        # ax = df.plot("time", ["x", "comp_x", "trns_x", "comp_x0"])
+        # # ax.set_ylim(-1,5)
+        # ax2 = ax.twinx()
+        # ax2.plot(df.time, df.a, "r--", label="acl")
+        # ax2.plot(df.time, df["trns_a"], "b--", label="trans_acl")
+        # ax2.plot(df.time, df["spring_accel"], "c--", label="spring_acl")
+        # ax2.legend()
+
+        self.assertGreaterEqual(df["time"].max(), endtime - dt)
+
+    def test_steady_state(self):
+        dc = DynamicComponent()
+        ds = DynamicSystem(comp=dc)
+
+        # TODO: check dxdt=0 combo results (dynamics/rates==states)
+
+        ans = ds.run(dxdt=0, combos="time", revert_last=False, revert_every=False)
+        output = ans["output"][0]
+        self.assertTrue(output["success"])
+
+        all_rate_res = output["Ycon"]
+        for rkey, rate_res in all_rate_res.items():
+            self.assertAlmostEqual(
+                rate_res, 0, places=3, msg=f"Rate {rkey} is not zero"
+            )

engforge/test/test_four_bar.py

@@ -0,0 +1,97 @@
+from engforge import *
+import attrs
+import numpy
+
+
+@forge(auto_attribs=True)
+class FourBar(System):
+    # r1
+    r1: float = 0.02
+    gamma_zero: float = 10 * 3.1415 / 180  # radians
+    gamma: float = 0
+    r1_slv = Solver.declare_var("r1", combos="indep,r1")
+    r1_slv.add_var_constraint(0.0, kind="min", combos="lim")
+    r1_slv.add_var_constraint(0.05, kind="max", combos="lim")
+
+    gz_slv = Solver.declare_var("gamma_zero", combos="indep,zero")
+    gz_slv.add_var_constraint(0.0, kind="min", combos="lim")
+    gz_slv.add_var_constraint(15 * 3.1415 / 180, kind="max", combos="lim")
+
+    gam_slv = Solver.declare_var("gamma", combos="indep,gamma")
+    gam_slv.add_var_constraint(0.0, kind="min", combos="lim")
+    gam_sig = Signal.define("gamma", "gamma_zero", combos="gam_sig")
+
+    # arm
+    theta: float = 0  # radians
+    ra: float = 0.03
+    theta_slv = Solver.declare_var("theta", combos="indep,theta")
+    theta_slv.add_var_constraint(0.0, kind="min", combos="lim")
+    theta_slv.add_var_constraint(3.14159, kind="max", combos="lim")
+
+    # r2
+    x2: float = 0.05
+    h2: float = 0.0
+    x2_slv = Solver.declare_var("x2", combos="indep,x2")
+    x2_slv.add_var_constraint(0.025, kind="min", combos="lim")
+    x2_slv.add_var_constraint(0.05, kind="max", combos="lim")
+
+    h2_slv = Solver.declare_var("h2", combos="indep,h2")
+    h2_slv.add_var_constraint(-0.01, kind="min", combos="lim")
+    h2_slv.add_var_constraint(0.01, kind="max", combos="lim")
+
+    len_slv = Solver.con_eq("l3_zero", "l3_gamma", combos="goal,leneq")
+    goal_slv = Solver.objective("gamma_goal", kind="max", combos="goal,gamma")
+    l3_max = Solver.objective("l3_zero", kind="max", combos="goal,l3max")
+
+    @system_prop
+    def gamma_goal(self) -> float:
+        return self.gamma
+
+    @system_prop
+    def r3_x_zero(self) -> float:
+        """length defined by closed condition"""
+        return self.x2 + self.ra - self.r1 * numpy.cos(self.gamma_zero)
+
+    @system_prop
+    def r3_x(self) -> float:
+        """length defined by gamma/theta"""
+        return (
+            self.x2 + self.ra * numpy.cos(self.theta) - self.r1 * numpy.cos(self.gamma)
+        )
+
+    @system_prop
+    def y_zero(self) -> float:
+        """length defined by closed condition"""
+        return self.h2 - self.r1 * numpy.sin(self.gamma_zero)
+
+    @system_prop
+    def y(self) -> float:
+        """length defined by gamma/theta"""
+        return (
+            self.x2 + self.ra * numpy.sin(self.theta) - self.r1 * numpy.sin(self.gamma)
+        )
+
+    @system_prop
+    def l3_zero(self) -> float:
+        return self.r3_x_zero**2 + self.y_zero**2
+
+    @system_prop
+    def l3_gamma(self) -> float:
+        return self.r3_x**2 + self.y**2
+
+
+if __name__ == "__main__":
+    # %run -i ~/engforge/engforge/test/test_four_bar.py
+    import numpy as np
+
+    fb = FourBar()
+    fb.run(combos="*", revert_last=False, revert_every=False)
+
+    df = fb.last_context.dataframe
+
+    fb.run(
+        combos="goal,gamma,theta,lim",
+        theta=np.linspace(0, 3.14159),
+        revert_last=False,
+        revert_every=False,
+    )

engforge/test/test_modules.py

@@ -0,0 +1,72 @@
+import pathlib
+
+testpath = pathlib.Path(__file__).parent.absolute()
+
+import logging
+
+log = logging.getLogger("neptunya-test")
+
+import sys
+
+
+from matplotlib import pylab
+import numpy as n
+import unittest
+
+import engforge
+
+
+import copy, traceback
+import random, json
+import time
+
+
+class ImportTest(unittest.TestCase):
+    """We test the compilation of all included modules"""
+
+    def test_import_analysis(self):
+        import engforge.analysis
+
+    def test_import_common(self):
+        import engforge.common
+
+    def test_import_components(self):
+        import engforge.components
+
+    def test_import_configuration(self):
+        import engforge.configuration
+
+    def test_import_data(self):
+        import engforge.datastores.data
+
+    # def test_import_gdocs(self):
+    #     import engforge.datastores.gdocs
+
+    def test_import_locations(self):
+        import engforge.locations
+
+    def test_import_logging(self):
+        import engforge.logging
+
+    def test_import_plotting(self):
+        import engforge.attr_plotting
+
+    # def test_import_process(self):
+    #     import engforge.process
+
+    def test_import_patterns(self):
+        import engforge.patterns
+
+    def test_import_solid_materials(self):
+        import engforge.eng.solid_materials
+
+    def test_import_tabulation(self):
+        import engforge.tabulation
+
+    def test_import_thermodynamics(self):
+        import engforge.eng.thermodynamics
+
+
+if __name__ == "__main__":
+    print(("\n" * 10))
+    unittest.main()