emerge 0.6.5__tar.gz → 0.6.7__tar.gz

{emerge-0.6.5 → emerge-0.6.7}/.bumpversion.toml

@@ -1,5 +1,5 @@
 [tool.bumpversion]
-current_version = "0.6.5"
+current_version = "0.6.7"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]
 search = "{current_version}"

{emerge-0.6.5 → emerge-0.6.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emerge
-Version: 0.6.5
+Version: 0.6.7
 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.5 → emerge-0.6.7}/emerge/__init__.py

@@ -18,7 +18,7 @@ along with this program; if not, see
 """
 import os
 
-__version__ = "0.6.5"
+__version__ = "0.6.7"
 
 ############################################################
 #               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.5 → emerge-0.6.7}/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, expand_surface
 from .polybased import XYPolygon, GeoPrism, Disc, Curve
 from .step import STEPItems

{emerge-0.6.5 → emerge-0.6.7}/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
@@ -60,7 +60,7 @@ def add(main: T, tool: T,
         main._exists = False
     if remove_tool:
         tool._exists = False
-    return output # type: ignore
+    return output.set_material(main.material) # type: ignore
 
 def remove(main: T, tool: T, 
              remove_object: bool = True,
@@ -90,7 +90,7 @@ def remove(main: T, tool: T,
         main._exists = False
     if remove_tool:
         tool._exists = False
-    return output # type: ignore
+    return output.set_material(main.material) # type: ignore
 
 subtract = remove
 
@@ -122,7 +122,7 @@ def intersect(main: T, tool: T,
         main._exists = False
     if remove_tool:
         tool._exists = False
-    return output #type:ignore
+    return output.set_material(main.material) #type:ignore
 
 def embed(main: GeoVolume, other: GeoSurface) -> None:
     ''' Embeds a surface into a volume in the GMSH model.
@@ -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,66 @@ 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
+
+def expand_surface(surface: GeoSurface, distance: float) -> GeoSurface:
+    """EXPERIMENTAL: Expands an input surface. The surface must exist on a 2D plane.
+    
+    The output surface does not inherit material properties.
+    
+    If any problems occur, reach out through email.
+
+    Args:
+        surface (GeoSurface): The input surface to expand
+        distance (float): The exapansion distance
+
+    Returns:
+        GeoSurface: The output surface
+    """
+    surfs = [] 
+    for tag in surface.tags:
+        looptags, _ = gmsh.model.occ.get_curve_loops(tag)
+        new_curves = []
+        for looptag in looptags:
+            curve_tags = gmsh.model.occ.offset_curve(looptag, distance)
+            loop_tag = gmsh.model.occ.addCurveLoop([t for d,t in curve_tags])
+            new_curves.append(loop_tag)
+        surftag = gmsh.model.occ.addPlaneSurface(new_curves)
+        surfs.append(surftag)
+    surf = GeoSurface(surfs)
+    return surf

{emerge-0.6.5 → emerge-0.6.7}/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))
@@ -965,8 +963,18 @@ class PCB:
         Returns:
             float: the z-height
         """
+        if layer <= 0:
+            return self._zs[layer]
         return self._zs[layer-1]
     
+    @property
+    def top(self) -> float:
+        return self._zs[-1]
+    
+    @property
+    def bottom(self) -> float:
+        return self._zs[0]
+    
     def _get_z(self, element: RouteElement) -> float :
         """Return the z-height of a given Route Element
 
@@ -981,6 +989,31 @@ class PCB:
                 return path.z
         raise RouteException('Requesting z-height of route element that is not contained in a path.')
 
+    def add_vias(self, *coordinates: tuple[float, float], radius: float,
+                 z1: float | None = None,
+                 z2: float | None = None,
+                 segments: int = 6) -> None:
+        """Add a series of vias provided by a list of coordinates.
+        
+        Make sure to define the radius explicitly, otherwise the radius gets interpreted as a coordinate:
+        
+        >>> pcb.add_vias((x1,y1), (x1,y2), radius=1)
+
+        Args:
+            *coordinates (tuple(float, float)): A series of coordinates
+            radius (float): The radius
+            z1 (float | None, optional): The bottom z-coordinate. Defaults to None.
+            z2 (float | None, optional): The top z-coordinate. Defaults to None.
+            segments (int, optional): The number of segmets for the via. Defaults to 6.
+        """
+        if z1 is None:
+            z1 = self.z(0)
+        if z2 is None:
+            z2 = self.z(-1)
+        
+        for x,y in coordinates:
+            self.vias.append(Via(x,y,z1,z2,radius,segments))
+        
     def load(self, name: str) -> StripLine:
         """Acquire the x,y, coordinate associated with the label name.
         
