ada-py 0.0.45.dev8__tar.gz → 0.2.0__tar.gz

{ada-py-0.0.45.dev8/src/ada_py.egg-info → ada-py-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ada-py
-Version: 0.0.45.dev8
+Version: 0.2.0
 Summary: Assembly for Design & Analysis - A python library for structural analysis and design
 Author-email: "Kristoffer H. Andersen" <kristoffer_andersen@outlook.com>
 Project-URL: Homepage, https://github.com/Krande/adapy

ada-py-0.2.0/pyproject.toml

@@ -0,0 +1,55 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ada-py"
+version = "0.2.0"
+authors = [
+    { name = "Kristoffer H. Andersen", email = "kristoffer_andersen@outlook.com" },
+]
+description = "Assembly for Design & Analysis - A python library for structural analysis and design"
+readme = "README.md"
+requires-python = ">=3.10"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering",
+    "Topic :: Utilities",
+]
+[project.scripts]
+ada-viewer = "ada.visit.render_pygfx:main"
+
+[project.urls]
+"Homepage" = "https://github.com/Krande/adapy"
+"Bug Tracker" = "https://github.com/Krande/adapy/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["ada*"]
+exclude = ["frontend*"]
+
+[tool.setuptools.package-data]
+ada = [
+    "sections/resources/ProfileDB.json",
+    "materials/metals/resources/NLMatParams.json",
+    "cadit/gxml/write/resources/xml_blank.xml",
+    "fem/results/resources/results.sql",
+    "visit/resources/index.zip"
+]
+
+[tool.black]
+line-length = 120
+
+[tool.ruff]
+line-length = 120
+ignore = ["E741"]
+exclude = ["examples/"]
+
+[tool.isort]
+profile = "black"

ada-py-0.2.0/src/ada/api/animations.py

