emerge 1.0.7__py3-none-any.whl → 1.1.1__py3-none-any.whl

emerge/_emerge/geo/step.py

@@ -1,11 +1,70 @@
 import gmsh
 from ..geometry import GeoPoint, GeoEdge, GeoVolume, GeoSurface, GeoObject
+from ..selection import FaceSelection
+from .shapes import Box
+from .operations import unite
+
 from pathlib import Path
 import numpy as np
+from typing import Callable
 
-class STEPItems:
+def _select_num(num1: float | None, num2: float | None) -> float:
+    if num1 is None and num2 is None:
+        return 0.0
+    if isinstance(num1, float) and num2 is None:
+        return num1
+    if num1 is None and isinstance(num2, float):
+        return num2
+    return max(num1, num2)
+
+class _FaceSliceSelector:
+    
+    def __init__(self, face_numbers: list[int], selector: Callable):
+        self.numbers: list[str] = face_numbers
+        self.selector: Callable = selector
+        
+    def __getitem__(self, slice) -> FaceSelection:
+        nums = self.numbers.__getitem__(slice)
+        if isinstance(nums, int):
+            nums = [nums,]
+        return self.selector(*nums)
+    
+class StepVolume(GeoVolume):
+    """The StepVoume class extens the EMerge GeoVolume class to add easier
+    face selection functionalities based on numbers as face names are not 
+    imported currently
+
+    Args:
+        GeoVolume (_type_): _description_
+
+    Returns:
+        _type_: _description_
+    """
+    
+        
+    @property
+    def _face_numbers(self) -> list[int]:
+        return sorted([int(name[4:]) for name in self._face_pointers.keys()])
+    
+    @property
+    def face_slice(self) -> _FaceSliceSelector:
+        return _FaceSliceSelector(self._face_numbers, self.faces)
+    
+    def faces(self, *numbers: int) -> FaceSelection:
+        """Select a set of faces by number
+
+        Returns:
+            FaceSelection: _description_
+        """
+        names = [f'Face{num}' for num in numbers]
+        return super().faces(*names)
+        
 
-    def __init__(self, filename: str, unit: float = 1.0):
+class STEPItems:
+    """STEPItems imports geometries form a STEP file and exposes them to the user.
+    
+    """
+    def __init__(self, name: str, filename: str, unit: float = 1.0):
         """Imports the provided STEP file.
         Specify the unit in case of scaling issues where mm units are not taken into consideration.
 
@@ -16,62 +75,139 @@ class STEPItems:
         Raises:
             FileNotFoundError: If a file does not exist
         """
+        self.name: str = name
+
         stl_path = Path(filename)
-        gmsh.option.setNumber("Geometry.OCCScaling", 1)
-        gmsh.option.setNumber("Geometry.OCCImportLabels", 2) 
+        gmsh.option.setNumber("Geometry.OCCScaling", unit)
+        gmsh.option.setNumber("Geometry.OCCImportLabels", 1) 
 
         if not stl_path.exists:
             raise FileNotFoundError(f'File with name {stl_path} does not exist.')
         
         dimtags = gmsh.model.occ.import_shapes(filename, format='step')
-
-        gmsh.model.occ.affine_transform(dimtags, np.array([unit, 0, 0, 0,
-                                                           0, unit, 0, 0,
-                                                           0, 0, unit, 0,
-                                                           0, 0, 0, 1]))
-        #dimtags = gmsh.model.occ.heal_shapes(dimtags, tolerance=1e-6)
         
-        self.points: dict[str, GeoPoint] = dict()
-        self.edges: dict[str, GeoEdge] = dict()
-        self.surfaces: dict[str, GeoSurface] = dict()
-        self.volumes: dict[str, GeoVolume] = dict()
-
+        self.points: list[GeoPoint] = []
+        self.edges: list[GeoEdge] = []
+        self.surfaces: list[GeoSurface] = []
+        self.volumes: list[GeoVolume] = []
+        
         i = 0
         for dim, tag in dimtags:
-            name = gmsh.model.getPhysicalName(dim, tag)
+            name = gmsh.model.getPhysicalName(dim, tag) #for now, this doesn't actually ever work.
             if name == '':
                 name = f'Obj{i}'
                 i+=1
             if dim == 0:
