emerge 0.6.3__tar.gz → 0.6.6__tar.gz

emerge-0.6.6/.bumpversion.toml

@@ -0,0 +1,72 @@
+[tool.bumpversion]
+current_version = "0.6.6"
+parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
+serialize = ["{major}.{minor}.{patch}"]
+search = "{current_version}"
+replace = "{new_version}"
+regex = false
+ignore_missing_version = false
+ignore_missing_files = false
+tag = true
+sign_tags= false
+tag_name = "v{new_version}"
+tag_message = "Bump version: {current_version} → {new_version}"
+allow_dirty = false
+commit = true
+message = "Bump version: {current_version} → {new_version}"
+moveable_tags = []
+commit_args = ""
+setup_hooks = []
+pre_commit_hooks = []
+post_commit_hooks = []
+
+[[tool.bumpversion.files]]
+filename = "uv.lock"
+
+[[tool.bumpversion.files]]
+filename = "pyproject.toml"
+
+[[tool.bumpversion.files]]
+filename = "src/emerge/__init__.py"
+
+[[tool.bumpversion.files]]
+filename = "examples/demo1_stepped_imp_filter.py"
+
+[[tool.bumpversion.files]]
+filename = "examples/demo2_combline_filter.py"
+
+[[tool.bumpversion.files]]
+filename = "examples/demo3_coupled_line_filter.py"
+
+[[tool.bumpversion.files]]
+filename = "examples/demo4_patch_antenna.py"
+
+[[tool.bumpversion.files]]
+filename = "examples/demo5_revolve.py"
+
+[[tool.bumpversion.files]]
+filename = "examples/demo6_striplines_with_vias.py"
+
+[[tool.bumpversion.files]]
+filename = "examples/demo7_periodic_cells.py"
+
+[[tool.bumpversion.files]]
+filename = "examples/demo8_waveguide_bpf_synthesis.py"
+
+[[tool.bumpversion.files]]
+filename = "examples/demo9_dielectric_resonator.py"
+
+[[tool.bumpversion.files]]
+filename = "examples/demo10_sgh.py"
+
+[[tool.bumpversion.files]]
+filename = "examples/demo11_lumped_element_filter.py"
+
+[[tool.bumpversion.files]]
+filename = "examples/demo12_mode_alignment.py"
+
+[[tool.bumpversion.files]]
+filename = "examples/demo13_helix_antenna.py"
+
+[[tool.bumpversion.files]]
+filename = "examples/demo14_boundary_selection.py"