@@ -0,0 +1,160 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+import numpy as np
+from trimesh.exchange.gltf import _data_append
+
+
+@dataclass
+class Animation:
+    name: str
+    keyframe_times: list[float | int]
+    translation_keyframes: list[float | int] = None
+    rotation_keyframes: list[list[float, float, float, float]] = None
+    deformation_weights_keyframes: list[float | int] = None
+    deformation_shape: list[list[float]] = None
+    node_idx: int | list[int] = None
+
+    def __call__(self, buffer_items, tree, morph_target_index, num_morph_targets):
+        node_idx_list = self.node_idx
+        if not isinstance(node_idx_list, list):
+            node_idx_list = [node_idx_list]
+
+        keyframe_idx = _data_append(
+            acc=tree["accessors"],
+            buff=buffer_items,
+            blob={"componentType": 5126, "type": "SCALAR"},
+            data=np.array(self.keyframe_times, dtype="float32"),
+        )
+
+        samplers = []
+        channels = []
+        if self.translation_keyframes is not None:
+            translation_idx = _data_append(
+                acc=tree["accessors"],
+                buff=buffer_items,
+                blob={"componentType": 5126, "type": "VEC3"},
+                data=np.array(self.translation_keyframes, dtype="float32"),
+            )
+            translation_sampler = {"input": keyframe_idx, "interpolation": "LINEAR", "output": translation_idx}
+            sampler_idx = len(samplers)
+            samplers.append(translation_sampler)
+            for node_idx in node_idx_list:
+                translation_channel = {"sampler": sampler_idx, "target": {"node": node_idx, "path": "translation"}}
+                channels.append(translation_channel)
+
+        if self.rotation_keyframes is not None:
+            rotation_idx = _data_append(
+                acc=tree["accessors"],
+                buff=buffer_items,
+                blob={"componentType": 5126, "type": "VEC4"},
+                data=np.array(self.rotation_keyframes, dtype="float32"),
+            )
+            rotation_sampler = {"input": keyframe_idx, "interpolation": "LINEAR", "output": rotation_idx}
+            sampler_idx = len(samplers)
+            samplers.append(rotation_sampler)
+            for node_idx in node_idx_list:
+                rotation_channel = {"sampler": sampler_idx, "target": {"node": node_idx, "path": "rotation"}}
+                channels.append(rotation_channel)
+
+        if self.deformation_weights_keyframes is not None:
+            deformation_shape_idx = _data_append(
+                acc=tree["accessors"],
+                buff=buffer_items,
+                blob={"componentType": 5126, "type": "VEC3"},
+                data=np.array(self.deformation_shape, dtype="float32"),
+            )
+
+            keyframe_weights = np.zeros((len(self.deformation_weights_keyframes) * num_morph_targets), dtype="float32")
+            for i, weight in enumerate(self.deformation_weights_keyframes):
+                keyframe_weights[i * num_morph_targets + morph_target_index] = weight
+
+            # print(keyframe_weights)
+            deformation_weights_keys_idx = _data_append(
+                acc=tree["accessors"],
+                buff=buffer_items,
+                blob={"componentType": 5126, "type": "SCALAR"},
+                data=keyframe_weights,
+            )
+
+            deformation_sampler = {
+                "input": keyframe_idx,
+                "interpolation": "LINEAR",
+                "output": deformation_weights_keys_idx,
+            }
+            sampler_idx = len(samplers)
+            samplers.append(deformation_sampler)
+
+            for node_idx in node_idx_list:
+                deformation_channel = {"sampler": sampler_idx, "target": {"node": node_idx, "path": "weights"}}
+                channels.append(deformation_channel)
+
+                # add position targets
+                mesh_no = tree["nodes"][node_idx]["mesh"]
+                mesh = tree["meshes"][mesh_no]
+
+                deform_target = {"POSITION": deformation_shape_idx}
+
+                # make sure the referenced bufferview contains the target property
+                primitive = mesh["primitives"][0]
+                if primitive.get("targets") is None:
+                    primitive["targets"] = []
+
+                target_idx = len(primitive["targets"])
+                primitive["targets"].append(deform_target)
+
+                if mesh["extras"].get("targetNames") is None:
+                    mesh["extras"]["targetNames"] = []
+                mesh["extras"]["targetNames"].append(self.name)
+
+                if mesh.get("weights") is None:
+                    mesh["weights"] = []
+
+                mesh["weights"].append(target_idx)
+
+        # Update tree with data added to buffer
+        if tree.get("animations") is None:
+            tree["animations"] = []
+
+        tree["animations"].append(
+            {
+                "name": self.name,
+                "samplers": samplers,
+                "channels": channels,
+            }
+        )
+
+
+@dataclass
+class AnimationStore:
+    animations: list[Animation] = field(default_factory=list)
+
+    def __call__(self, buffer_items, tree, *args, **kwargs):
+        for idx, animation in enumerate(self.animations):
+            animation(buffer_items, tree, morph_target_index=idx, num_morph_targets=len(self.animations))
+
+    def add(self, animation: Animation):
+        self.animations.append(animation)
+
+    @staticmethod
+    def update_buffer_view(tree, accessor_idx, target_num):
+        buffer_view_idx = tree["accessors"][accessor_idx]["bufferView"]
+        buffer_view = tree["bufferViews"][buffer_view_idx]
+        if buffer_view.get("target") is None:
+            buffer_view["target"] = target_num
+
+    @staticmethod
+    def tree_postprocessor(tree):
+        for material in tree["materials"]:
+            material["doubleSided"] = True
+
+        for anim in tree["animations"]:
+            node_idx = anim["channels"][0]["target"]["node"]
+            mesh_idx = tree["nodes"][node_idx]["mesh"]
+            mesh = tree["meshes"][mesh_idx]
+            for primitive in mesh["primitives"]:
+                AnimationStore.update_buffer_view(tree, primitive["attributes"]["POSITION"], 34962)
+                AnimationStore.update_buffer_view(tree, primitive["indices"], 34963)
+                for target in primitive["targets"]:
+                    AnimationStore.update_buffer_view(tree, target["POSITION"], 34962)

{ada-py-0.0.45.dev8 → ada-py-0.2.0}/src/ada/api/beams/geom_beams.py

@@ -26,11 +26,11 @@ def straight_beam_to_geom(beam: Beam | PipeSegStraight, is_solid=True) -> Geomet
         geom = Geometry(beam.guid, solid, beam.color)
     else:
         if beam.section.type in (
-                beam.section.TYPES.IPROFILE,
-                beam.section.TYPES.TPROFILE,
-                beam.section.TYPES.ANGULAR,
-                beam.section.TYPES.CHANNEL,
-                beam.section.TYPES.FLATBAR,
+            beam.section.TYPES.IPROFILE,
+            beam.section.TYPES.TPROFILE,
+            beam.section.TYPES.ANGULAR,
+            beam.section.TYPES.CHANNEL,
+            beam.section.TYPES.FLATBAR,
         ):
             geom = profile_disconnected_to_face_geom(beam)
         elif beam.section.type == beam.section.TYPES.BOX:

