engforge 0.3.0__py3-none-any.whl

engforge/tabulation.py

@@ -0,0 +1,288 @@
+"""Tabulation Module:
+
+Incrementally records attrs input values and system_properties per save_data() call.
+
+save_data() is called after item.eval() is called.
+"""
+
+from contextlib import contextmanager
+import attr
+
+from engforge.common import inst_vectorize, chunks
+
+# from engforge.configuration import Configuration, forge
+from engforge.solveable import SolveableMixin
+from engforge.logging import LoggingMixin
+from engforge.dataframe import DataframeMixin
+from engforge.typing import *
+from engforge.properties import *
+from typing import Callable
+
+import numpy
+import pandas
+import os
+import collections
+import uuid
+
+
+class TableLog(LoggingMixin):
+    pass
+
+
+log = TableLog()
+
+# SKIP_REF = ["run_id", "converged", "name", "index"]
+SKIP_REF = ["name", "index"]
+
+
+class TabulationMixin(SolveableMixin, DataframeMixin):
+    """In which we define a class that can enable tabulation"""
+
+    # Super Special Tabulating Index
+    # index = 0  # Not an attr on purpose, we want pandas to provide the index
+
+    # override per class:
+    _skip_table_vars: list = None
+    _skip_plot_vars: list
+
+    # Cached and private
+    # _table: dict = None
+    _anything_changed: bool = True
+    _always_save_data = False
+
+    def __getstate__(self):
+        """remove references and storage of properties, be sure to call super if overwriting this function in your subclass"""
+        vs = super().__getstate__()
+        pir = vs.pop("_prv_internal_references", None)
+        pir = vs.pop("_system_properties_def", None)
+        pir = vs.pop("parent", None)
+
+        return vs
+
+    @property
+    def anything_changed(self):
+        """use the on_setattr method to determine if anything changed,
+        also assume that stat_tab could change without input changes"""
+        if not hasattr(self, "_anything_changed"):
+            self._anything_changed = True
+
+        if self._anything_changed or self.always_save_data:
+            if self.log_level <= 5:
+                self.msg(
+                    f"change: {self._anything_changed}| always: {self.always_save_data}"
+                )
+            return True
+        return False
+
+    @property
+    def last_context(self):
+        """Returns the last context"""
+        raise NotImplemented("this should be implemented in the solvable class")
+
+    # TODO: create an intelligent graph informed anything_changed alerting system (pyee?) and trigger solver_cache expirations appropriately
+    # @solver_cached #FIXME: not caching correctly
+    @property  # FIXME: this is slow
+    def dataframe(self):
+        """
+        Returns a pandas DataFrame based on the current context.
+
+        This method checks for the presence of `last_context` and its `dataframe` attribute.
+        If they exist, it returns the `dataframe` from `last_context`.
+        If not, it checks for the `_patch_dataframe` attribute and returns it if it exists.
+        If neither condition is met, it returns an empty DataFrame.
+
+        :return: A pandas DataFrame based on the current context or an empty DataFrame if no context is available.
+        :rtype: pandas.DataFrame
+        """
+        """"""
+        if hasattr(self, "last_context") and hasattr(self.last_context, "dataframe"):
+            return self.last_context.dataframe
+        if hasattr(self, "_patch_dataframe") and self._patch_dataframe is not None:
+            return self._patch_dataframe
+        return pandas.DataFrame([])
+
+    @dataframe.setter
+    def dataframe(self, input_dataframe):
+        if hasattr(self, "last_context") and hasattr(self.last_context, "dataframe"):
+            raise Exception(f"may not set dataframe on run component")
+        self._patch_dataframe = input_dataframe
+
+    @property
+    def plotable_variables(self):
+        """Checks columns for ones that only contain numeric types or haven't been explicitly skipped"""
+        if self.dataframe is not None:
+            check_type = lambda key: all(
+                [isinstance(v, NUMERIC_TYPES) for v in self.dataframe[key]]
+            )
+            check_non_mono = lambda key: len(set(self.dataframe[key])) > 1
+
+            return [
+                var
+                for var in self.dataframe.columns
+                if var.lower() not in self.skip_plot_vars
+                and check_type(var)
+                and check_non_mono(var)
+            ]
+        return []
+
+    # Properties & Attribues
+    def print_info(self):
+        print(f"INFO: {self.name} | {self.identity}")
+        print("#" * 80)
+        for key, value in sorted(self.data_dict.items(), key=lambda kv: kv[0]):
+            print(f"{key:>40} | {value}")
+
+    @property
+    def data_dict(self):
+        """this is what is captured and used in each row of the dataframe / table"""
+        # NOTE: Solver class overrides this with full system references
+        out = collections.OrderedDict()
+        sref = self.internal_references()
+        for k, v in sref["attributes"].items():
+            if k in self.attr_raw_keys:
+                out[k] = v.value()
+        for k, v in sref["properties"].items():
+            out[k] = v.value()
+        return out
+
+    @instance_cached
+    def attr_raw_keys(self) -> list:
+        good = set(self.table_fields())
+        return [k for k in attr.fields_dict(self.__class__).keys() if k in good]
+
+    def set_attr(self, **kwargs):
+        assert set(kwargs).issubset(set(self.attr_raw_keys))
+        # TODO: support subcomponents via slots lookup
+        for k, v in kwargs.items():
+            setattr(self, k, v)
+
+    @instance_cached
+    def always_save_data(self):
+        """Checks if any properties are stochastic (random)"""
+        return self._always_save_data
+
+    @solver_cached
+    def table_dict(self):
+        # We use __get__ to emulate the property, we could call regularly from self but this is more straightforward
+        return {
+            k.lower(): obj.__get__(self)
+            for k, obj in self.system_properties_def.items()
+        }
+
+    @solver_cached
+    def system_properties(self):
+        # We use __get__ to emulate the property, we could call regularly from self but this is more straightforward
+        tabulated_properties = [
+            obj.__get__(self) for k, obj in self.system_properties_def.items()
+        ]
+        return tabulated_properties
+
+    @instance_cached
+    def system_properties_labels(self) -> list:
+        """Returns the labels from table properties"""
+        class_dict = self.__class__.__dict__
+        tabulated_properties = [
+            obj.label.lower() for k, obj in self.system_properties_def.items()
+        ]
+        return tabulated_properties
+
+    @instance_cached
+    def system_properties_types(self) -> list:
+        """Returns the types from table properties"""
+        class_dict = self.__class__.__dict__
+        tabulated_properties = [
+            obj.return_type for k, obj in self.system_properties_def.items()
+        ]
+        return tabulated_properties
+
+    @instance_cached
+    def system_properties_keys(self) -> list:
+        """Returns the table property keys"""
+        tabulated_properties = [k for k, obj in self.system_properties_def.items()]
+        return tabulated_properties
+
+    @instance_cached
+    def system_properties_description(self) -> list:
+        """returns system_property descriptions if they exist"""
+        class_dict = self.__class__.__dict__
+        tabulated_properties = [
+            obj.desc for k, obj in self.system_properties_def.items()
+        ]
+        return tabulated_properties
+
+    @classmethod
+    def cls_all_property_labels(cls):
+        return [obj.label for k, obj in cls.system_properties_classdef().items()]
+
+    @classmethod
+    def cls_all_property_keys(cls):
+        return [k for k, obj in cls.system_properties_classdef().items()]
+
+    @classmethod
+    def cls_all_attrs_fields(cls):
+        return attr.fields_dict(cls)
+
+    @solver_cached
+    def system_properties_def(self):
+        """Combine other classes table properties into this one, in the case of subclassed system_properties as a property that is cached"""
+        return self.__class__.system_properties_classdef()
+
+    @classmethod
+    def system_properties_classdef(cls, recache=False):
+        """Combine other parent-classes table properties into this one, in the case of subclassed system_properties"""
+        from engforge.tabulation import TabulationMixin
+
+        cls_key = f"_{cls.__name__}_system_properties"
+        # Use a cache for deep recursion
+        if not recache and hasattr(cls, cls_key):
+            res = getattr(cls, cls_key)
+            if res is not None:
+                return res
+
+        # otherwise make the cache
+        __system_properties = {}
+        for k, obj in cls.__dict__.items():
+            if isinstance(obj, system_property):
+                __system_properties[k] = obj
+
+        #
+        mrl = cls.mro()
+        inx_comp = mrl.index(TabulationMixin)
+
+        # Ensures everything is includes Tabulation Functionality
+        mrvs = mrl[1:inx_comp]
+
+        for mrv in mrvs:
+            # Remove anything not in the user code
+            log.msg(f"adding system properties from {mrv.__name__}")
+            if (
+                issubclass(mrv, TabulationMixin)
+                # and "engforge" not in mrv.__module__
+            ):
+                for k, obj in mrv.__dict__.items():
+                    if k not in __system_properties and isinstance(
+                        obj, system_property
+                    ):  # Precedent
+                        # Assumes our instance has assumed this table property
+                        prop = getattr(cls, k, None)
+                        if prop and isinstance(prop, system_property):
+                            __system_properties[k] = prop
+                            if log.log_level <= 3:
+                                log.msg(f"adding system property {mrv.__name__}.{k}")
+
+        setattr(cls, cls_key, __system_properties)
+
+        return __system_properties
+
+    @classmethod
+    def pre_compile(cls):
+        cls._anything_changed = True  # set default on class
+        if any([v.stochastic for k, v in cls.system_properties_classdef(True).items()]):
+            log.info(f"setting always save on {cls.__name__}")
+            cls._always_save_data = True
+
+    @property
+    def system_id(self) -> str:
+        """returns an instance unique id based on id(self)"""
+        idd = id(self)
+        return f"{self.classname}.{idd}"