-                self.points[name] = GeoPoint(tag)
+                self.points.append(GeoPoint(tag, name=f'{self.name}_{name}'))
             elif dim == 1:
-                self.edges[name] = GeoEdge(tag)
+                self.edges.append(GeoEdge(tag, name=f'{self.name}_{name}'))
             elif dim == 2:
-                self.surfaces[name] = GeoSurface(tag)
+                self.surfaces.append(GeoSurface(tag, name=f'{self.name}_{name}'))
             elif dim == 3:
-                self.volumes[name] = GeoVolume(tag)
-    
+                self.volumes.append(StepVolume(tag, name=f'{self.name}_{name}'))
+        
+        gmsh.model.occ.synchronize()
+        
     @property
-    def _dicts(self):
-        yield self.points
-        yield self.edges
-        yield self.surfaces
-        yield self.volumes
-
+    def dictionary(self) -> dict[str, GeoObject]:
+        return {obj.name: obj for obj in self.objects}
+    
     @property
     def objects(self) -> tuple[GeoObject,...]:
-        objects = tuple()
-        for dct in self._dicts:
-            objects = objects + tuple(dct.values())
-        return objects
+        """Returns a list of all objects in the STEP file
+
+        Returns:
+            tuple[GeoObject,...]: _description_
+        """
+        return tuple(self.points+self.edges+self.surfaces+self.volumes)
+    
+    def __getitem__(self, name: str) -> GeoObject | None:
+        return self.dictionary.get(name, None)
+    
+    def as_volume(self) -> StepVolume:
+        """Returns the 3D volumetric part of the STEP file as a single geometry
+
+        Returns:
+            StepVolume: The resultant StepVolume(GeoVolume) object.
+        """
+        if len(self.volumes)==1:
+            return self.volumes[0]
+        return unite(*self.volumes)._auto_face_tag()
+    
+    def as_surface(self) -> GeoSurface:
+        """Returns the 2D surface part of the STEP file as a single geometry
+
+
+        Returns:
+            GeoSurface: The resultant GeoSurface object
+        """
+        if len(self.surfaces)==1:
+            return self.surfaces[0]
+        return unite(*self.surfaces)
+    
+    def as_edge(self) -> GeoEdge:
+        """Returns the 1D Edge part of the STEP file as a single geometry
+
+        Returns:
+            GeoEdge: The resultant GeoEdge object
+        """
+        if len(self.edges)==1:
+            return self.edges[1]
+        return unite(*self.edges)
     
-    def __getitem__(self, name: str) -> GeoObject:
-        if name in self.points:
-            return self.points[name]
-        elif name in self.edges:
-            return self.edges[name]
-        elif name in self.surfaces:
-            return self.surfaces[name]
-        elif name in self.volumes:
-            return self.volumes[name]
-            
+    def as_point(self) -> GeoPoint:
+        """Returns the 0D Point part of the STEP file as a single geometry
+
+        Returns:
+            GeoPoint: The resultant GeoPoint object.
+        """
+        if len(self.points)==1:
+            return self.points[0]
+        return unite(*self.points)
+    
+    def enclose(self, 
+                margin: float = None,
+                x_margins: tuple[float, float] = (None, None),
+                y_margins: tuple[float, float] = (None, None),
+                z_margins: tuple[float, float] = (None, None)) -> Box:
+        """Create an enclosing bounding box for the step model.
+
+        Args:
+            margin (float, optional): _description_. Defaults to 0.
+            x_margins (tuple[float, float], optional): _description_. Defaults to (0., 0.).
+            y_margins (tuple[float, float], optional): _description_. Defaults to (0., 0.).
+            z_margins (tuple[float, float], optional): _description_. Defaults to (0., 0.).
+
+        Returns:
+            Box: _description_
+        """
+        xminm = _select_num(margin, x_margins[0])
+        xmaxm = _select_num(margin, x_margins[1])
+        yminm = _select_num(margin, y_margins[0])
+        ymaxm = _select_num(margin, y_margins[1])
+        zminm = _select_num(margin, z_margins[0])
+        zmaxm = _select_num(margin, z_margins[1])
+        
+        xmin = 1000000
+        xmax = -1000000
+        ymin = 1000000
+        ymax = -1000000
+        zmin = 1000000
+        zmax = -1000000
+        
+        for obj in self.objects:
+            for dim, tag in obj.dimtags:
+                x1, y1, z1, x2, y2, z2 = gmsh.model.occ.getBoundingBox(dim, tag)
+                xmin = min(xmin, x1)
+                xmax = max(xmax, x2)
+                ymin = min(ymin, y1)
+                ymax = max(ymax, y2)
+                zmin = min(zmin, z1)
+                zmax = max(zmax, z2)
+        
+        width = xmax-xmin + xminm + xmaxm
+        depth = ymax-ymin + yminm + ymaxm
+        height = zmax -zmin + zminm + zmaxm
+
+        return Box(width, depth, height, (xmin-xminm, ymin-yminm, zmin-zminm)).background()
+    