{ada-py-0.0.45.dev8 → ada-py-0.2.0}/src/ada/api/containers.py

@@ -941,7 +941,9 @@ class Nodes:
     def nodes(self) -> list[Node]:
         return self._nodes
 
-    def get_by_volume(self, p=None, vol_box=None, vol_cyl=None, tol=Settings.point_tol, single_member=False) -> list[Node]:
+    def get_by_volume(
+        self, p=None, vol_box=None, vol_cyl=None, tol=Settings.point_tol, single_member=False
+    ) -> list[Node]:
         """
 
         :param p: Point
@@ -1002,12 +1004,12 @@ class Nodes:
             result = list(simplesearch)
 
         if len(result) == 0:
-            logger.info(f'No vertices found using {p=}, {vol_box=}, {vol_cyl=} and {tol=}')
+            logger.info(f"No vertices found using {p=}, {vol_box=}, {vol_cyl=} and {tol=}")
             return result
 
         if single_member:
             if len(result) != 1:
-                logger.warning(f'Returning member at index=0 despite {len(result)=}. Please check your results')
+                logger.warning(f"Returning member at index=0 despite {len(result)=}. Please check your results")
             return result[0]
 
         return result

{ada-py-0.0.45.dev8 → ada-py-0.2.0}/src/ada/api/spatial/assembly.py

@@ -64,9 +64,6 @@ class Assembly(Part):
         clear_cache: bool = False,
         ifc_class: SpatialTypes = SpatialTypes.IfcSite,
     ):
-        from ada.cadit.ifc.store import IfcStore
-        from ada.cadit.ifc.utils import assembly_to_ifc_file
-
         metadata = dict() if metadata is None else metadata
         metadata["project"] = project
         metadata["schema"] = schema
@@ -76,7 +73,8 @@ class Assembly(Part):
         self._user = user
 
         self._ifc_class = ifc_class
-        self._ifc_file = assembly_to_ifc_file(self)
+        self._ifc_store = None
+        self._ifc_file = None
         self._convert_options = _ConvertOptions()
         self._ifc_sections = None
         self._ifc_materials = None
@@ -84,7 +82,6 @@ class Assembly(Part):
         self._ifc_settings = ifc_settings
         self._presentation_layers = PresentationLayers()
 
-        self._ifc_store = IfcStore(assembly=self)
         self._cache_store = None
         if enable_cache:
             self._cache_store = CacheStore(name)
@@ -208,7 +205,9 @@ class Assembly(Part):
 
         scratch_dir = Settings.scratch_dir if scratch_dir is None else pathlib.Path(scratch_dir)
 
-        write_to_fem(self, name, fem_format, overwrite, fem_converter, scratch_dir, metadata, make_zip_file, model_data_only)
+        write_to_fem(
+            self, name, fem_format, overwrite, fem_converter, scratch_dir, metadata, make_zip_file, model_data_only
+        )
 
         # Execute
         if execute:
@@ -288,6 +287,13 @@ class Assembly(Part):
 
     @property
     def ifc_store(self) -> IfcStore:
+        if self._ifc_store is None:
+            from ada.cadit.ifc.store import IfcStore
+            from ada.cadit.ifc.utils import assembly_to_ifc_file
+
+            self._ifc_file = assembly_to_ifc_file(self)
+            self._ifc_store = IfcStore(assembly=self)
+
         return self._ifc_store
 
     @ifc_store.setter

{ada-py-0.0.45.dev8 → ada-py-0.2.0}/src/ada/api/spatial/part.py

@@ -6,6 +6,7 @@ from itertools import chain
 from typing import TYPE_CHECKING, Any, Callable, Iterable
 
 from ada import Node, Pipe, PrimBox, PrimCyl, PrimExtrude, PrimRevolve, Shape
+from ada.api.animations import AnimationStore
 from ada.api.beams.base_bm import Beam, BeamTapered
 from ada.api.connections import JointBase
 from ada.api.containers import Beams, Connections, Materials, Nodes, Plates, Sections
@@ -76,6 +77,7 @@ class Part(BackendGeom):
         self._groups: dict[str, Group] = dict()
         self._ifc_class = ifc_class
         self._props = settings
+        self._animation_store = AnimationStore()
         if fem is not None:
             fem.parent = self
 
@@ -253,7 +255,7 @@ class Part(BackendGeom):
         return self._sections.add(section)
 
     def add_object(self, obj: Part | Beam | Plate | Wall | Pipe | Shape | Weld | Section):
-        from ada import Beam, Part, Pipe, Plate, Shape, Wall, Weld, Section
+        from ada import Beam, Part, Pipe, Plate, Section, Shape, Wall, Weld
 
         if isinstance(obj, Beam):
             return self.add_beam(obj)
@@ -791,10 +793,42 @@ class Part(BackendGeom):
 
         step_writer.export(destination_file)
 
-    def to_viewer(self, **kwargs):
-        from ada.visit.comms import send_to_viewer
+    def show(
+        self,
+        renderer="react",
+        auto_open_viewer=False,
+        host="localhost",
+        port=8765,
+        server_exe: pathlib.Path = None,
+        server_args: list[str] = None,
+        **kwargs,
+    ):
+        from ada.occ.tessellating import BatchTessellator
+        from ada.visit.comms import PYGFX_RENDERER_EXE_PY, start_ws_server
+
+        server_exe = None
+        if renderer == "pygfx":
+            server_exe = PYGFX_RENDERER_EXE_PY
+
+        # Start the websocket server
+        ws = start_ws_server(server_exe=server_exe, server_args=server_args, host=host, port=port)
+
+        # Set the rendering engine
+        if renderer == "react":
+            from ada.visit.rendering.renderer_react import RendererReact
 
-        send_to_viewer(self, **kwargs)
+            if auto_open_viewer:
+                RendererReact().show()
+
+        # Tessellate the geometry
+        bt = BatchTessellator()
+        scene = bt.tessellate_part(self)
+
+        ws.send_scene(scene, self.animation_store, **kwargs)
+
+    @property
+    def animation_store(self) -> AnimationStore:
+        return self._animation_store
 
     @property
     def parts(self) -> dict[str, Part]:

{ada-py-0.0.45.dev8 → ada-py-0.2.0}/src/ada/base/physical_objects.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import pathlib
 from typing import TYPE_CHECKING, Callable, Iterable
 
 from ada.api.transforms import Placement
@@ -160,6 +161,45 @@ class BackendGeom(Root):
 
         return occ_geom_to_poly_mesh(self, geom_repr=geom_repr, export_config=export_config)
 
+    def show(
+        self,
+        renderer="react",
+        auto_open_viewer=False,
+        host="localhost",
+        port=8765,
+        server_exe: pathlib.Path = None,
+        server_args: list[str] = None,
+        dry_run=False,
+    ):
+        from itertools import groupby
+
+        import trimesh
+
+        from ada.occ.tessellating import BatchTessellator
+        from ada.visit.comms import start_ws_server
+        from ada.visit.gltf.optimize import concatenate_stores
+        from ada.visit.gltf.store import merged_mesh_to_trimesh_scene
+
+        bt = BatchTessellator()
+        mesh_stores = list(bt.batch_tessellate([self]))
+
+        scene = trimesh.Scene()
+        mesh_map = []
+
+        for mat_id, meshes in groupby(mesh_stores, lambda x: x.material):
+            meshes = list(meshes)
+
+            merged_store = concatenate_stores(meshes)
+            mesh_map.append((mat_id, meshes, merged_store))
+            merged_mesh_to_trimesh_scene(scene, merged_store, bt.get_mat_by_id(mat_id), mat_id, None)
+
+        if dry_run:
+            return None
+
+        ws = start_ws_server(server_exe=server_exe, server_args=server_args, host=host, port=port)
+        ws.send_scene(scene)
+        return scene.show("notebook")
+
     @property
     def booleans(self) -> list[Boolean]:
         return self._booleans

{ada-py-0.0.45.dev8 → ada-py-0.2.0}/src/ada/cadit/ifc/convert_length_unit_patch.py

@@ -121,4 +121,4 @@ class Patcher:
 
         if self.file.schema == "IFC2X3":
             ifcopenshell.api.owner.settings.get_user = old_get_user
-            ifcopenshell.api.owner.settings.get_application = old_get_application
+            ifcopenshell.api.owner.settings.get_application = old_get_application

{ada-py-0.0.45.dev8 → ada-py-0.2.0}/src/ada/cadit/ifc/units_conversion.py

@@ -1,8 +1,9 @@
-from typing import Iterable, Any
+from typing import Any, Iterable
 
+import ifcopenshell.api
 import ifcopenshell.util.element
 import ifcopenshell.util.unit
-import ifcopenshell.api
+
 from ada.base.units import Units
 from ada.cadit.ifc.convert_length_unit_patch import Patcher
 

{ada-py-0.0.45.dev8 → ada-py-0.2.0}/src/ada/calc/beams.py

@@ -6,8 +6,6 @@ from ada import Beam
 from ada.core.utils import Counter
 from ada.visit.plots import easy_plotly
 
-from .utils import equation_compiler
-
 
 class ResType:
     displ = "DISPL"
@@ -79,12 +77,18 @@ class BeamCalc:
         self._p.append((name, p, x, use_relative_position))
 
     def get_displ_formula(self):
+        from .utils import equation_compiler
+
         return equation_compiler(displ, True)
 
     def get_shear_formula(self):
+        from .utils import equation_compiler
+
         return equation_compiler(shear, True)
 
     def get_moment_formula(self):
+        from .utils import equation_compiler
+
         return equation_compiler(moment, True)
 
     def _repr_html_(self):

{ada-py-0.0.45.dev8 → ada-py-0.2.0}/src/ada/fem/__init__.py

@@ -9,7 +9,13 @@ from .loads import Load, LoadCase, LoadGravity, LoadPoint, LoadPressure
 from .outputs import FieldOutput, HistOutput
 from .sections import ConnectorSection, FemSection
 from .sets import FemSet
-from .steps import StepEigen, StepExplicit, StepImplicitStatic, StepSteadyState, StepImplicitDynamic
+from .steps import (
+    StepEigen,
+    StepExplicit,
+    StepImplicitDynamic,
+    StepImplicitStatic,
+    StepSteadyState,
+)
 from .surfaces import Surface
 
 __all__ = [
@@ -21,6 +27,7 @@ __all__ = [
     "StepSteadyState",
     "StepEigen",
     "StepImplicitStatic",
+    "StepImplicitDynamic",
     "StepExplicit",
     "Surface",
     "Elem",

{ada-py-0.0.45.dev8 → ada-py-0.2.0}/src/ada/fem/common.py

@@ -1,9 +1,10 @@
 from __future__ import annotations
 
-import numpy as np
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
+import numpy as np
+
 from ada.config import Settings
 
 if TYPE_CHECKING:

{ada-py-0.0.45.dev8 → ada-py-0.2.0}/src/ada/fem/concept.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass, field
 from itertools import chain
-from typing import TYPE_CHECKING, Dict, Iterable, List, Tuple, Union
+from typing import TYPE_CHECKING, Dict, Iterable, List, Union
 
 from ada.api.containers import Nodes
 from ada.config import logger
@@ -38,7 +38,7 @@ if TYPE_CHECKING:
     from ada.fem.results.common import Mesh
     from ada.fem.steps import Step
 
-_step_types = Union["StepSteadyState", "StepEigen", "StepImplicit", "StepExplicit"]
+_step_types = Union["StepSteadyState", "StepEigen", "StepImplicitStatic", "StepExplicit"]
 
 
 @dataclass
@@ -66,8 +66,9 @@ class FEM:
     constraints: Dict[str, Constraint] = field(init=False, default_factory=dict)
 
     bcs: List[Bc] = field(init=False, default_factory=list)
-    steps: List[Union[StepSteadyState, StepEigen, StepImplicitStatic, StepExplicit]] = field(init=False,
-                                                                                             default_factory=list)
+    steps: List[Union[StepSteadyState, StepEigen, StepImplicitStatic, StepExplicit]] = field(
+        init=False, default_factory=list
+    )
 
     nodes: Nodes = field(default_factory=Nodes, init=True)
     ref_points: Nodes = field(default_factory=Nodes, init=True)
@@ -130,13 +131,13 @@ class FEM:
         return mass
 
     def add_set(
-            self,
-            fem_set: FemSet,
-            p=None,
-            vol_box=None,
-            vol_cyl=None,
-            single_member=False,
-            tol=1e-4,
+        self,
+        fem_set: FemSet,
+        p=None,
+        vol_box=None,
+        vol_cyl=None,
+        single_member=False,
+        tol=1e-4,
     ) -> FemSet:
         """
         :param fem_set: A fem set object
@@ -250,7 +251,8 @@ class FEM:
         connector.parent = self
         if not isinstance(self.parent, Assembly):
             logger.warning(
-                "Connector Elements can usually only be added to an Assembly object. Please check your model.")
+                "Connector Elements can usually only be added to an Assembly object. Please check your model."
+            )
 
         self.elements.add(connector)
         connector.csys.parent = self