emerge 1.0.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

emerge/_emerge/geo/pcb_tools/dxf.py

@@ -0,0 +1,360 @@
+
+import re
+from typing import Any
+from ..pcb import PCB, RouteException
+from ...material import Material, PEC
+from ...cs import GCS, CoordinateSystem
+from loguru import logger
+from math import hypot
+
+try: 
+    import ezdxf
+    from ezdxf.recover import readfile as recover_readfile
+    from ezdxf.path import make_path, from_hatch
+except ImportError as e:
+    logger.error('Cannot find the required ezdxf library. Install using: pip install ezdxf')
+    raise e
+
+INSUNITS_TO_NAME = {
+    0: "unitless",
+    1: "inch",
+    2: "foot",
+    3: "mile",
+    4: "millimeter",
+    5: "centimeter",
+    6: "meter",
+    7: "kilometer",
+    8: "microinch",
+    9: "mil",          # thousandth of an inch
+    10: "yard",
+    11: "angstrom",
+    12: "nanometer",
+    13: "micrometer",
+    14: "decimeter",
+    15: "decameter",
+    16: "hectometer",
+    17: "gigameter",
+    18: "astronomical unit",
+    19: "light year",
+    20: "parsec",
+}
+
+# scale factor: drawing units -> millimeters
+INSUNITS_TO_MM = {
+    0: 1.0,           # unitless; treat as mm by convention
+    1: 25.4,
+    2: 304.8,
+    3: 1609344.0,
+    4: 1.0,
+    5: 10.0,
+    6: 1000.0,
+    7: 1_000_000.0,
+    8: 25.4e-6,
+    9: 0.0254,
+    10: 914.4,
+    11: 1e-7,
+    12: 1e-6,
+    13: 1e-3,
+    14: 100.0,
+    15: 10_000.0,
+    16: 100_000.0,
+    17: 1e12,
+    18: 1.495978707e14,     # AU in mm
+    19: 9.460730472e18,     # ly in mm
+    20: 3.085677581e19,     # pc in mm
+}
+
+def cluster_values(values, tol):
+    """Return [(center, count), ...] clustering sorted values by tolerance."""
+    if not values:
+        return []
+    values = sorted(values)
+    clusters = [[values[0]]]
+    for v in values[1:]:
+        if abs(v - clusters[-1][-1]) <= tol:
+            clusters[-1].append(v)
+        else:
+            clusters.append([v])
+    out = []
+    for c in clusters:
+        out.append((sum(c)/len(c), len(c)))
+    return out
+
+STACKUP_TOKENS = [
+    r"fr-?4", r"rogers ?\d+", r"core", r"prepreg", r"dielectric",
+    r"cu(?:\W|$)|copper", r"\b1\.?6\s*mm\b", r"\b0\.?8\s*mm\b",
+    r"\b[12]\s*oz\b", r"\b35\s*µ?m\b", r"\b70\s*µ?m\b",
+    r"stack[- ]?up", r"layer\s*\d+", r"pcb", r"thickness",
+]
+
+def inspect_pcb_from_dxf(
+    filename: str,
+    flatten_tol: float = 0.25,    # curve flattening tolerance (drawing units)
+    z_tol: float | None = None,   # cluster tolerance for Z (drawing units); default auto
+    layer_filter: str | None = None,
+):
+    """
+    Returns a dict with:
+      {
+        'units': {'code': int, 'name': str, 'to_mm': float},
+        'z_levels': [{'z': float, 'count': int}],           # in drawing units
+        'thickness_units': 'same as units',
+        'thickness': float,                                  # in drawing units
+        'thickness_mm': float,                               # convenience
+        'notes': {'materials': [...], 'raw_text_hits': [...]}
+      }
+    """
+    doc, auditor = recover_readfile(filename)
+    msp = doc.modelspace()
+
+    # Units
+    code = int(doc.header.get("$INSUNITS", 0))
+    unit_name = INSUNITS_TO_NAME.get(code, f"unknown({code})")
+    to_mm = INSUNITS_TO_MM.get(code, 1.0)
+
+    # Gather geometry Zs (WCS), also consider entity.dxf.elevation as fallback
+    z_values = []
+
+    def on_layer(e) -> bool:
+        return layer_filter is None or e.dxf.layer == layer_filter
+
+    for e in msp:
+        if not on_layer(e):
+            continue
+        dxtype = e.dxftype()
+        paths = []
+        try:
+            if dxtype in ("HATCH", "MPOLYGON"):
+                paths = list(from_hatch(e))
+            else:
+                paths = [make_path(e)]
+        except TypeError:
+            # skip unsupported entity types
+            pass
+        except Exception:
+            pass
+
+        for p in paths:
+            subs = p.sub_paths() if getattr(p, "has_sub_paths", False) and p.has_sub_paths else [p]
+            for sp in subs:
+                try:
+                    verts = list(sp.flattening(distance=flatten_tol))
+                except Exception:
+                    continue
+                for v in verts:
+                    # v may be Vec2 or Vec3; handle both
+                    z = getattr(v, "z", None)
+                    if z is None:
+                        # fallback to entity elevation if available
+                        z = float(getattr(e.dxf, "elevation", 0.0))
+                    z_values.append(float(z))
+
+        # Entities with explicit THICKNESS (rare but possible)
+        thick = getattr(e.dxf, "thickness", None)
+        if thick not in (None, 0):
+            # If an entity is extruded, its "top" would be at elevation+thickness along normal.
+            # We can't reliably map OCS normal here; just record the magnitude as a hint.
+            pass
+
+    # Cluster Zs
+    auto_tol = (1e-6 if to_mm >= 1.0 else 1e-6 / to_mm)  # ~1 nm in mm space → tiny in most units
+    ztol = z_tol if z_tol is not None else auto_tol
+    z_clusters = cluster_values(z_values, tol=ztol)
+    z_levels = [{"z": z, "count": n} for z, n in z_clusters]
+
+    # Thickness from geometry (only meaningful if multiple distinct Zs)
+    if z_values:
+        zmin, zmax = min(z_values), max(z_values)
+        thickness = zmax - zmin
+    else:
+        zmin = zmax = thickness = 0.0
+
+    # Parse material/thickness hints from TEXT/MTEXT
+    material_hits = set()
+    raw_text_hits = []
+    token_re = re.compile("|".join(STACKUP_TOKENS), re.IGNORECASE)
+
+    for e in msp.query("TEXT MTEXT"):
+        try:
+            text = e.dxf.text if e.dxftype() == "TEXT" else e.text
+        except Exception:
+            continue
+        if not text:
+            continue
+        if token_re.search(text):
+            raw_text_hits.append(text.strip())
+            # simple keyword extraction
+            for kw in ["FR4", "Rogers", "core", "prepreg", "copper", "stackup", "thickness", "oz", "µm", "um", "mm"]:
+                if re.search(kw, text, re.IGNORECASE):
+                    material_hits.add(kw.upper())
+
+    return {
+        "units": {"code": code, "name": unit_name, "to_mm": to_mm},
+        "z_levels": z_levels,
+        "thickness_units": unit_name,
+        "thickness": thickness,
+        "thickness_mm": thickness * to_mm,
+        "notes": {
+            "materials": sorted(material_hits),
+            "raw_text_hits": raw_text_hits[:50],  # cap to keep output sane
+            "comment": (
+                "Single Z level detected; geometry alone cannot determine PCB thickness."
+                if len(z_levels) <= 1 else
+                "Thickness estimated from min/max Z across all geometry."
+            )
+        },
+    }
+
+def path_items_with_semantics(e, p, distance=0.25):
+    """Yield dicts describing each sub-path with geometry + semantics we can infer."""
+    subs = p.sub_paths() if getattr(p, "has_sub_paths", False) and p.has_sub_paths else [p]
+    for sp in subs:
+        verts = list(sp.flattening(distance=distance))
+        if len(verts) < 2:
+            continue
+
+        # geometry in XY (keep Z if you like)
+        pts = [(v.x, v.y) for v in verts]
+        is_closed = pts[0] == pts[-1]
+
+        item = {
+            "layer": e.dxf.layer,
+            "entity": e.dxftype(),
+            "handle": e.dxf.handle,
+            "is_closed": is_closed,
+            "points": pts if is_closed else None,       # polygon ring for closed shapes
+            "start": None,
+            "end": None,
+            "length": None,                             # centerline length for open paths
+            "width": None,                              # LWPOLYLINE width if available
+        }
+
+        if not is_closed:
+            item["start"] = pts[0]
+            item["end"]   = pts[-1]
+            # polyline centerline length
+            item["length"] = sum(
+                hypot(x2 - x1, y2 - y1) for (x1, y1), (x2, y2) in zip(pts, pts[1:])
+            )
+
+        # Preserve potential trace width info from LWPOLYLINE
+        if e.dxftype() == "LWPOLYLINE":
+            cw = getattr(e.dxf, "const_width", None)
+            if cw not in (None, 0):
+                item["width"] = float(cw)
+            else:
+                # per-vertex widths (rare but possible)
+                try:
+                    item["widths"] = [(v[0], v[1]) for v in zip(e.get_start_widths(), e.get_end_widths())]
+                except Exception:
+                    pass
+
+        yield item
+        
+def extract_polygons_with_meta(
+    filename: str,
+    layer: str | None = None,
+    distance: float = 0.25,
+    skip_open: bool = True,
+) -> dict[str, Any]:
+    """
+    Returns a list of dicts:
+      {
+        'ring': [(x, y), ...],         # closed ring
+        'layer': 'LayerName',
+        'z': 12.34,                    # representative height (median Z of ring)
+        'entity': 'LWPOLYLINE' | ...,
+        'handle': 'ABCD'
+      }
+    """
+    doc, auditor = recover_readfile(filename)
+    msp = doc.modelspace()
+
+    def on_layer(e) -> bool:
+        return layer is None or e.dxf.layer == layer
+
+    items = []
+
+    for e in msp:
+        if not on_layer(e):
+            continue
+
+        dxtype = e.dxftype()
+        paths = []
+        try:
+            if dxtype in ("HATCH", "MPOLYGON"):
+                paths = list(from_hatch(e))
+            else:
+                paths = [make_path(e)]
+        except TypeError:
+            continue
+        except Exception:
+            continue
+
+        for p in paths:
+            subs = p.sub_paths() if p.has_sub_paths else [p]
+            for sp in subs:
+                
+                verts = list(sp.flattening(distance=distance))  # Vec3 in WCS
+                if len(verts) < 2:
+                    continue
+
+                # ensure not closed
+                if (verts[0].x, verts[0].y) == (verts[-1].x, verts[-1].y):
+                    verts = verts[:-1]
+
+                # ring in XY (your original target), but also compute a Z for reference
+                ring_xy = [(v.x, v.y) for v in verts]
+                zs = sorted(v.z for v in verts)
+                z = zs[len(zs)//2] if zs else float(getattr(e.dxf, "elevation", 0.0))  # median Z
+
+                items.append({
+                    "ring": ring_xy,
+                    "layer": e.dxf.layer,
+                    "z": float(z),
+                    "entity": dxtype,
+                    "handle": e.dxf.handle,
+                })
+
+    return items
+
+
+def import_dxf(filename: str, 
+               material: Material, 
+               thickness: float | None = None,
+               unit: float | None = None,
+               cs: CoordinateSystem | None = GCS,
+               trace_material: Material = PEC) -> PCB:
+    polies = extract_polygons_with_meta(filename)
+    prop = inspect_pcb_from_dxf('LP5G_Chb3.dxf')
+    
+    if prop['units']['name'] == 'unitless':
+        if unit is None:
+            raise RouteException(f'Cannot generate PCB because the unit is not found in the DXF file or provided in the import_dxf function.')
+        pcb_unit = unit
+    else:
+        pcb_unit = 0.001 * prop['units']['to_mm']
+    
+    if prop['thickness']==0.0:
+        if thickness is None:
+            raise RouteException(f'Cannot generate PCB because no thickness is found int he DXF file and none is provided in the import_dxf function.')
+        pcb_thickness = thickness
+    else:
+        pcb_thickness = 0.001 * prop['thickness_mm'] / pcb_unit
+    
+    if cs is None:
+        cs = GCS
+    
+    zs = sorted(list(set([pol['z'] for pol in polies])))
+    pcb = PCB(pcb_thickness, pcb_unit, cs, material=material, trace_material=trace_material, _zs=zs)
+    
+    for poly in polies:
+        xs, ys = zip(*poly['ring'])
+        z = poly['z']
+        zs.append(z)
+        xs = [x for x in xs]
+        ys = [y for y in ys]
+        
+        pcb.add_poly(xs, ys, z=z, name=poly['handle'])
+    return pcb
+    

emerge/_emerge/geo/polybased.py

@@ -219,8 +219,9 @@ class GeoPrism(GeoVolume):
                  volume_tag: int,
                  front_tag: int | None = None,
                  side_tags: list[int] | None = None,
-                 _axis: Axis | None = None):
-        super().__init__(volume_tag)
+                 _axis: Axis | None = None,
+                 name: str | None = None):
+        super().__init__(volume_tag, name=name)
         
         
         
