feat(cad): FEM/gmsh meshing is backend-agnostic (works under adacpp)

Rewrite import_into_gmsh_use_nativepointer to go through the active CAD
backend instead of pythonocc directly: iterate sub-shapes via
backend.solids/faces/edges, translate via backend.transform, and feed gmsh
each sub-shape pointer via backend.to_topods_pointer. Under adacpp the pointer
is to its OCCT 7.9.3 TopoDS_Shape — ABI-valid for gmsh's OCCT, so gmsh stays a
pointer consumer with no kernel mixing.

Add solids/edges/to_topods_pointer/make_wire to both backends; route
Beam.line_occ through backend.make_wire (was raw pythonocc).

Under ADAPY_CAD_BACKEND=adacpp: solid + shell + line FEM meshing all work
(IPE300 solid mesh = 506 elems). tests/core under adacpp 614->638 pass.
OccBackend unchanged (655 pass), ruff clean.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: Krande

src/ada/api/beams/base_bm.py

@@ -308,11 +308,9 @@ def bbox(self) -> BoundingBox:
         return self._bbox
 
     def line_occ(self):
-        from ada.occ.utils import make_wire_from_points
+        from ada.cad import active_backend
 
-        points = [self.n1.p, self.n2.p]
-
-        return make_wire_from_points(points)
+        return active_backend().make_wire([self.n1.p, self.n2.p])
 
     def shell_occ(self) -> ShapeHandle:
         from ada.occ.geom.cache import get_shell_occ

src/ada/cad/__init__.py

@@ -52,6 +52,7 @@ class CadBackend(Protocol):
     name: str
 
     def build(self, geometry: "Geometry") -> ShapeHandle: ...
+    def make_wire(self, points: "list") -> ShapeHandle: ...
     def make_box(self, dx: float, dy: float, dz: float) -> ShapeHandle: ...
     def make_cylinder(self, radius: float, height: float) -> ShapeHandle: ...
     def make_sphere(self, radius: float) -> ShapeHandle: ...
@@ -69,8 +70,11 @@ def serialize(self, shape: ShapeHandle) -> str: ...
     def is_valid(self, shape: ShapeHandle) -> bool: ...
     def volume(self, shape: ShapeHandle) -> float: ...
     def faces(self, shape: ShapeHandle) -> list[ShapeHandle]: ...
+    def solids(self, shape: ShapeHandle) -> list[ShapeHandle]: ...
+    def edges(self, shape: ShapeHandle) -> list[ShapeHandle]: ...
     def vertex_points(self, shape: ShapeHandle) -> list[tuple[float, float, float]]: ...
     def face_plane(self, face: ShapeHandle) -> "tuple[Point, Direction] | None": ...
+    def to_topods_pointer(self, shape: ShapeHandle) -> int: ...
 
 
 class AdacppBackend:
@@ -180,6 +184,9 @@ def _encode_curve(self, curve) -> list[list[float]]:
             f"AdacppBackend.build: profile curve {type(curve).__name__!r} not yet ported to adacpp."
         )
 
+    def make_wire(self, points: "list") -> ShapeHandle:
+        return self._cad.make_wire([[float(c) for c in self._xyz(p)] for p in points])
+
     def make_box(self, dx: float, dy: float, dz: float) -> ShapeHandle:
         return self._cad.make_box(dx, dy, dz)
 
@@ -260,6 +267,24 @@ def faces(self, shape: ShapeHandle) -> list[ShapeHandle]:
             raise NotImplementedError("adacpp.cad.faces is not available in this build")
         return list(fn(shape))
 
+    def solids(self, shape: ShapeHandle) -> list[ShapeHandle]:
+        fn = getattr(self._cad, "solids", None)
+        if fn is None:
+            raise NotImplementedError("adacpp.cad.solids is not available in this build")
+        return list(fn(shape))
+
+    def edges(self, shape: ShapeHandle) -> list[ShapeHandle]:
+        fn = getattr(self._cad, "edges", None)
+        if fn is None:
+            raise NotImplementedError("adacpp.cad.edges is not available in this build")
+        return list(fn(shape))
+
+    def to_topods_pointer(self, shape: ShapeHandle) -> int:
+        fn = getattr(self._cad, "to_topods_pointer", None)
+        if fn is None:
+            raise NotImplementedError("adacpp.cad.to_topods_pointer is not available in this build")
+        return fn(shape)
+
     def vertex_points(self, shape: ShapeHandle) -> list[tuple[float, float, float]]:
         fn = getattr(self._cad, "vertex_points", None)
         if fn is None:
@@ -376,6 +401,11 @@ def build(self, geometry: "Geometry") -> ShapeHandle:
 
         return geom_to_occ_geom(geometry)
 
+    def make_wire(self, points: "list") -> ShapeHandle:
+        from ada.occ.utils import make_wire_from_points
+
+        return make_wire_from_points(list(points))
+
     def make_box(self, dx: float, dy: float, dz: float) -> ShapeHandle:
         # Centered axis-aligned box: matches adacpp.cad.make_box semantics
         # (corner at -d/2, opposite corner at +d/2). adapy's helper expects
@@ -454,6 +484,17 @@ def faces(self, shape: ShapeHandle) -> list[ShapeHandle]:
         # face, so callers iterate without re-entering the backend per element.
         return list(self._TopologyExplorer(shape).faces())
 
+    def solids(self, shape: ShapeHandle) -> list[ShapeHandle]:
+        return list(self._TopologyExplorer(shape).solids())
+
+    def edges(self, shape: ShapeHandle) -> list[ShapeHandle]:
+        return list(self._TopologyExplorer(shape).edges())
+
+    def to_topods_pointer(self, shape: ShapeHandle) -> int:
+        # Under this backend a ShapeHandle IS a TopoDS_Shape; its SWIG pointer
+        # is int(shape.this) — the value gmsh's importShapesNativePointer wants.
+        return int(shape.this)
+
     def vertex_points(self, shape: ShapeHandle) -> list[tuple[float, float, float]]:
         # Walk every vertex and return all coordinates as one list. The
         # per-vertex loop stays inside the backend (the abstraction boundary

src/ada/fem/meshing/concepts.py

@@ -398,36 +398,42 @@ def import_into_gmsh_using_step(
 
 
 def import_into_gmsh_use_nativepointer(obj: BackendGeom | Shape, geom_repr: GeomRepr, model: gmsh.model) -> List[tuple]:
-    from OCC.Extend.TopologyUtils import TopologyExplorer
-
+    # gmsh consumes raw OCCT shapes via native pointers. We go through the
+    # active CAD backend (sub-shape iteration + the to_topods_pointer bridge)
+    # so this works on either backend without kernel mixing: under adacpp the
+    # pointer is to its OCCT 7.9.x TopoDS_Shape, ABI-valid for gmsh's OCCT.
     from ada import Placement, PrimBox
-    from ada.occ.utils import transform_shape
+    from ada.cad import active_backend
 
+    backend = active_backend()
     abs_place = obj.placement.get_absolute_placement()
 
     def transform_occ(geo):
-
         if Placement() != abs_place:
-            geo = transform_shape(geo, transform=abs_place)
+            o = abs_place.origin
+            mat = np.array(
+                [[1.0, 0.0, 0.0, float(o[0])],
+                 [0.0, 1.0, 0.0, float(o[1])],
+                 [0.0, 0.0, 1.0, float(o[2])],
+                 [0.0, 0.0, 0.0, 1.0]]
+            )
+            geo = backend.transform(geo, mat, copy=True)
         return geo
 
-    ents = []
     if geom_repr == GeomRepr.SOLID:
         geom = transform_occ(obj.solid_occ())
-        t = TopologyExplorer(geom)
-        geom_iter = t.solids()
+        sub_shapes = backend.solids(geom)
     elif geom_repr == GeomRepr.SHELL:
         geom = obj.shell_occ() if type(obj) not in (PrimBox,) else obj.solid_occ()
         geom = transform_occ(geom)
-        t = TopologyExplorer(geom)
-        geom_iter = t.faces()
+        sub_shapes = backend.faces(geom)
     else:
         geom = transform_occ(obj.line_occ())
-        t = TopologyExplorer(geom)
-        geom_iter = t.edges()
+        sub_shapes = backend.edges(geom)
 
-    for shp in geom_iter:
-        ents += model.occ.importShapesNativePointer(int(shp.this))
+    ents = []
+    for shp in sub_shapes:
+        ents += model.occ.importShapesNativePointer(backend.to_topods_pointer(shp))
 
     if len(ents) == 0:
         raise ValueError("No entities found")