emerge/_emerge/geometry.py

@@ -18,13 +18,12 @@
 from __future__ import annotations
 import gmsh # type: ignore
 from .material import Material, AIR
-from .selection import FaceSelection, DomainSelection, EdgeSelection, PointSelection, Selection
+from .selection import FaceSelection, DomainSelection, EdgeSelection, PointSelection, Selection, SelectionError
 from loguru import logger
-from typing import Literal, Any, Iterable, TypeVar
+from typing import Literal, Any, Iterable, Callable
 import numpy as np
 
 
-
 def _map_tags(tags: list[int], mapping: dict[int, list[int]]):
     new_tags = []
     for tag in tags:
@@ -34,6 +33,7 @@ def _map_tags(tags: list[int], mapping: dict[int, list[int]]):
 def _bbcenter(x1, y1, z1, x2, y2, z2):
     return np.array([(x1+x2)/2, (y1+y2)/2, (z1+z2)/2])
 
+
 FaceNames = Literal['back','front','left','right','top','bottom']
 
 class _KEY_GENERATOR:
@@ -88,15 +88,12 @@ class _GeometryManager:
     def sign_in(self, modelname: str) -> None:
         # if modelname not in self.geometry_list:
         #     self.geometry_list[modelname] = []
-        if modelname is self.geometry_list:
-            logger.warning(f'{modelname} already exist, Geometries will be reset.')
         self.geometry_list[modelname] = dict()
         self.geometry_names[modelname] = set()
         self.active = modelname
 
     def reset(self, modelname: str) -> None:
-        self.geometry_list[modelname] = dict()
-        self.geometry_names[modelname] = set()
+        self.sign_in(modelname)
     
     def lowest_priority(self) -> int:
         return min([geo._priority for geo in self.all_geometries()])
@@ -123,9 +120,9 @@ class _FacePointer:
              normals: list[np.ndarray]) -> list[int]:
         tags = []
         for (d,t), o, n in zip(dimtags, origins, normals):
-            normdist = np.abs((o-self.o)@self.n)
+            normdist = np.abs((o-self.o) @ self.n)
             dotnorm = np.abs(n@self.n)
-            if normdist < 1e-3 and dotnorm > 0.99:
+            if normdist < 1e-5 and dotnorm > 0.999:
                 tags.append(t)
         return tags
     
@@ -235,6 +232,8 @@ class _FacePointer:
     def copy(self) -> _FacePointer:
         return _FacePointer(self.o, self.n)
 
+    def __eq__(self, other: _FacePointer) -> bool:
+        return (np.linalg.norm(self.o - other.o) + np.linalg.norm(self.n - other.n)) < 1e-6
 
 _GENERATOR = _KEY_GENERATOR()
 _GEOMANAGER = _GeometryManager()