@@ -420,7 +421,7 @@ class XYPolygon:
         wiretag = gmsh.model.occ.add_wire(lines)
         return ptags, lines, wiretag
         
-    def _finalize(self, cs: CoordinateSystem) -> GeoPolygon:
+    def _finalize(self, cs: CoordinateSystem, name: str | None = 'GeoPolygon') -> 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.
@@ -433,12 +434,12 @@ class XYPolygon:
         """
         ptags, lines, wiretag = self._make_wire(cs)
         surftag = gmsh.model.occ.add_plane_surface([wiretag,])
-        poly = GeoPolygon([surftag,])
+        poly = GeoPolygon([surftag,], name=name)
         poly.points = ptags
         poly.lines = lines
         return poly
     
-    def extrude(self, length: float, cs: CoordinateSystem | None = None) -> GeoPrism:
+    def extrude(self, length: float, cs: CoordinateSystem | None = None, name: str = 'Extrusion') -> GeoPrism:
         """Extrues the polygon along the Z-axis.
         The z-coordinates go from z1 to z2 (in meters). Then the extrusion
         is either provided by a maximum dz distance (in meters) or a number
@@ -458,9 +459,9 @@ class XYPolygon:
         volume = gmsh.model.occ.extrude(poly_fin.dimtags, zax[0], zax[1], zax[2])
         tags = [t for d,t in volume if d==3]
         surftags = [t for d,t in volume if d==2]