engforge/test/__init__.py

@@ -0,0 +1,2 @@
+import sys
+import os, pathlib

engforge/test/_pre_test_structures.py

@@ -0,0 +1,221 @@
+import unittest
+from matplotlib import pylab
+from engforge.eng.structure import *
+from engforge.eng.geometry import ShapelySection
+from sectionproperties.pre.library.steel_sections import i_section
+
+from numpy import *
+
+
+class test_cantilever(unittest.TestCase):
+    # tests the first example here
+    # https://www.engineeringtoolbox.com/cantilever-beams-d_1848.html
+
+    def setUp(self):
+        self.st = Structure(name="cantilever_beam", add_gravity_force=False)
+        self.st.add_node("wall", 0, 0, 0)
+        self.st.add_node("free", 0, 5, 0)
+
+        self.ibeam = i_section(0.3072, 0.1243, 0.0121, 0.008, 0.0089, 4)
+        beam = ShapelySection(shape=self.ibeam, material=ANSI_4130())
+        self.bm = self.st.add_member("mem", "wall", "free", section=beam)
+
+        self.st.def_support(
+            "wall",
+            support_DX=True,
+            support_DY=True,
+            support_DZ=True,
+            support_RY=True,
+            support_RX=True,
+            support_RZ=True,
+        )
+        self.st.frame.add_node_load("free", "FX", 3000, case="gravity")
+
+        self.st.run(check_statics=True)
+
+    def test_beam(self):
+        self.subtest_assert_near(self.bm.A, 53.4 / (100**2))
+        self.subtest_assert_near(self.bm.Ix, 8196 / (100**4))
+        self.subtest_assert_near(self.bm.Iy, 388.8 / (100**4))
+        self.subtest_assert_near(self.bm.section_mass, 41.9)
+
+        self.subtest_assert_near(self.bm.max_von_mises(), 27.4e6)
+        self.subtest_assert_near(float(self.bm.data_dict["min_deflection_y"]), -0.0076)
+        # self.subtest_assert_near(float(self.bm.data_dict["max_shear_y"]), 3000)
+        self.subtest_assert_near(float(self.bm.data_dict["max_shear_y"]), 3000)
+
+        df = self.st.node_dataframe.loc["gravity"]
+
+        dfw = df.loc["wall"]
+        dff = df.loc["free"]
+
+        self.subtest_assert_near(float(dfw["rxfx"]), -3000, msg="wall rxfx")
+        self.subtest_assert_near(float(dfw["rxmz"]), 15000, msg="wall rxmz")
+        self.subtest_assert_near(float(dfw["dx"]), 0, msg="wall dx")
+
+        self.subtest_assert_near(float(dff["dx"]), 0.0076, msg="dx")
+        self.subtest_assert_near(float(dff["rxfx"]), 0, msg="rxfx")
+        self.subtest_assert_near(float(dff["rxmz"]), 0, msg="rxmz")
+
+        stress_obj = self.bm.get_stress_at(0, "gravity")
+        # stress_obj.plot_stress_vm()
+
+    def subtest_assert_near(self, value, truth, pct=0.025, **kw):
+        with self.subTest(**kw):
+            self.assertAlmostEqual(value, truth, delta=max(abs(truth * pct), abs(pct)))
+
+
+class test_truss(unittest.TestCase):
+    # Match this example, no beam stresses
+    # https://engineeringlibrary.org/reference/trusses-air-force-stress-manual
+
+    def setUp(self):
+        self.st = Structure(name="truss", add_gravity_force=False)
+        self.st.add_node("A", 0, 0, 0)
+        self.st.add_node("B", 15, 30 * sqrt(3) / 2, 0)
+        self.st.add_node("C", 45, 30 * sqrt(3) / 2, 0)
+        self.st.add_node("D", 75, 30 * sqrt(3) / 2, 0)
+        self.st.add_node("E", 90, 0, 0)
+        self.st.add_node("F", 60, 0, 0)
+        self.st.add_node("G", 30, 0, 0)
+
+        pairs = set()
+        Lmin = 30 * sqrt(3) / 2
+        Lmax = 30.1
+
+        for n1 in self.st.nodes.values():
+            for n2 in self.st.nodes.values():
+                L = numpy.sqrt(
+                    (n1.X - n2.X) ** 2.0 + (n1.Y - n2.Y) ** 2.0 + (n1.Z - n2.Z) ** 2.0
+                )
+
+                if (
+                    L >= Lmin
+                    and L <= Lmax
+                    and (n1.name, n2.name) not in pairs
+                    and (n2.name, n1.name) not in pairs
+                ):
+                    pairs.add((n1.name, n2.name))
+
+                elif (n1.name, n2.name) in pairs or (
+                    n2.name,
+                    n1.name,
+                ) in pairs:
+                    pass
+
+        self.beam = sections.rectangular_section(1.5, 1.5)
+        material = ANSI_4130()
+        self.section = ShapelySection(shape=self.beam, material=material)
+
+        constrained = ("A", "E")
+        for n1, n2 in pairs:
+            bkey = f"{n1}_{n2}"
+            self.bm = self.st.add_member(
+                bkey,
+                n1,
+                n2,
+                # material=ANSI_4130(),
+                section=self.section,
+                # min_mesh_size=0.01,
+            )
+
+            # if n1 not in constrained:
+            #     print(f'releasing {bkey}')
+            #     self.st.frame.DefineReleases(bkey, Rzi=True)
+
+            # if n2 not in constrained:
+            #     print(f'releasing {bkey} J')
+            #     self.st.frame.DefineReleases(bkey, Rzj=True)
+
+        self.st.def_support(
+            "A",
+            support_DX=True,
+            support_DY=True,
+            support_DZ=True,
+            support_RY=True,
+            support_RX=True,
+            support_RZ=True,
+        )
+        self.st.def_support(
+            "E",
+            support_DX=False,
+            support_DY=True,
+            support_DZ=True,
+            support_RY=False,
+            support_RX=False,
+            support_RZ=True,
+        )
+        # for node in self.st.nodes:
+        #     self.st.frame.Definesupport_(node,support_DZ=True,support_RZ=True)
+
+        self.st.add_node_load("F", "FY", -1000, case="gravity")
+        self.st.add_node_load("G", "FY", -2000, case="gravity")
+
+        self.st.run(check_statics=True)
+        # self.st.visulize()
+
+    def test_reactions(self):
+        df = self.st.node_dataframe.loc["gravity"]
+        # print(df)
+
+        dfa = df.loc["A"]
+        dfe = df.loc["E"]
+
+        # print(dfa)
+        # print(dfe)
+
+        self.subtest_assert_near(float(dfa["rxfy"]), 1667)
+        self.subtest_assert_near(float(dfe["rxfy"]), 1333)
+
+        self.subtest_member("A", "B", "max_axial", 1925)
+        self.subtest_member("A", "G", "max_axial", -949)  # -926 textbook
+        self.subtest_member("B", "C", "max_axial", 1925)
+        self.subtest_member("B", "G", "max_axial", -1925)
+        self.subtest_member("C", "D", "max_axial", 1541)
+        self.subtest_member("F", "G", "max_axial", -1734)
+        self.subtest_member("C", "F", "max_axial", 382)
+        self.subtest_member("C", "G", "max_axial", -382)
+        self.subtest_member("C", "G", "max_axial", -378)  # 1541 textbook
+        self.subtest_member("D", "F", "max_axial", -1541)
+        self.subtest_member("E", "F", "max_axial", -770)
+
+        # Visualization.RenderModel( self.st.frame )
+
+    def subtest_member(self, nodea, nodeb, result_key, truth, pct=0.025):
+        with self.subTest(msg=f"test {nodea}->{nodeb}"):
+            key_1 = f"{nodea}_{nodeb}"
+            key_2 = f"{nodeb}_{nodea}"
+
+            if key_1 in self.st.beams:
+                key = key_1
+            elif key_2 in self.st.beams:
+                key = key_2
+            else:
+                raise
+
+            value = self.get_member_result(nodea, nodeb, result_key)
+            dopasst = abs(value - truth) <= abs(truth) * pct
+
+            if not dopasst:
+                print(f"fails {key} {result_key}| {value:3.5f} == {truth:3.5f}?")
+            self.subtest_assert_near(value, truth, pct=pct)
+
+    def subtest_assert_near(self, value, truth, pct=0.025):
+        with self.subTest():
+            self.assertAlmostEqual(value, truth, delta=abs(truth * pct))
+
+    def get_member_result(self, nodea, nodeb, result_key):
+        key_1 = f"{nodea}_{nodeb}"
+        key_2 = f"{nodeb}_{nodea}"
+
+        if key_1 in self.st.beams:
+            mem = self.st.beams[key_1]
+            if result_key in mem.data_dict:
+                return float(mem.data_dict[result_key])
+
+        elif key_2 in self.st.beams:
+            mem = self.st.beams[key_2]
+            if result_key in mem.data_dict:
+                return float(mem.data_dict[result_key])
+
+        return numpy.nan  # shouod fail, nan is not comparable