@@ -244,6 +243,7 @@ class GeoObject:
     """
     dim: int = -1
     _default_name: str = 'GeoObject'
+    
     def __init__(self, tags: list[int] | None = None, name: str | None = None):
         if tags is None:
             tags = []
@@ -257,7 +257,7 @@ class GeoObject:
         self._embeddings: list[GeoObject] = []
         self._face_pointers: dict[str, _FacePointer] = dict()
         self._tools: dict[int, dict[str, _FacePointer]] = dict()
-        
+        self._hidden: bool = False
         self._key = _GENERATOR.new()
         self._aux_data: dict[str, Any] = dict()
         self._priority: int = 10
@@ -266,7 +266,24 @@ class GeoObject:
         
         self.give_name(name)
         _GEOMANAGER.submit_geometry(self)
-
+        self._fill_face_pointers()
+        
+    def _fill_face_pointers(self) -> None:
+        """ Fills the list of all face pointers of this object
+        """
+        current = list(self._face_pointers.values())
+        ctr = 0
+        gmsh.model.occ.synchronize()
+        for dim, tag in gmsh.model.get_boundary(self.dimtags, True, False):
+            if dim != 2:
+                continue
+            o = gmsh.model.occ.get_center_of_mass(2, tag)
+            n = gmsh.model.get_normal(tag, (0,0))
+            fp = _FacePointer(o, n)
+            if fp not in current:
+                self._face_pointers[f'Face{ctr}'] = fp
+                ctr += 1
+            
     def _store(self, name: str, data: Any) -> None:
         """Store a property as auxilliary data under a given name
 
@@ -364,6 +381,19 @@ class GeoObject:
     def _data(self, *labels) -> tuple[Any | None, ...]:
         return tuple([self._aux_data[lab] for lab in labels])
     