-        return GeoPrism(tags, surftags[0], surftags)
+        return GeoPrism(tags, surftags[0], surftags, name=name)
     
-    def geo(self, cs: CoordinateSystem | None = None) -> GeoPolygon:
+    def geo(self, cs: CoordinateSystem | None = None, name: str = 'GeoPolygon') -> GeoPolygon:
         """Returns a GeoPolygon object for the current polygon.
 
         Args:
@@ -475,7 +476,7 @@ class XYPolygon:
             cs = GCS
         return self._finalize(cs) 
     
-    def revolve(self, cs: CoordinateSystem, origin: tuple[float, float, float], axis: tuple[float, float,float], angle: float = 360.0) -> GeoPrism:
+    def revolve(self, cs: CoordinateSystem, origin: tuple[float, float, float], axis: tuple[float, float,float], angle: float = 360.0, name: str = 'Revolution') -> GeoPrism:
         """Applies a revolution to the XYPolygon along the provided rotation ais
 
         Args:
@@ -496,7 +497,7 @@ class XYPolygon:
         
         tags = [t for d,t in volume if d==3]
         poly_fin.remove()
-        return GeoPrism(tags, _axis=axis)
+        return GeoPrism(tags, _axis=axis, name=name)
 
     @staticmethod
     def circle(radius: float, 
@@ -588,7 +589,7 @@ class XYPolygon:
         self.extend(xs, ys)
         return self
     
-    def connect(self, other: XYPolygon) -> GeoVolume:
+    def connect(self, other: XYPolygon, name: str = 'Connection') -> 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
@@ -610,17 +611,19 @@ class XYPolygon:
         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 = GeoVolume([t for d,t in dts if d==3], name=name)
         
         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):