@@ -1062,7 +1095,7 @@ class PCB:
             GeoSurface: _description_
         """
         if width is None or height is None or origin is None:
-            if self.width is None or self.length is None or self.origin:
+            if self.width is None or self.length is None or self.origin is None:
                 raise RouteException('Cannot define a plane with no possible definition of its size.')
             width = self.width
             height = self.length
@@ -1077,6 +1110,7 @@ class PCB:
 
         plane = Plate(origin, (width*self.unit, 0, 0), (0, height*self.unit, 0)) # type: ignore
         plane = change_coordinate_system(plane, self.cs) # type: ignore
+        plane.set_material(COPPER)
         return plane # type: ignore
     
     def generate_pcb(self, 
@@ -1123,7 +1157,7 @@ class PCB:
         """Generate the Air Block object
 
         This requires that the width, depth and origin are deterimed. This 
-        can either be done manually or via the .determine_boudns() method.
+        can either be done manually or via the .determine_bounds() method.
 
         Returns:
             GeoVolume: The PCB Block
@@ -1247,7 +1281,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 +1361,7 @@ class PCB:
         Returns:
             list[Polygon] | GeoSurface: The output stripline polygons possibly merged if merge = True.
         """
-        polys = []
+        polys: list[GeoSurface] = []
         allx = []
         ally = []
 
@@ -1353,19 +1393,19 @@ class PCB:
             poly = self._gen_poly(pcbpoly.xys, pcbpoly.z)
             poly.material = pcbpoly.material
             polys.append(poly)
+            xs, ys = zip(*pcbpoly.xys)
+            allx.extend(xs)
+            ally.extend(ys)
+            
 
         self.xs = allx
         self.ys = ally
 
         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)
+            
         return polys
                 
 ############################################################

{emerge-0.6.5 → emerge-0.6.7}/emerge/_emerge/geo/shapes.py

@@ -30,10 +30,20 @@ class Alignment(Enum):
     CENTER = 1
     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, 
@@ -91,10 +101,15 @@ class Box(GeoVolume):
         
         tags = list(reduce(lambda a,b: a+b, tagslist))
         return FaceSelection(tags)
-
+    
     
 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)):
@@ -108,7 +123,19 @@ class Sphere(GeoVolume):
         x,y,z = position
         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 +161,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],
@@ -172,27 +211,43 @@ class Plate(GeoSurface):
         tags: list[int] = [gmsh.model.occ.addPlaneSurface([tag_wire,]),]
         super().__init__(tags)
 
+
 class Cylinder(GeoVolume):
+    """Generates a Cylinder object in 3D space.
+        The cylinder will always be placed in the origin of the provided CoordinateSystem.
+        The bottom cylinder plane is always placed in the XY-plane. The length of the cylinder is
+        oriented along the Z-axis.
 
+        By default the cylinder uses the Open Cascade modeling for a cylinder. In this representation
+        the surface of the cylinder is approximated with a tolerance thay may be irregular.
+        As an alternative, the argument Nsections may be provided in which case the Cylinder is replaced
+        by an extrusion of a regular N-sided polygon.
+
+        Args:
+            radius (float): The radius of the Cylinder
+            height (float): The height of the Cylinder
+            cs (CoordinateSystem, optional): The coordinate system. Defaults to GCS.
+            Nsections (int, optional): The number of sections. Defaults to None.
+        """
     def __init__(self, 
                  radius: float,
                  height: float,
-                 cs: CoordinateSystem = None,
-                 Nsections: int = None):
+                 cs: CoordinateSystem = GCS,
+                 Nsections: int | None = None):
         """Generates a Cylinder object in 3D space.
-        The cyllinder will always be placed in the origin of the provided CoordinateSystem.
-        The bottom cyllinder plane is always placed in the XY-plane. The lenth of the cyllinder is
+        The cylinder will always be placed in the origin of the provided CoordinateSystem.
+        The bottom cylinder plane is always placed in the XY-plane. The length of the cylinder is
         oriented along the Z-axis.
 
-        By default the cyllinder uses the Open Cascade modeling for a cyllinder. In this representation
-        the surface of the cyllinder is approximated with a tolerance thay may be irregular.
+        By default the cylinder uses the Open Cascade modeling for a cylinder. In this representation
+        the surface of the cylinder is approximated with a tolerance thay may be irregular.
         As an alternative, the argument Nsections may be provided in which case the Cylinder is replaced
         by an extrusion of a regular N-sided polygon.
 
         Args:
             radius (float): The radius of the Cylinder
             height (float): The height of the Cylinder