+    def _replace_pointer(self, name: str, face_pointer: _FacePointer) -> None:
+        """Will be used to replace face pointers so only one unique one exists.
+
+        Args:
+            name (str): _description_
+            face_pointer (_FacePointer): _description_
+        """
+        for key, fp in self._face_pointers.items():
+            if fp == face_pointer:
+                self._face_pointers.pop(key)
+                break
+        self._face_pointers[name] = face_pointer
+
     def _add_face_pointer(self, 
                           name: str,
                           origin: np.ndarray | None = None,
@@ -381,15 +411,16 @@ class GeoObject:
             ValueError: _description_
         """
         if tag is not None:
-            o = gmsh.model.occ.get_center_of_mass(2, tag)
-            n = gmsh.model.get_normal(tag, (0,0))
-            self._face_pointers[name] = _FacePointer(o, n)
-            return
-        if origin is not None and normal is not None:
-            self._face_pointers[name] = _FacePointer(origin, normal)
-            return
-        raise ValueError('Eitehr a tag or an origin + normal must be provided!')
-    
+            origin = gmsh.model.occ.get_center_of_mass(2, tag)
+            normal = gmsh.model.get_normal(tag, (0,0))
+        
+        if origin is None or normal is None:
+            raise ValueError('Eitehr a tag or an origin + normal must be provided!')
+        fp = _FacePointer(origin, normal)
+        self._face_pointers[name] = fp
+        #self._replace_pointer(name, fp) <-- Will be added in later versions
+        
+        
     def make_copy(self) -> GeoObject:
         """ Copies this object and returns a new object (also in GMSH)"""
         new_dimtags = gmsh.model.occ.copy(self.dimtags)
@@ -455,7 +486,7 @@ class GeoObject:
     def _face_tags(self, name: FaceNames, tool: GeoObject | None = None) -> list[int]:
         names = self._all_pointer_names
         if name not in names:
-            raise ValueError(f'The face {name} does not exist in {self}')
+            raise ValueError(f'The face {name} does not exist in {self}. Only {list(self._face_pointers.keys())}')
         
         gmsh.model.occ.synchronize()
         dimtags = gmsh.model.get_boundary(self.dimtags, True, False)
@@ -470,6 +501,7 @@ class GeoObject:
         logger.info(f'Selected face {tags}.')
         return tags
 
+    
     def set_material(self, material: Material) -> GeoObject:
         self.material = material
         return self
@@ -566,6 +598,9 @@ class GeoObject:
         Returns:
             FaceSelection: The selected faces
         """
+        # if not self._exists:
+        #     raise SelectionError('Cannot select faces from an object that no longer exists.')
+        
         if isinstance(exclude, str):
             exclude = (exclude,)
             
@@ -575,11 +610,13 @@ class GeoObject:
         if tags is None:
             tags = []
         
-        
         for name in exclude:
             tags.extend(self.face(name, tool=tool).tags)
         dimtags = gmsh.model.get_boundary(self.dimtags, True, False)
-        return FaceSelection([t for d,t in dimtags if t not in tags])
+        selname = 'Boundary'
+        if exclude:
+            selname = selname + 'Except[' + ','.join(exclude) + ']'
+        return FaceSelection([t for d,t in dimtags if t not in tags])._named(selname)
     
     def face(self, name: FaceNames = None, tool: GeoObject | None = None, no: FaceNames = None) -> FaceSelection:
         """Returns the FaceSelection for a given face name.
@@ -599,8 +636,16 @@ class GeoObject:
         if no is not None:
             return self.boundary(exclude=no)
         
-        return FaceSelection(self._face_tags(name, tool))
+        return FaceSelection(self._face_tags(name, tool))._named(name)
 
+    def all_faces(self) -> list[FaceSelection]:
+        """Returns a list of all face selections of this object
+
+        Returns:
+            list[FaceSelection]: A list of all face selections
+        """
+        return [self.face(name) for name in self._face_pointers]
+    
     def faces(self, *names: FaceNames, tool: GeoObject | None = None) -> FaceSelection:
         """Returns the FaceSelection for a given face names.
         
@@ -616,8 +661,26 @@ class GeoObject:
         tags = []
         for name in names:
             tags.extend(self._face_tags(name, tool))
-        return FaceSelection(tags)
-        
+        return FaceSelection(tags)._named('Faces[' + ','.join(names) + ']')
+    
+    def hide(self) -> GeoObject:
+        """Hides the object from views
+
+        Returns:
+            GeoObject: _description_
+        """
+        self._hidden = True
+        return self
+    
+    def unhide(self) -> GeoObject:
+        """Unhides the object from views
+
+        Returns:
+            GeoObject: _description_
+        """
+        self._hidden = False
+        return self
+    
     @property
     def dimtags(self) -> list[tuple[int, int]]:
         return [(self.dim, tag) for tag in self.tags]
@@ -643,7 +706,22 @@ class GeoObject:
     def remove(self) -> None:
         self._exists = False
         gmsh.model.occ.remove(self.dimtags, True)
-        
+    
+    def extract(self, tags: int | list[int]) -> GeoObject:
+        """Returns a new GeoObject of the same dimensional type that isolates a set of given tags
+
+        Args:
+            tags (list[int]): A list of GMSH tags
+
+        Returns:
+            GeoObject: _description_
+        """
+        if isinstance(tags, int):
+            tags = [tags,]
+        self.tags = [t for t in self.tags if t not in tags]
+        dts = [(self.dim, t) for t in tags]
+        return GeoObject.from_dimtags(dts)
+    
 class GeoVolume(GeoObject):
     '''GeoVolume is an interface to the GMSH CAD kernel. It does not represent EMerge
     specific geometry data.'''
@@ -660,10 +738,94 @@ class GeoVolume(GeoObject):
         else:
             self.tags = [tag,]
 
+        self._fill_face_pointers()
+        self._autoname()
+        
     @property
     def selection(self) -> DomainSelection:
         return DomainSelection(self.tags)
     
+    def _auto_face_tag(self) -> GeoVolume:
+        self._face_pointers = dict()
+        self._tools = dict()
+        logger.trace('Automatically assigning face pointers.')
+        ctr = 0
+        for tag in self.tags:
+            loops = gmsh.model.occ.getSurfaceLoops(tag)
+            for loopcluster in loops[1]:
+                for st in loopcluster:
+                    self._add_face_pointer(f'Face{ctr}', tag=st)
+                    ctr += 1
+        return self
+    
+    def exterior_faces(self, base_object: GeoObject) -> FaceSelection:
+        """Select the exterior faces of an object based on the face
+        pointers of an original base object. For example
+        
+        Example:
+        >>> cheese = em.geo.Box(...)
+        >>> hole = em.geo.Box(...) 
+        >>> holed_cheese = em.geo.subtract(cheese, hole)
+        >>> holed_cheese.exterior_faces(cheese)
+
+        Args:
+            base_object (GeoObject): The object to base the selection on.
+
+        Returns:
+            FaceSelection: The resultant face selection
+        """
+        dimtags = gmsh.model.get_boundary(self.dimtags, True, False)
+        
+        normals = [gmsh.model.get_normal(t, [0,0]) for d,t, in dimtags]
+        origins = [gmsh.model.occ.get_center_of_mass(d, t) for d,t in dimtags]
+        
+        tool_tags = []
+        for key, tool in self._tools.items():
+            if key == base_object._key:
+                continue
+            for name in tool.keys():
+                tags = tool[name].find(dimtags, origins, normals)
+                tool_tags.extend(tags)
+        tags = [dt[1] for dt in dimtags if dt[1] not in tool_tags]
+        return FaceSelection(tags)
+    
+    def _find_fp(self, condition: Callable):
+        for key, fp in self._face_pointers.items():
+            if condition(fp):
+                return key, fp
+        return None, None
+    
+    def _rename_fp(self, new_name: str, condition: Callable):
+        name, fp = self._find_fp(condition)
+        if fp is not None:
+            self._face_pointers.pop(name)
+            self._face_pointers[new_name] = fp
+        
+    def _autoname(self) -> None:
+        if len(self._face_pointers)==0:
+            return
+        
+        xs = []
+        ys = []
+        zs = []
+        for fp in self._face_pointers.values():
+            xs.append(fp.o[0])
+            ys.append(fp.o[1])
+            zs.append(fp.o[2])
+        minx = min(xs)
+        maxx = max(xs)
+        miny = min(ys)
+        maxy = max(ys)
+        minz = min(zs)
+        maxz = max(zs)
+        
+        self._rename_fp('-x', lambda fp: (fp.o[0]==minx) and np.abs(np.dot(fp.n, np.array([1,0,0])))>0.999)
+        self._rename_fp('+x', lambda fp: (fp.o[0]==maxx) and np.abs(np.dot(fp.n, np.array([1,0,0])))>0.999)
+        self._rename_fp('-y', lambda fp: (fp.o[1]==miny) and np.abs(np.dot(fp.n, np.array([0,1,0])))>0.999)
+        self._rename_fp('+y', lambda fp: (fp.o[1]==maxy) and np.abs(np.dot(fp.n, np.array([0,1,0])))>0.999)
+        self._rename_fp('-z', lambda fp: (fp.o[2]==minz) and np.abs(np.dot(fp.n, np.array([0,0,1])))>0.999)
+        self._rename_fp('+z', lambda fp: (fp.o[2]==maxz) and np.abs(np.dot(fp.n, np.array([0,0,1])))>0.999)
+        
 class GeoPoint(GeoObject):
     dim = 0
     _default_name: str = 'GeoPoint'

emerge/_emerge/logsettings.py

@@ -17,7 +17,7 @@
 
 from loguru import logger
 import sys
-from typing import Literal
+from typing import Literal, Generator
 from pathlib import Path
 import os
 from collections import deque
@@ -132,4 +132,28 @@ class LogController:
         self.file_level = loglevel
         os.environ["EMERGE_FILE_LOGLEVEL"] = loglevel
 
-LOG_CONTROLLER = LogController()
+class DebugCollector:
+    """The DebugController is used by EMerge to collect heuristic
+    warnings for detections of things that might be causing problems but aren't
+    guaranteed to cause them. These logs will be printed at the end of a simulation
+    to ensure that users are aware of them if they abort simulations.
+    
+    """
+    def __init__(self):
+        self.reports: list[str] = []
+    
+    @property
+    def any_warnings(self) -> bool:
+        return len(self.reports)>0
+    
+    def add_report(self, message: str):
+        self.reports.append(message)
+        
+    def all_reports(self) -> Generator[tuple[int, str], None, None]:
+        
+        for i, message in enumerate(self.reports):
+            yield i+1, message
+
+
+LOG_CONTROLLER = LogController()
+DEBUG_COLLECTOR = DebugCollector()

emerge/_emerge/material.py

@@ -244,6 +244,7 @@ class FreqCoordDependent(MatProperty):
         if scalar is not None:
             def _func(f, x, y, z) -> np.ndarray:
                 return np.eye(3)[:, :, None] * scalar(f,x,y,z)[None, None, :]
+        
         if vector is not None:
             def _func(f,x, y, z) -> np.ndarray:
                 N = x.shape[0]
@@ -251,6 +252,7 @@ class FreqCoordDependent(MatProperty):
                 idx = np.arange(3)
                 out[idx, idx, :] = vector(f,x,y,z)
                 return out
+        
         if matrix is not None:
             _func = matrix