+    _default_name: str = 'Disc'
     
     def __init__(self, origin: tuple[float, float, float],
                  radius: float,
-                 axis: tuple[float, float, float] = (0,0,1.0)):
+                 axis: tuple[float, float, float] = (0,0,1.0),
+                 name: str | None = None):
         """Creates a circular Disc surface.
 
         Args:
@@ -629,10 +632,12 @@ class Disc(GeoSurface):
             axis (tuple[float, float, float], optional): The disc normal axis. Defaults to (0,0,1.0).
         """
         disc = gmsh.model.occ.addDisk(*origin, radius, radius, zAxis=axis)
-        super().__init__(disc)
+        super().__init__(disc, name=name)
     
     
 class Curve(GeoEdge):
+    _default_name: str = 'Curve'
+    
     def __init__(self, 
                  xpts: np.ndarray, 
                  ypts: np.ndarray, 
@@ -640,7 +645,8 @@ class Curve(GeoEdge):
                  degree: int = 3,
                  weights: list[float] | None = None,
                  knots: list[float] | None = None,
-                 ctype: Literal['Spline','BSpline','Bezier'] = 'Spline'):
+                 ctype: Literal['Spline','BSpline','Bezier'] = 'Spline',
+                 name: str | None = None):
         """Generate a Spline/Bspline or Bezier curve based on a series of points
 
         This calls the different curve features in OpenCASCADE.
@@ -678,7 +684,7 @@ class Curve(GeoEdge):
         
         tags = gmsh.model.occ.addWire([tags,])
         gmsh.model.occ.remove([(0,tag) for tag in points])
-        super().__init__(tags)
+        super().__init__(tags, name=name)
     
         gmsh.model.occ.synchronize()
         p1 = gmsh.model.getValue(self.dim, self.tags[0], [0,])

emerge/_emerge/geo/shapes.py

@@ -50,14 +50,15 @@ class Box(GeoVolume):
             alignment (Alignment, optional): Which point of the box is placed at the position. 
                 Defaults to Alignment.CORNER.
         """