{emerge-0.6.3 → emerge-0.6.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emerge
-Version: 0.6.3
+Version: 0.6.6
 Summary: An open source EM FEM simulator in Python
 Project-URL: Homepage, https://github.com/FennisRobert/EMerge
 Project-URL: Issues, https://github.com/FennisRobert/EMerge/issues

{emerge-0.6.3 → emerge-0.6.6}/emerge/__init__.py

@@ -18,7 +18,7 @@ along with this program; if not, see
 """
 import os
 
-__version__ = "0.6.3"
+__version__ = "0.6.6"
 
 ############################################################
 #               HANDLE ENVIRONMENT VARIABLES              #
@@ -52,6 +52,7 @@ from ._emerge.cs import CoordinateSystem, CS, GCS, Plane, Axis, XAX, YAX, ZAX, X
 from ._emerge.coord import Line
 from ._emerge import geo
 from ._emerge.selection import Selection, FaceSelection, DomainSelection, EdgeSelection
+from ._emerge.geometry import select
 from ._emerge.mth.common_functions import norm, coax_rout, coax_rin
 from ._emerge.physics.microwave.sc import stratton_chu
 from ._emerge.periodic import RectCell, HexCell

{emerge-0.6.3 → emerge-0.6.6}/emerge/_emerge/geo/__init__.py

@@ -19,6 +19,6 @@ from .pcb import PCB
 from .pmlbox import pmlbox
 from .horn import Horn
 from .shapes import Cylinder, CoaxCylinder, Box, XYPlate, HalfSphere, Sphere, Plate, OldBox, Alignment, Cone
-from .operations import subtract, add, embed, remove, rotate, mirror, change_coordinate_system, translate, intersect
+from .operations import subtract, add, embed, remove, rotate, mirror, change_coordinate_system, translate, intersect, unite
 from .polybased import XYPolygon, GeoPrism, Disc, Curve
 from .step import STEPItems

{emerge-0.6.3 → emerge-0.6.6}/emerge/_emerge/geo/operations.py

@@ -15,8 +15,8 @@
 # along with this program; if not, see
 # <https://www.gnu.org/licenses/>.
 
-from typing import TypeVar
-from ..geometry import GeoSurface, GeoVolume, GeoObject, GeoPoint, GeoEdge
+from typing import TypeVar, overload
+from ..geometry import GeoSurface, GeoVolume, GeoObject, GeoPoint, GeoEdge, GeoPolygon
 from ..cs import CoordinateSystem, GCS
 import gmsh
 import numpy as np
@@ -144,7 +144,8 @@ def rotate(main: GeoVolume,
            c0: tuple[float, float, float],
            ax: tuple[float, float, float],
            angle: float,
-           degree=True) -> GeoVolume:
+           make_copy: bool = False,
+           degree=True) -> GeoObject:
     """Rotates a GeoVolume object around an axist defined at a coordinate.
 
     Args:
@@ -159,17 +160,23 @@ def rotate(main: GeoVolume,
     """
     if degree:
         angle = angle * np.pi/180
-    gmsh.model.occ.rotate(main.dimtags, *c0, *ax, -angle)
-
+    
+    if make_copy:
+        rotate_obj = main.make_copy()
+    else:
+        rotate_obj = main
+     
+    gmsh.model.occ.rotate(rotate_obj.dimtags, *c0, *ax, -angle)
     # Rotate the facepointers
-    for fp in main._all_pointers:
+    for fp in rotate_obj._all_pointers:
         fp.rotate(c0, ax, angle)
-    return main
+    return rotate_obj
 
 def translate(main: GeoVolume,
               dx: float = 0,
               dy: float = 0,
-              dz: float = 0) -> GeoVolume:
+              dz: float = 0,
+              make_copy: bool = False) -> GeoObject:
     """Translates the GeoVolume object along a given displacement
 
     Args:
@@ -177,17 +184,23 @@ def translate(main: GeoVolume,
         dx (float, optional): The X-displacement in meters. Defaults to 0.
         dy (float, optional): The Y-displacement in meters. Defaults to 0.
         dz (float, optional): The Z-displacement in meters. Defaults to 0.
+        make_copy (bool, optional): Whether to make a copy first before translating.
 
     Returns:
-        GeoVolume: The translated object
+        GeoObject: The translated object
     """
-    gmsh.model.occ.translate(main.dimtags, dx, dy, dz)
+    
+    if make_copy:
+        trans_obj = main.make_copy()
+    else:
+        trans_obj = main
+    gmsh.model.occ.translate(trans_obj.dimtags, dx, dy, dz)
     
      # Rotate the facepointers
-    for fp in main._all_pointers:
+    for fp in trans_obj._all_pointers:
         fp.translate(dx, dy, dz)
 
-    return main
+    return trans_obj
 
 def mirror(main: GeoObject,
            origin: tuple[float, float, float] = (0.0, 0.0, 0.0),
@@ -199,6 +212,7 @@ def mirror(main: GeoObject,
         main (GeoVolume): The object to mirror
         origin (tuple[float, float, float], optional): The point of origin in meters. Defaults to (0.0, 0.0, 0.0).
         direction (tuple[float, float, float], optional): The normal axis defining the plane of reflection. Defaults to (1.0, 0.0, 0.0).
+        make_copy (bool, optional): Whether to make a copy first before mirroring.
 
     Returns:
         GeoVolume: The mirrored GeoVolume object
@@ -211,14 +225,12 @@ def mirror(main: GeoObject,
     d = -(a*x0 + b*y0 + c*z0)
     if (a==0) and (b==0) and (c==0):
         return main
+    
     mirror_obj = main
     if make_copy:
-        new_obj = main.make_copy()
-        gmsh.model.occ.mirror(new_obj.dimtags, a,b,c,d)
-        mirror_obj = new_obj
-    else:
-        gmsh.model.occ.mirror(main.dimtags, a,b,c,d)
-
+        mirror_obj = main.make_copy()
+    gmsh.model.occ.mirror(mirror_obj.dimtags, a,b,c,d)
+    
     for fp in mirror_obj._all_pointers:
         fp.mirror(origin, direction)
     return mirror_obj
@@ -237,7 +249,7 @@ def change_coordinate_system(main: GeoObject,
         old_cs (CoordinateSystem, optional): The old coordinate system. Defaults to GCS.
 
     Returns:
-        _type_: _description_
+        GeoObject: The output object
     """
     if new_cs._is_global and old_cs._is_global:
         return main
@@ -254,4 +266,39 @@ def change_coordinate_system(main: GeoObject,
     for fp in main._all_pointers:
         fp.affine_transform(M1)
         fp.affine_transform(M2)
-    return main
+    return main
+
+@overload
+def unite(*objects: GeoVolume) -> GeoVolume: ...
+
+@overload
+def unite(*objects: GeoSurface) -> GeoSurface: ...
+
+@overload
+def unite(*objects: GeoEdge) -> GeoEdge: ...
+
+@overload
+def unite(*objects: GeoPolygon) -> GeoSurface: ...
+
+def unite(*objects: GeoObject) -> GeoObject:
+    """Applies a fusion consisting of all geometries in the argument.
+
+    Returns:
+        GeoObject: The resultant object
+    """
+    main, *rest = objects
+    if not rest:
+        return main
+    main._exists = False
+    dts = []
+    for other in rest:
+        dts.extend(other.dimtags)
+        other._exists = False
+    
+    new_dimtags, mapping = gmsh.model.occ.fuse(main.dimtags, dts)
+    
+    new_obj = GeoObject.from_dimtags(new_dimtags)._take_tools(*objects)
+    new_obj.set_material(main.material)
+    new_obj.prio_set(main._priority)
+    
+    return new_obj

{emerge-0.6.3 → emerge-0.6.6}/emerge/_emerge/geo/pcb.py

@@ -22,7 +22,7 @@ from ..geometry import GeoPolygon, GeoVolume, GeoSurface
 from ..material import Material, AIR, COPPER
 from .shapes import Box, Plate, Cylinder
 from .polybased import XYPolygon
-from .operations import change_coordinate_system
+from .operations import change_coordinate_system, unite
 from .pcb_tools.macro import parse_macro
 from .pcb_tools.calculator import PCBCalculator
 
@@ -310,7 +310,6 @@ class StripCurve(StripTurn):
         points: list[tuple[float, float]] = []
         Npts = int(np.ceil(abs(self.angle/self.dang)))
         R = self.radius-np.sign(self.angle)*self.width/2
-        print(R, self.circ_origin, self._xhat, self._yhat)
         for i in range(Npts):
             ang = abs((i+1)/Npts * self.angle * np.pi/180)
             pnew = self.circ_origin + R*(self._xhat*np.cos(ang)+self._yhat*np.sin(ang))
@@ -324,7 +323,6 @@ class StripCurve(StripTurn):
 
         Npts = int(np.ceil(abs(self.angle/self.dang)))
         R = self.radius+np.sign(self.angle)*self.width/2
-        print(R, self.circ_origin, self._xhat, self._yhat)
         for i in range(Npts):
             ang = abs((i+1)/Npts * self.angle * np.pi/180)
             pnew = self.circ_origin + R*(self._xhat*np.cos(ang)+self._yhat*np.sin(ang))
@@ -1247,7 +1245,13 @@ class PCB:
         plate = change_coordinate_system(plate, self.cs)
         return plate # type: ignore
 
-    def generate_vias(self, merge=False) -> list[Cylinder] | Cylinder:
+    @overload
+    def generate_vias(self, merge=Literal[True]) -> GeoVolume: ...
+    
+    @overload
+    def generate_vias(self, merge=Literal[False]) -> list[Cylinder]: ...
+        
+    def generate_vias(self, merge=False) -> list[Cylinder] | GeoVolume:
         """Generates the via objects.
 
         Args:
@@ -1321,7 +1325,7 @@ class PCB:
         Returns:
             list[Polygon] | GeoSurface: The output stripline polygons possibly merged if merge = True.
         """
-        polys = []
+        polys: list[GeoSurface] = []
         allx = []
         ally = []
 
@@ -1359,13 +1363,14 @@ class PCB:
 
         self.traces = polys
         if merge:
-            tags = []
-            for p in polys:
-                tags.extend(p.tags)
-                if p.material != COPPER:
-                    logger.warning(f'Merging a polygon with material {p.material} into a single polygon that will be COPPER.')
-            polys = GeoSurface(tags)
-            polys.material = COPPER
+            polys = unite(*polys)
+            # tags = []
+            # for p in polys:
+            #     tags.extend(p.tags)
+            #     if p.material != COPPER:
+            #         logger.warning(f'Merging a polygon with material {p.material} into a single polygon that will be COPPER.')
+            # polys = GeoSurface(tags)
+            # polys.material = COPPER
         return polys
                 
 ############################################################

{emerge-0.6.3 → emerge-0.6.6}/emerge/_emerge/geo/polybased.py

@@ -16,7 +16,7 @@
 # <https://www.gnu.org/licenses/>.
 from __future__ import annotations
 import numpy as np
-from ..cs import CoordinateSystem, GCS, Axis
+from ..cs import CoordinateSystem, GCS, Axis, _parse_axis
 from ..geometry import GeoVolume, GeoPolygon, GeoEdge, GeoSurface
 from .shapes import Alignment
 import gmsh
@@ -158,7 +158,35 @@ def rotate_point(point: tuple[float, float, float],
     rotated += o
     return tuple(rotated)
 
+def _dist(p1: tuple[float, float], p2: tuple[float, float]) -> float:
+    return ((p2[0]-p1[0])**2 + (p2[1]-p1[1])**2)**(0.5)
 
+def _pair_points(x1: np.ndarray,
+                 y1: np.ndarray,
+                 x2: np.ndarray,
+                 y2: np.ndarray) -> list[tuple[int,int]]:
+    if x1.shape[0]==x2.shape[0]:
+        return [(i,i) for i in range(x1.shape[0])]
+
+    #create point tuples
+    p1s = [(x,y) for x,y in zip(x1, y1)]
+    p2s = [(x,y) for x,y in zip(x2, y2)]
+    
+    pairs = []
+    for i, p1 in enumerate(p1s):
+        d1 = _dist(p1, p2s[i-1])
+        d2 = _dist(p1, p2s[i])
+        d3 = _dist(p1, p2s[i+1])
+        mind = min([d1, d2, d3])
+        if mind==d1:
+            pairs.append((i,i-1))
+            continue
+        elif mind==d2:
+            pairs.append((i,i))
+        else:
+            pairs.append((i,i+1))
+    return pairs
+            
 def orthonormalize(axis: np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
     """Generates a set of orthonormal vectors given an input vector X
 
@@ -233,8 +261,9 @@ class XYPolygon:
     """This class generalizes a polygon in an un-embedded XY space that can be embedded in 3D space.
     """
     def __init__(self, 
-                 xs: np.ndarray | list | tuple = None,
-                 ys: np.ndarray | list | tuple = None):
+                 xs: np.ndarray | list | tuple | None = None,
+                 ys: np.ndarray | list | tuple | None = None,
+                 cs: CoordinateSystem | None = None):
         """Constructs an XY-plane placed polygon.
 
         Args:
@@ -250,7 +279,13 @@ class XYPolygon:
         self.y: np.ndarray = np.asarray(ys)
 
         self.fillets: list[tuple[float, int]] = []
+        
+        self._cs: CoordinateSystem = cs
 
+    @property
+    def center(self) -> tuple[float, float]:
+        return np.mean(self.x), np.mean(self.y)
+    
     @property
     def length(self):
         return sum([((self.x[i2]-self.x[i1])**2 + (self.y[i2]-self.y[i1])**2)**0.5 for i1, i2 in zip(range(self.N-1),range(1, self.N))])
@@ -282,6 +317,10 @@ class XYPolygon:
         """
         return 0.5*np.abs(np.dot(self.x,np.roll(self.y,1))-np.dot(self.y,np.roll(self.x,1)))
 
+    def incs(self, cs: CoordinateSystem) -> XYPolygon:
+        self._cs = cs
+        return self
+
     def extend(self, xpts: list[float], ypts: list[float]) -> XYPolygon:
         """Adds a series for x and y coordinates to the existing polygon.
 
@@ -301,7 +340,7 @@ class XYPolygon:
         for i in range(self.N):
             yield (self.x[i], self.y[i])
 
-    def fillet(self, radius: float, *indices: int) -> None:
+    def fillet(self, radius: float, *indices: int) -> XYPolygon:
         """Add a fillet rounding with a given radius to the provided nodes.
 
         Example:
@@ -313,8 +352,9 @@ class XYPolygon:
         """
         for i in indices:
             self.fillets.append((radius, i))
+        return self
 
-    def _finalize(self, cs: CoordinateSystem = None) -> GeoPolygon:
+    def _make_wire(self, cs: CoordinateSystem) -> tuple[list[int], list[int], int]:
         """Turns the XYPolygon object into a GeoPolygon that is embedded in 3D space.
 
         The polygon will be placed in the XY-plane of the provided coordinate center.
@@ -340,13 +380,27 @@ class XYPolygon:
         
         add = 0
         for radius, index in self.fillets:
-            t1 = lines[index + add]
-            t2 = lines[(index+add-1) % len(lines)]
+            t1 = lines[(index + add-1) % len(lines)]
+            t2 = lines[index + add]
             tag = gmsh.model.occ.fillet2_d(t1, t2, radius)
             lines.insert(index, tag)
             add += 1
 
         wiretag = gmsh.model.occ.add_wire(lines)
+        return ptags, lines, wiretag
+        
+    def _finalize(self, cs: CoordinateSystem) -> GeoPolygon:
+        """Turns the XYPolygon object into a GeoPolygon that is embedded in 3D space.
+
+        The polygon will be placed in the XY-plane of the provided coordinate center.
+
+        Args:
+            cs (CoordinateSystem, optional): The coordinate system in which to put the polygon. Defaults to None.
+
+        Returns:
+            GeoPolygon: The resultant 3D GeoPolygon object.
+        """
+        ptags, lines, wiretag = self._make_wire(cs)
         surftag = gmsh.model.occ.add_plane_surface([wiretag,])
         poly = GeoPolygon([surftag,])
         poly.points = ptags
@@ -384,6 +438,8 @@ class XYPolygon:
         Returns:
             GeoPolygon: The resultant object.
         """
+        if self._cs is not None:
+            return self._finalize(self._cs)
         if cs is None:
             cs = GCS
         return self._finalize(cs) 
@@ -500,7 +556,34 @@ class XYPolygon:
         self.extend(xs, ys)
         return self
     
+    def connect(self, other: XYPolygon) -> GeoVolume:
+        """Connect two XYPolygons with a defined coordinate system
 
+        The coordinate system must be defined before this function can be used. To add a coordinate systme without
+        rendering the Polygon to a GeoVolume, use:
+        >>> polygon.incs(my_cs_obj)
+        
+        Args:
+            other (XYPolygon): _descrThe otheiption_
+
+        Returns:
+            GeoVolume: The resultant volume object
+        """
+        if self._cs is None:
+            raise RuntimeError('Cannot connect XYPolygons without a defined coordinate system. Set this first using .incs()')
+        if other._cs is None:
+            raise RuntimeError('Cannot connect XYPolygons without a defined coordinate system. Set this first using .incs()')
+        p1, l1, w1 = self._make_wire(self._cs)
+        p2, l2, w2 = other._make_wire(other._cs)
+        o1 = np.array(self._cs.in_global_cs(*self.center, 0)).flatten()
+        o2 = np.array(other._cs.in_global_cs(*other.center, 0)).flatten()
+        dts = gmsh.model.occ.addThruSections([w1, w2], True, parametrization="IsoParametric")
+        vol = GeoVolume([t for d,t in dts if d==3])
+        
+        vol._add_face_pointer('front',o1, self._cs.zax.np)
+        vol._add_face_pointer('back', o2, other._cs.zax.np)
+        return vol
+            
 class Disc(GeoSurface):
     
     def __init__(self, origin: tuple[float, float, float],
@@ -525,8 +608,7 @@ class Curve(GeoEdge):
                  degree: int = 3,
                  weights: list[float] | None = None,
                  knots: list[float] | None = None,
-                 ctype: Literal['Spline','BSpline','Bezier'] = 'Bezier',
-                 dstart: tuple[float, float, float] | None = None):
+                 ctype: Literal['Spline','BSpline','Bezier'] = 'Spline'):
         """Generate a Spline/Bspline or Bezier curve based on a series of points
 
         This calls the different curve features in OpenCASCADE.
@@ -547,11 +629,6 @@ class Curve(GeoEdge):
         self.xpts: np.ndarray = xpts
         self.ypts: np.ndarray = ypts
         self.zpts: np.ndarray = zpts
-        
-        if dstart is None:
-            dstart = (xpts[1]-xpts[0], ypts[1]-ypts[0], zpts[1]-zpts[0])
-        
-        self.dstart: tuple[float, float, float] = dstart
 
         points = [gmsh.model.occ.add_point(x,y,z) for x,y,z in zip(xpts, ypts, zpts)]
         
@@ -571,6 +648,14 @@ class Curve(GeoEdge):
         gmsh.model.occ.remove([(0,tag) for tag in points])
         super().__init__(tags)
     
+        gmsh.model.occ.synchronize()
+        p1 = gmsh.model.getValue(self.dim, self.tags[0], [0,])
+        p2 = gmsh.model.getValue(self.dim, self.tags[0], [1e-6])
+        self.dstart: tuple[float, float, float] = (p2[0]-p1[0], p2[1]-p1[1], p2[2]-p1[2])
+    
+        
+        
+    
     @property
     def p0(self) -> tuple[float, float, float]:
         """The start coordinate
@@ -653,7 +738,7 @@ class Curve(GeoEdge):
             zp[2] += d/2*dz
             dp = tuple(Z)
         
-        return Curve(xp, yp, zp, ctype='Spline', dstart=dp)
+        return Curve(xp, yp, zp, ctype='Spline')
     
     @staticmethod
     def helix_lh(pstart: tuple[float, float, float],
@@ -731,9 +816,12 @@ class Curve(GeoEdge):
             zp[2] += d/2*dz
             dp = tuple(Z)
         
-        return Curve(xp, yp, zp, ctype='Spline', dstart=dp)
+        return Curve(xp, yp, zp, ctype='Spline')
         
-    def pipe(self, crossection: GeoSurface | XYPolygon, max_mesh_size: float | None = None) -> GeoVolume:
+    def pipe(self, crossection: GeoSurface | XYPolygon, 
+             max_mesh_size: float | None = None,
+             start_tangent: Axis | tuple[float, float, float] | np.ndarray | None = None,
+             x_axis: Axis | tuple[float, float, float] | np.ndarray | None = None) -> GeoVolume:
         """Extrudes a surface or XYPolygon object along the given curve
 
         If a GeoSurface object is used, make sure it starts at the center of the curve. This property
@@ -744,25 +832,31 @@ class Curve(GeoEdge):
         Args:
             crossection (GeoSurface | XYPolygon): The cross section definition to be used
             max_mesh_size (float, optional): The maximum mesh size. Defaults to None
+            start_tangent (Axis, tuple, ndarray, optional): The input polygon plane normal direction. Defaults to None
+            x_axis (Axis, tuple, ndarray optional): The reference X-axis to align the input polygon. Defaults to None
         Returns:
             GeoVolume: The resultant volume object
         """
         if isinstance(crossection, XYPolygon):
-            zax = self.dstart
-            cs = Axis(np.array(zax)).construct_cs(self.p0)
-            surf = crossection.geo(cs)
+            if start_tangent is None:
+                start_tangent = self.dstart
+            if x_axis is not None:
+                xax = _parse_axis(x_axis)
+                zax = _parse_axis(self.dstart)
+                yax = zax.cross(xax)
+                cs = CoordinateSystem(xax, yax, zax, self.p0)
+            else:
+                zax = self.dstart
+                cs = Axis(np.array(zax)).construct_cs(self.p0)
+                surf = crossection.geo(cs)
         else:
             surf = crossection
         x1, y1, z1, x2, y2, z2 = gmsh.model.occ.getBoundingBox(*surf.dimtags[0])
         diag = ((x2-x1)**2 + (y2-y1)**2 + (z2-z1)**2)**(0.5)
-        
         pipetag = gmsh.model.occ.addPipe(surf.dimtags, self.tags[0], 'GuidePlan')
-        
         self.remove()
         surf.remove()
-        
         volume = GeoVolume(pipetag[0][1])
-        
         volume.max_meshsize = diag/2
         return volume
         

{emerge-0.6.3 → emerge-0.6.6}/emerge/_emerge/geo/shapes.py

@@ -31,9 +31,18 @@ class Alignment(Enum):
     CORNER = 2
 
 class Box(GeoVolume):
-    """ A class that represents a box shaped volume
+    """Creates a box volume object.
+        Specify the alignment of the box with the provided position. The options are CORNER (default)
+        for the front-left-bottom node of the box or CENTER for the center of the box.
 
-    """
+        Args:
+            width (float): The x-size
+            depth (float): The y-size
+            height (float): The z-size
+            position (tuple, optional): The position of the box. Defaults to (0,0,0).
+            alignment (Alignment, optional): Which point of the box is placed at the position. 
+                Defaults to Alignment.CORNER.
+        """
 
     def __init__(self, 
                  width: float, 
@@ -94,7 +103,12 @@ class Box(GeoVolume):
 
     
 class Sphere(GeoVolume):
+    """Generates a sphere objected centered ont he position with the given radius
 
+    Args:
+        radius (float): The sphere radius
+        position (tuple, optional): The center position. Defaults to (0,0,0).
+    """
     def __init__(self, 
                  radius: float,
                  position: tuple = (0,0,0)):
@@ -109,6 +123,17 @@ class Sphere(GeoVolume):
         self.tags: list[int] = [gmsh.model.occ.addSphere(x,y,z,radius),]
 
 class XYPlate(GeoSurface):
+    """Generates and XY-plane oriented plate
+        
+        Specify the alignment of the plate with the provided position. The options are CORNER (default)
+        for the front-left node of the plate or CENTER for the center of the plate.
+
+        Args:
+            width (float): The x-size of the plate
+            depth (float): The y-size of the plate
+            position (tuple, optional): The position of the alignment node. Defaults to (0,0,0).
+            alignment (Alignment, optional): Which node to align to. Defaults to Alignment.CORNER.
+        """
     def __init__(self, 
                  width: float, 
                  depth: float, 
@@ -134,7 +159,19 @@ class XYPlate(GeoSurface):
 
 
 class Plate(GeoSurface):
-        
+    """A generalized 2D rectangular plate in XYZ-space.
+
+        The plate is specified by an origin (o) in meters coordinate plus two vectors (u,v) in meters
+        that span two of the sides such that all points of the plate are defined by:
+            p1 = o
+            p2 = o+u
+            p3 = o+v
+            p4 = o+u+v
+        Args:
+            origin (tuple[float, float, float]): The origin of the plate in meters
+            u (tuple[float, float, float]): The u-axis of the plate
+            v (tuple[float, float, float]): The v-axis of the plate
+        """
     def __init__(self,
                 origin: tuple[float, float, float],
                 u: tuple[float, float, float],
@@ -297,7 +334,6 @@ class CoaxCylinder(GeoVolume):
 
         xo, yo, zo = self.cs.in_global_cs(x.flatten(), y.flatten(), z.flatten())
         return xo, yo, zo
-        return super().boundary()
     
 class HalfSphere(GeoVolume):