Bug/add component shared master (#567)

Co-authored-by: jonahrb <[email protected]>
Co-authored-by: Roberto Pastor Muela <[email protected]>

Author: 3 people

src/ansys/geometry/core/designer/body.py

@@ -679,8 +679,7 @@ def copy(self, parent: "Component", name: str = None) -> "Body":  # noqa: D102
         tb = MasterBody(
             response.master_id, copy_name, self._grpc_client, is_surface=self.is_surface
         )
-        parent._transformed_part.part.bodies.append(tb)
-        # TODO: fix when DMS ObjectPath is fixed - previously we return the body with response.id
+        parent._master_component.part.bodies.append(tb)
         body_id = f"{parent.id}/{tb.id}" if parent.parent_component else tb.id
         return Body(body_id, response.name, parent, tb)
 

src/ansys/geometry/core/designer/component.py

@@ -87,9 +87,9 @@ class Component:
         If a component already exists on the server, you can pass in its ID to create it on the
         client-side data model. If this is argument is present, a new Component will not be created
         on the server.
-    transformed_part : MasterComponent, optional
+    master_component : MasterComponent, optional
         This argument should be present when creating a nested instance component. It will use the
-        given transformed_part instead of creating a new one.
+        given master_component instead of creating a new one.
     read_existing_comp : bool, optional
         Indicates whether an existing component on the service should be read
         or not. By default, ``False``. This is only valid when connecting
@@ -112,7 +112,7 @@ def __init__(
         grpc_client: GrpcClient,
         template: Optional["Component"] = None,
         preexisting_id: Optional[str] = None,
-        transformed_part: Optional[MasterComponent] = None,
+        master_component: Optional[MasterComponent] = None,
         read_existing_comp: bool = False,
     ):
         """Initialize ``Component`` class."""
@@ -146,32 +146,31 @@ def __init__(
         self._parent_component = parent_component
         self._is_alive = True
         self._shared_topology = None
-        self._transformed_part = transformed_part
+        self._master_component = master_component
 
         # Populate client data model
         if template:
             # If this is not a nested instance
-            if not transformed_part:
+            if not master_component:
                 # Create new MasterComponent, but use template's Part
-                tp = MasterComponent(
+                master = MasterComponent(
                     uuid.uuid4(),
-                    f"tp_{name}",
-                    template._transformed_part.part,
-                    template._transformed_part.transform,
+                    f"master_{name}",
+                    template._master_component.part,
+                    template._master_component.transform,
                 )
-                tp.part.parts.append(tp)
-                self._transformed_part = tp
+                self._master_component = master
 
             # Recurse - Create more children components from template's remaining children
             self.__create_children(template)
-            return
 
         elif not read_existing_comp:
             # This is an independent Component - Create new Part and MasterComponent
             p = Part(uuid.uuid4(), f"p_{name}", [], [])
-            tp = MasterComponent(uuid.uuid4(), f"tp_{name}", p)
-            p.parts.append(tp)
-            self._transformed_part = tp
+            master = MasterComponent(uuid.uuid4(), f"master_{name}", p)
+            self._master_component = master
+
+        self._master_component.occurrences.append(self)
 
     @property
     def id(self) -> str:
@@ -192,7 +191,7 @@ def components(self) -> List["Component"]:
     def bodies(self) -> List[Body]:
         """``Body`` objects inside of the component."""
         bodies = []
-        for body in self._transformed_part.part.bodies:
+        for body in self._master_component.part.bodies:
             id = f"{self.id}/{body.id}" if self.parent_component else body.id
             bodies.append(Body(id, body.name, self, body))
         return bodies
@@ -242,7 +241,7 @@ def __create_children(self, template: "Component") -> None:
                 self._grpc_client,
                 template=template_comp,
                 preexisting_id=new_id,
-                transformed_part=template_comp._transformed_part,
+                master_component=template_comp._master_component,
             )
             self.components.append(new)
 
@@ -257,7 +256,7 @@ def get_world_transform(self) -> Matrix44:
         """
         if self.parent_component is None:
             return IDENTITY_MATRIX44
-        return self.parent_component.get_world_transform() * self._transformed_part.transform
+        return self.parent_component.get_world_transform() * self._master_component.transform
 
     @protect_grpc
     def modify_placement(
@@ -308,7 +307,7 @@ def modify_placement(
                 rotation_angle=angle.value.m,
             )
         )
-        self._transformed_part.transform = grpc_matrix_to_matrix(response.matrix)
+        self._master_component.transform = grpc_matrix_to_matrix(response.matrix)
 
     def reset_placement(self):
         """
@@ -336,7 +335,25 @@ def add_component(self, name: str, template: Optional["Component"] = None) -> "C
         Component
             New component with no children in the design assembly.
         """
-        self._components.append(Component(name, self, self._grpc_client, template=template))
+        new_comp = Component(name, self, self._grpc_client, template=template)
+        master = new_comp._master_component
+        master_id = new_comp.id.split("/")[-1]
+
+        for comp in self._master_component.occurrences:
+            if comp.id != self.id:
+                comp.components.append(
+                    Component(
+                        name,
+                        comp,
+                        self._grpc_client,
+                        template,
+                        preexisting_id=f"{comp.id}/{master_id}",
+                        master_component=master,
+                        read_existing_comp=True,
+                    )
+                )
+
+        self.components.append(new_comp)
         return self._components[-1]
 
     @protect_grpc
@@ -402,7 +419,7 @@ def extrude_sketch(
         self._grpc_client.log.debug(f"Extruding sketch provided on {self.id}. Creating body...")
         response = self._bodies_stub.CreateExtrudedBody(request)
         tb = MasterBody(response.master_id, name, self._grpc_client, is_surface=False)
-        self._transformed_part.part.bodies.append(tb)
+        self._master_component.part.bodies.append(tb)
         return Body(response.id, response.name, self, tb)
 
     @protect_grpc
@@ -449,7 +466,7 @@ def extrude_face(self, name: str, face: Face, distance: Union[Quantity, Distance
         response = self._bodies_stub.CreateExtrudedBodyFromFaceProfile(request)
 
         tb = MasterBody(response.master_id, name, self._grpc_client, is_surface=False)
-        self._transformed_part.part.bodies.append(tb)
+        self._master_component.part.bodies.append(tb)
         return Body(response.id, response.name, self, tb)
 
     @protect_grpc
@@ -486,7 +503,7 @@ def create_surface(self, name: str, sketch: Sketch) -> Body:
         response = self._bodies_stub.CreatePlanarBody(request)
 
         tb = MasterBody(response.master_id, name, self._grpc_client, is_surface=True)
-        self._transformed_part.part.bodies.append(tb)
+        self._master_component.part.bodies.append(tb)
         return Body(response.id, response.name, self, tb)
 
     @protect_grpc
@@ -526,7 +543,7 @@ def create_surface_from_face(self, name: str, face: Face) -> Body:
         response = self._bodies_stub.CreateBodyFromFace(request)
 
         tb = MasterBody(response.master_id, name, self._grpc_client, is_surface=True)
-        self._transformed_part.part.bodies.append(tb)
+        self._master_component.part.bodies.append(tb)
         return Body(response.id, response.name, self, tb)
 
     @check_input_types

src/ansys/geometry/core/designer/design.py

@@ -570,25 +570,27 @@ def __read_existing_design(self) -> None:
         created_components = {self.id: self}
         created_bodies = {}
 
-        # Make dummy TP for design since server doesn't have one
-        self._transformed_part = MasterComponent("1", "tp_design", created_parts[self.id])
+        # Make dummy master for design since server doesn't have one
+        self._master_component = MasterComponent("1", "master_design", created_parts[self.id])
 
         # Create MasterComponents
-        for tp in response.transformed_parts:
-            part = created_parts.get(tp.part_master.id)
-            new_tp = MasterComponent(tp.id, tp.name, part, grpc_matrix_to_matrix(tp.placement))
-            created_tps[tp.id] = new_tp
+        for master in response.transformed_parts:
+            part = created_parts.get(master.part_master.id)
+            new_master = MasterComponent(
+                master.id, master.name, part, grpc_matrix_to_matrix(master.placement)
+            )
+            created_tps[master.id] = new_master
 
         # Create Components
         for comp in response.components:
             parent = created_components.get(comp.parent_id)
-            tp = created_tps.get(comp.master_id)
+            master = created_tps.get(comp.master_id)
             c = Component(
                 comp.name,
                 parent,
                 self._grpc_client,
                 preexisting_id=comp.id,
-                transformed_part=tp,
+                master_component=master,
                 read_existing_comp=True,
             )
             created_components[comp.id] = c

src/ansys/geometry/core/designer/part.py

@@ -1,9 +1,12 @@
 """Provides the ``Part`` class module."""
-from beartype.typing import List
+from beartype.typing import TYPE_CHECKING, List
 
 from ansys.geometry.core.designer.body import MasterBody
 from ansys.geometry.core.math import IDENTITY_MATRIX44, Matrix44
 
+if TYPE_CHECKING:
+    from ansys.geometry.core.designer.component import Component
+
 
 class Part:
     """
@@ -17,19 +20,19 @@ class Part:
         Unique identifier for this part.
     name : str
         Name of this part.
-    parts : List[MasterComponent]
+    components : List[MasterComponent]
         List of MasterComponent children that this Part contains.
     bodies : List[MasterBody]
         List of MasterBody children that this Part contains. These are master bodies.
     """
 
     def __init__(
-        self, id: str, name: str, parts: List["MasterComponent"], bodies: List[MasterBody]
+        self, id: str, name: str, components: List["MasterComponent"], bodies: List[MasterBody]
     ) -> None:
         """Initialize the ``Part`` class."""
         self._id: str = id
         self._name: str = name
-        self._parts: List["MasterComponent"] = parts
+        self._components: List["MasterComponent"] = components
         self._bodies: List[MasterBody] = bodies
 
     @property
@@ -43,13 +46,13 @@ def name(self) -> str:
         return self._name
 
     @property
-    def parts(self) -> List["MasterComponent"]:
+    def components(self) -> List["MasterComponent"]:
         """``MasterComponent`` children that this ``Part`` contains."""
-        return self._parts
+        return self._components
 
-    @parts.setter
-    def parts(self, parts: List["MasterComponent"]) -> None:
-        self._parts = parts
+    @components.setter
+    def components(self, components: List["MasterComponent"]) -> None:
+        self._components = components
 
     @property
     def bodies(self) -> List[MasterBody]:
@@ -69,7 +72,7 @@ def __repr__(self) -> str:
         return (
             f"Part(id={self.id}, "
             f"name={self.name}, "
-            f"parts={[p.name for p in self.parts]}, "
+            f"parts={[p.name for p in self.components]}, "
             f"bodies={[b.name for b in self.bodies]})"
         )
 
@@ -103,7 +106,9 @@ def __init__(
         self._id: str = id
         self._name: str = name
         self._part: Part = part
+        part.components.append(self)
         self._transform: Matrix44 = transform
+        self._occurrences: List["Component"] = []
 
     @property
     def id(self) -> str:
@@ -115,6 +120,11 @@ def name(self) -> str:
         """Name of the transformed part."""
         return self._name
 
+    @property
+    def occurrences(self) -> List["Component"]:
+        """All occurrences of this component."""
+        return self._occurrences
+
     @property
     def part(self) -> Part:
         """The master part of this transformed part."""

tests/integration/test_design.py

@@ -1336,14 +1336,14 @@ def test_component_instances(modeler: Modeler):
     assert len(body_ids) == len(set(body_ids))
 
     # Assert all instances have unique MasterComponents
-    comp_templates = [wheel2._transformed_part, wheel3._transformed_part, wheel4._transformed_part]
+    comp_templates = [wheel2._master_component, wheel3._master_component, wheel4._master_component]
     assert len(comp_templates) == len(set(comp_templates))
 
     # Assert all instances have the same Part
     comp_parts = [
-        wheel2._transformed_part.part,
-        wheel3._transformed_part.part,
-        wheel4._transformed_part.part,
+        wheel2._master_component.part,
+        wheel3._master_component.part,
+        wheel4._master_component.part,
     ]
     assert len(set(comp_parts)) == 1
 
@@ -1612,3 +1612,42 @@ def test_boolean_body_operations(modeler: Modeler, skip_not_on_linux_service):
     assert not copy3.is_alive
     assert body3.is_alive
     assert Accuracy.length_is_equal(copy1.volume.m, 1)
+
+
+def test_child_component_instances(modeler: Modeler):
+    """Test creation of child ``Component`` instances and check the data model reflects that."""
+
+    design_name = "ChildComponentInstances_Test"
+    design = modeler.create_design(design_name)
+    # Create a base component
+    base1 = design.add_component("Base1")
+    comp1 = base1.add_component("A")
+    comp2 = base1.add_component("B")
+
+    # Create the solid body for the base
+    sketch = Sketch().box(Point2D([5, 10]), 10, 20)
+    comp2.extrude_sketch("Bottom", sketch, 5)
+
+    # Create the 2nd base
+    base2 = design.add_component("Base2", base1)
+    base2.modify_placement(Vector3D([30, 0, 0]))
+
+    # Create top part (applies to both Base1 and Base2)
+    sketch = Sketch(Plane(Point3D([0, 5, 5]))).box(Point2D([5, 2.5]), 10, 5)
+    comp1.extrude_sketch("Top", sketch, 5)
+
+    # create the first child component
+    comp1.add_component("Child1")
+    comp1.extrude_sketch("Child1_body", Sketch(Plane([5, 7.5, 10])).box(Point2D([0, 0]), 1, 1), 1)
+
+    assert len(comp1.components) == 1
+    assert len(base2.components[0].components) == 1
+    assert len(comp1.components) == len(base2.components[0].components)
+
+    # create the second child component
+    comp1.add_component("Child2")
+    comp1.extrude_sketch("Child2_body", Sketch(Plane([5, 7.5, 10])).box(Point2D([0, 0]), 1, 1), -1)
+
+    assert len(comp1.components) == 2
+    assert len(base2.components[0].components) == 2
+    assert len(comp1.components) == len(base2.components[0].components)