-
+    _default_name: str = 'Box'
     def __init__(self, 
                  width: float, 
                  depth: float, 
                  height: float, 
                  position: tuple = (0,0,0),
                  alignment: Alignment = Alignment.CORNER,
-                 cs: CoordinateSystem = GCS):
+                 cs: CoordinateSystem = GCS,
+                 name: str | None = None):
         """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.
@@ -76,7 +77,7 @@ class Box(GeoVolume):
         x,y,z = position
 
         tag = gmsh.model.occ.addBox(x,y,z,width,depth,height)
-        super().__init__(tag)
+        super().__init__(tag, name=name)
 
         self.center = (x+width/2, y+depth/2, z+height/2)
         self.width = width
@@ -116,6 +117,7 @@ class Sphere(GeoVolume):
         radius (float): The sphere radius
         position (tuple, optional): The center position. Defaults to (0,0,0).
     """
+    _default_name: str = 'Sphere'
     def __init__(self, 
                  radius: float,
                  position: tuple = (0,0,0)):
@@ -142,11 +144,13 @@ class XYPlate(GeoSurface):
             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.
         """
+    _default_name: str = 'XYPlate'
     def __init__(self, 
                  width: float, 
                  depth: float, 
                  position: tuple = (0,0,0),
-                 alignment: Alignment = Alignment.CORNER):
+                 alignment: Alignment = Alignment.CORNER,
+                 name: str | None = None):
         """Generates and XY-plane oriented plate
         
         Specify the alignment of the plate with the provided position. The options are CORNER (default)
@@ -158,7 +162,7 @@ class XYPlate(GeoSurface):
             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.
         """
-        super().__init__([])
+        super().__init__([], name=name)
         if alignment is Alignment.CENTER:
             position = (position[0]-width/2, position[1]-depth/2, position[2])
         
@@ -180,10 +184,12 @@ class Plate(GeoSurface):
             u (tuple[float, float, float]): The u-axis of the plate
             v (tuple[float, float, float]): The v-axis of the plate
         """
+    _default_name: str = 'Plate'
     def __init__(self,
                 origin: tuple[float, float, float],
                 u: tuple[float, float, float],
-                v: tuple[float, float, float]):
+                v: tuple[float, float, float],
+                name: str | None = None):
         """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
@@ -215,7 +221,7 @@ class Plate(GeoSurface):
         tag_wire = gmsh.model.occ.addWire([tagl1,tagl2, tagl3, tagl4])
 
         tags: list[int] = [gmsh.model.occ.addPlaneSurface([tag_wire,]),]
-        super().__init__(tags)
+        super().__init__(tags, name=name)
 
 
 class Cylinder(GeoVolume):
@@ -235,11 +241,13 @@ class Cylinder(GeoVolume):
             cs (CoordinateSystem, optional): The coordinate system. Defaults to GCS.
             Nsections (int, optional): The number of sections. Defaults to None.
         """