-            cs (CoordinateSystem, optional): The coordinate system. Defaults to None.
+            cs (CoordinateSystem, optional): The coordinate system. Defaults to GCS.
             Nsections (int, optional): The number of sections. Defaults to None.
         """
         ax = cs.zax.np
@@ -233,33 +288,46 @@ class Cylinder(GeoVolume):
         xo, yo, zo = self.cs.in_global_cs(x.flatten(), y.flatten(), z.flatten())
         return xo, yo, zo
 
+
 class CoaxCylinder(GeoVolume):
-    """A coaxial cylinder with an inner and outer radius."""
-    
+    """Generates a Coaxial cylinder object in 3D space.
+        The coaxial cylinder will always be placed in the origin of the provided CoordinateSystem.
+        The bottom coax plane is always placed in the XY-plane. The lenth of the coax is
+        oriented along the Z-axis.
+
+        By default the coax uses the Open Cascade modeling for a cylinder. In this representation
+        the surface of the cylinder is approximated with a tolerance thay may be irregular.
+        As an alternative, the argument Nsections may be provided in which case the Cylinder is replaced
+        by an extrusion of a regular N-sided polygon.
+
+        Args:
+            radius (float): The radius of the Cylinder
+            height (float): The height of the Cylinder
+            cs (CoordinateSystem, optional): The coordinate system. Defaults to GCS.
+            Nsections (int, optional): The number of sections. Defaults to None.
+        """
     def __init__(self, 
                  rout: float,
                  rin: float,
                  height: float,
-                 cs: CoordinateSystem = None,
-                 Nsections: int = None):
-        """Generates a Coaxial cyllinder object in 3D space.
-        The coaxial cyllinder will always be placed in the origin of the provided CoordinateSystem.
+                 cs: CoordinateSystem = GCS,
+                 Nsections: int | None = None):
+        """Generates a Coaxial cylinder object in 3D space.
+        The coaxial cylinder will always be placed in the origin of the provided CoordinateSystem.
         The bottom coax plane is always placed in the XY-plane. The lenth of the coax is
         oriented along the Z-axis.
 
-        By default the coax uses the Open Cascade modeling for a cyllinder. In this representation
-        the surface of the cyllinder is approximated with a tolerance thay may be irregular.
+        By default the coax uses the Open Cascade modeling for a cylinder. In this representation
+        the surface of the cylinder is approximated with a tolerance thay may be irregular.
         As an alternative, the argument Nsections may be provided in which case the Cylinder is replaced
         by an extrusion of a regular N-sided polygon.
 
         Args:
             radius (float): The radius of the Cylinder
             height (float): The height of the Cylinder
-            cs (CoordinateSystem, optional): The coordinate system. Defaults to None.
+            cs (CoordinateSystem, optional): The coordinate system. Defaults to GCS.
             Nsections (int, optional): The number of sections. Defaults to None.
         """
-        if cs is None:
-            cs = GCS
         if rout <= rin:
             raise ValueError("Outer radius must be greater than inner radius.")
         
@@ -297,10 +365,9 @@ 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):
-
+    """A half sphere volume."""
     def __init__(self,
                  radius: float,
                  position: tuple = (0,0,0),
@@ -326,8 +393,6 @@ class HalfSphere(GeoVolume):
         self._add_face_pointer('back',np.array(position), np.array(direction))
         self._add_face_pointer('bottom',np.array(position), np.array(direction))
         self._add_face_pointer('face',np.array(position), np.array(direction))
-        
-
 
 
 class OldBox(GeoVolume):
@@ -353,8 +418,6 @@ class OldBox(GeoVolume):
             alignment (Alignment, optional): Which point of the box is placed at the position. 
                 Defaults to Alignment.CORNER.
         """
-        
-
         if alignment is Alignment.CORNER:
             position = (position[0]+width/2, position[1]+depth/2, position[2])
         elif alignment is Alignment.CENTER:
@@ -436,7 +499,6 @@ class OldBox(GeoVolume):
         self._add_face_pointer('right', pc + width/2*wax, wax)
         self._add_face_pointer('top', pc + height/2*hax, hax)
         self._add_face_pointer('bottom', pc - height/2*hax, -hax)
-        
     
     def outside(self, *exclude: Literal['bottom','top','right','left','front','back']) -> FaceSelection:
         """Select all outside faces except for the once specified by outside
@@ -449,8 +511,17 @@ class OldBox(GeoVolume):
         tags = list(reduce(lambda a,b: a+b, tagslist))
         return FaceSelection(tags)
 
+
 class Cone(GeoVolume):
-    
+    """Constructis a cone that starts at position p0 and is aimed in the given direction.
+        r1 is the start radius and r2 the end radius. The magnitude of direction determines its length.
+
+        Args:
+            p0 (tuple[float, float, float]): _description_
+            direction (tuple[float, float, float]): _description_
+            r1 (float): _description_
+            r2 (float): _description_
+        """
     def __init__(self, p0: tuple[float, float, float],
                  direction: tuple[float, float, float],
                  r1: float,