engforge/test/report_testing.py

@@ -0,0 +1,158 @@
+from engforge.datastores.reporting import *
+from engforge.configuration import forge
+from engforge.tabulation import system_property
+from engforge.components import Component
+from engforge.analysis import Analysis
+from logging import *
+
+import numpy
+
+# tests scripts
+
+# suprise the db and add more columns to test dynamic creation
+suprise = False
+
+
+@forge
+class TestComponent(Component):
+    blank = attr.ib(default=None, validator=None)  # no validator
+
+    name = attr.ib(default="test", validator=STR_VALIDATOR())
+    word = attr.ib(default="bird", validator=STR_VALIDATOR())
+    val = attr.ib(default=10)
+
+    always_save_data = True
+
+    @system_property
+    def synthetic_val(self):
+        if self.word == "schfiftyfive":
+            return 55
+        return random.random() * self.val
+
+    @system_property
+    def nan_val(self):
+        return numpy.nan
+
+    @system_property
+    def inf_val(self):
+        return numpy.inf
+
+    if suprise:
+
+        @system_property
+        def surpise_val(self):
+            return 13
+
+
+@forge
+class OtherComponent(Component):
+    arg1 = attr.ib(default="mmmm", validator=STR_VALIDATOR())
+    arg2 = attr.ib(default="word", validator=STR_VALIDATOR())
+    argnum = attr.ib(default=10)
+
+    if suprise:
+        ones = attr.ib(default=1111)
+        wacky = attr.ib(default="one hundred and 111", validator=STR_VALIDATOR())
+        more = attr.ib(default="other stuff", validator=STR_VALIDATOR())
+
+    always_save_data = True
+
+    @system_property
+    def random_val(self):
+        return self.argnum * random.random() / random.random()
+
+    if suprise:
+
+        @system_property
+        def new_val(self):
+            return self.argnum * random.random()
+
+
+if suprise:
+
+    @forge
+    class SupriseComponent(Component):
+        arg3 = attr.ib(default="mmmm", validator=STR_VALIDATOR())
+        arg4 = attr.ib(default="word", validator=STR_VALIDATOR())
+        argque = attr.ib(default=-999)
+        # ones = attr.ib(default=1111)
+        # wacky = attr.ib(default='one hundred and 111', validator=STR_VALIDATOR())
+        # more = attr.ib(default='other stuff', validator=STR_VALIDATOR())
+
+        always_save_data = True
+
+        @system_property
+        def negative_random_val(self):
+            return self.argque * random.random() / random.random()
+
+
+@forge
+class TestAnalysis(Analysis):
+    if suprise:
+        surprise = attr.ib(factory=SupriseComponent)
+
+    other_cocomponent = attr.ib(factory=OtherComponent)
+    internal_component = attr.ib(factory=TestComponent)
+    some_random_value = attr.ib(default=10)
+    other_rand_val = attr.ib(default=1e6)
+
+    mode = "iterator"
+    iterator = attr.ib(factory=lambda: list(range(10)))
+    always_save_data = True
+
+    @system_property
+    def internal_val(self):
+        return self.internal_component.val
+
+    @system_property
+    def rand_val(self):
+        return random.random() * self.internal_component.val
+
+    def eval(self, item):
+        self.some_random_value = item
+
+    @system_property
+    def random_none(self):
+        val = random.random()
+        if val > 0.6:
+            return None
+        return val
+
+    if suprise:
+
+        @system_property
+        def suprise(self):
+            return random.random() * self.internal_component.val
+
+
+if __name__ == "__main__":
+    log = logging.getLogger()
+    DEBUG = True
+    if DEBUG:
+        log.setLevel(logging.DEBUG)
+        logging.basicConfig(level=logging.DEBUG)
+        set_all_loggers_to(logging.DEBUG)
+
+    analysis = TestAnalysis()
+    tc = analysis.internal_component
+
+    # 1) Ensure exists Reflect The Database
+    db = DBConnection("reports", host="localhost", user="postgres", passd="dumbpass")
+    db.ensure_database_exists()
+    # db.engine.echo = True
+
+    rr = ResultsRegistry(db=db)
+    # rr.ensure_all_tables()
+    # rr.base.metadata.drop_all()
+    # rr.initalize()
+
+    # 2) Use ComponentRegistry, and AnalysisRegistry to gather subclasses of each. Analysis will also have results tables since they are components, these will be referenced in the analysis table.
+    analysis.run()
+    rr.ensure_analysis(analysis)
+    thread = rr.upload_analysis(analysis, use_thread=True)
+    thread.join()
+
+    # 3) For each component and analysis map create tables or map them if they dont exist.
+    # - use a registry approach (singleton?) to map the {component: db_class} pairs
+
+    # 4) When an an an analysis is solved, if configured for reporting, on post processing the results will be added to the database