+    _default_name: str = 'Cylinder'
     def __init__(self, 
                  radius: float,
                  height: float,
                  cs: CoordinateSystem = GCS,
-                 Nsections: int | None = None):
+                 Nsections: int | None = None,
+                 name: str | None = None):
         """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
@@ -263,12 +271,12 @@ class Cylinder(GeoVolume):
             cyl = XYPolygon.circle(radius, Nsections=Nsections).extrude(height, cs)
             cyl._exists = False
             self._face_pointers = cyl._face_pointers
-            super().__init__(cyl.tags)
+            super().__init__(cyl.tags, name=name)
         else:
             cyl = gmsh.model.occ.addCylinder(cs.origin[0], cs.origin[1], cs.origin[2],
                                          height*ax[0], height*ax[1], height*ax[2],
                                          radius)
-            super().__init__(cyl)
+            super().__init__(cyl, name=name)
         self._add_face_pointer('front', cs.origin, -cs.zax.np)
         self._add_face_pointer('back', cs.origin+height*cs.zax.np, cs.zax.np)
         self._add_face_pointer('bottom', cs.origin, -cs.zax.np)
@@ -312,12 +320,14 @@ class CoaxCylinder(GeoVolume):
             cs (CoordinateSystem, optional): The coordinate system. Defaults to GCS.
             Nsections (int, optional): The number of sections. Defaults to None.
         """
+    _default_name: str = 'CoaxCylinder'
     def __init__(self, 
                  rout: float,
                  rin: float,
                  height: float,
                  cs: CoordinateSystem = GCS,
-                 Nsections: int | None = None):
+                 Nsections: int | None = None,
+                 name: str | 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
@@ -347,7 +357,7 @@ class CoaxCylinder(GeoVolume):
         self.cyl_out._exists = False
         cyltags, _ = gmsh.model.occ.cut(self.cyl_out.dimtags, self.cyl_in.dimtags)
         
-        super().__init__([dt[1] for dt in cyltags])
+        super().__init__([dt[1] for dt in cyltags], name=name)
 
         self._add_face_pointer('front', cs.origin, -cs.zax.np)
         self._add_face_pointer('back', cs.origin+height*cs.zax.np, cs.zax.np)
@@ -374,10 +384,12 @@ class CoaxCylinder(GeoVolume):
     
 class HalfSphere(GeoVolume):
     """A half sphere volume."""
+    _default_name: str = 'HalfSphere'
     def __init__(self,
                  radius: float,
                  position: tuple = (0,0,0),
-                 direction: tuple = (1,0,0)):
+                 direction: tuple = (1,0,0),
+                 name: str | None = None):
         
         sphere = Sphere(radius, position=position)
         cx, cy, cz = position
@@ -393,7 +405,7 @@ class HalfSphere(GeoVolume):
         sphere._exists = False
         box._exists = False
 
-        super().__init__([dt[1] for dt in dimtags])
+        super().__init__([dt[1] for dt in dimtags], name=name)
         
         self._add_face_pointer('front',np.array(position), np.array(direction))
         self._add_face_pointer('back',np.array(position), np.array(direction))
@@ -528,10 +540,13 @@ class Cone(GeoVolume):
             r1 (float): _description_
             r2 (float): _description_
         """
+    _default_name: str = 'Cone'
+    
     def __init__(self, p0: tuple[float, float, float],
                  direction: tuple[float, float, float],
                  r1: float,
-                 r2: float):
+                 r2: float,
+                 name: str | None = None):
         """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.
 
@@ -542,7 +557,7 @@ class Cone(GeoVolume):
             r2 (float): _description_
         """
         tag = gmsh.model.occ.add_cone(*p0, *direction, r1, r2)
-        super().__init__(tag)
+        super().__init__(tag, name=name)
         
         p0 = np.array(p0)
         ds = np.array(direction)