emerge 0.5.1__py3-none-any.whl → 0.5.3__py3-none-any.whl

emerge/_emerge/bc.py

@@ -21,6 +21,9 @@ from loguru import logger
 from .selection import Selection, FaceSelection
 import numpy as np
 from .geometry import GeoObject
+from typing import TypeVar, Type
+
+T = TypeVar('T')
 
 class BCDimension(Enum):
     ANY = -1
@@ -61,17 +64,8 @@ class BoundaryCondition:
         return self.dimension.value
     
     def __repr__(self) -> str:
-        if self.dimension is BCDimension.ANY:
-            return f'{type(self).__name__}{self.tags}'
-        elif self.dimension is BCDimension.EDGE:
-            return f'{type(self).__name__}{self.tags}'
-        elif self.dimension is BCDimension.NODE:
-            return f'{type(self).__name__}{self.tags}'
-        elif self.dimension is BCDimension.FACE:
-            return f'{type(self).__name__}{self.tags}'
-        elif self.dimension is BCDimension.DOMAIN:
-            return f'{type(self).__name__}{self.tags}'
-    
+        return f'{type(self).__name__}{self.tags}'
+
     def __str__(self) -> str:
         return self.__repr__()
     
@@ -94,14 +88,14 @@ class BoundaryCondition:
         elif self.dimension != BCDimension(dimension):
             raise ValueError(f'Current boundary condition has dimension {self.dimension}, but tags have dimension {BCDimension(dimension)}')
         
-    def add_tags(self, tags: list[tuple[int,int]]) -> None:
+    def add_tags(self, dimtags: list[tuple[int,int]]) -> None:
         """Adds the given taggs to this boundary condition.
 
         Args:
             tags (list[tuple[int,int]]): The tags to include
         """
-        self.check_dimension(tags)
-        tags = [x[1] for x in tags]
+        self.check_dimension(dimtags)
+        tags = [x[1] for x in dimtags]
         self.tags = _unique(self.tags + tags)
     
     def remove_tags(self, tags: list[int]) -> list[int]:
@@ -137,12 +131,12 @@ class BoundaryConditionSet:
         self.boundary_conditions: list[BoundaryCondition] = []
         self._initialized: bool = False
     
-    def _construct_bc(self, constructor: type):
+    def _construct_bc(self, constructor: type) -> type:
         def constr(*args, **kwargs):
             obj = constructor(*args, **kwargs)
             self.assign(obj)
             return obj
-        return constr
+        return constr # type: ignore
     
     def assigned(self, dim: int = 2) -> list[int]:
         """Returns all boundary tags that have a boundary condition assigned to them
@@ -171,7 +165,7 @@ class BoundaryConditionSet:
         """
         return len(self.oftype(bctype))
     
-    def oftype(self, bctype: type) -> list[BoundaryCondition]:
+    def oftype(self, bctype: Type[T]) -> list[T]:
         """Returns a list of all boundary conditions of a certain type.
 
         Args:
@@ -180,7 +174,7 @@ class BoundaryConditionSet:
         Returns:
             list[BoundaryCondition]: The list of boundary conditions
         """
-        return [item for item in self. boundary_conditions if isinstance(item, bctype)]
+        return [item for item in self.boundary_conditions if isinstance(item, bctype)]
 
     def reset(self) -> None:
         """Resets the boundary conditions that are defined
@@ -218,8 +212,8 @@ class BoundaryConditionSet:
 class Periodic(BoundaryCondition):
 
     def __init__(self, 
-                 selection1: FaceSelection,
-                 selection2: FaceSelection,
+                 selection1: Selection,
+                 selection2: Selection,
                  dv: tuple[float,float,float],
                  ):
         self.face1: BoundaryCondition = BoundaryCondition(selection1)

emerge/_emerge/const.py

@@ -0,0 +1,5 @@
+C0 = 299792458
+Z0 = 376.73031366857
+PI = 3.14159265358979323846
+EPS0 = 8.854187818814e-12
+MU0 = 1/(C0*C0*EPS0)#1.2566370612720e-6

emerge/_emerge/cs.py

@@ -120,7 +120,7 @@ XAX: Axis = Axis(np.array([1, 0, 0]))
 YAX: Axis = Axis(np.array([0, 1, 0]))
 ZAX: Axis = Axis(np.array([0, 0, 1]))
 
-def _parse_vector(vec: np.ndarray | tuple | list | Axis) -> np.ndarray:
+def _parse_vector(vec: np.ndarray | tuple[float, float, float] | list[float] | Axis) -> np.ndarray:
     """ Takes an array, tuple, list or Axis and alwasys returns an array."""
     if isinstance(vec, np.ndarray):
         return vec
@@ -130,7 +130,7 @@ def _parse_vector(vec: np.ndarray | tuple | list | Axis) -> np.ndarray:
         return vec.vector
     return None
 
-def _parse_axis(vec: np.ndarray | tuple | list | Axis) -> Axis:
+def _parse_axis(vec: np.ndarray | tuple[float, float, float] | list[float] | Axis) -> Axis:
     """Takes an array, tuple, list or Axis and always returns an Axis.
 
     Args:

emerge/_emerge/elements/femdata.py

@@ -19,7 +19,7 @@ from __future__ import annotations
 from ..mesh3d import Mesh3D
 import numpy as np
 from typing import Callable
-from scipy.sparse import coo_matrix, csr_matrix
+from scipy.sparse import csr_matrix # type: ignore
 
 from ..mth.optimized import matmul
 
@@ -31,22 +31,22 @@ class FEMBasis:
         self.n_tris: int = self.mesh.n_tris
         self.n_tets: int = self.mesh.n_tets
 
-        self.n_tet_dofs: int = None
-        self.n_tri_dofs: int = None
+        self.n_tet_dofs: int = -1
+        self.n_tri_dofs: int = -1
 
         self.n_field: int = 2*self.n_edges + 2*self.n_tris
 
-        self.tet_to_field: np.ndarray = None
+        self.tet_to_field: np.ndarray = np.array([])
         
-        self.edge_to_field: np.ndarray = None
+        self.edge_to_field: np.ndarray = np.array([])
 
-        self.tri_to_field: np.ndarray = None
+        self.tri_to_field: np.ndarray = np.array([])
 
-        self._rows: np.ndarray = None
-        self._cols: np.ndarray = None
+        self._rows: np.ndarray = np.array([])
+        self._cols: np.ndarray = np.array([])
         
     
-    def interpolate_Ef(self, field: np.ndarray, basis: np.ndarray = None, origin: np.ndarray = None, tetids: np.ndarray = None) -> Callable:
+    def interpolate_Ef(self, field: np.ndarray, basis: np.ndarray | None = None, origin: np.ndarray | None = None, tetids: np.ndarray | None = None) -> Callable:
         '''Generates the Interpolation function as a function object for a given coordiante basis and origin.'''
         if basis is None:
             basis = np.eye(3)
@@ -61,14 +61,14 @@ class FEMBasis:
             return matmul(ibasis, np.array(self.interpolate(field, xyzg[0,:], xyzg[1,:], xyzg[2,:], tetids)))
         return func
     
-    def interpolate(self, field: np.ndarray, xs: np.ndarray, ys: np.ndarray, zs: np.ndarray, tetids: np.ndarray = None) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
-        pass
+    def interpolate(self, field: np.ndarray, xs: np.ndarray, ys: np.ndarray, zs: np.ndarray, tetids: np.ndarray | None = None) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        raise NotImplementedError()
     
-    def interpolate_curl(self, field: np.ndarray, xs: np.ndarray, ys: np.ndarray, zs: np.ndarray, constants: np.ndarray, tetids: np.ndarray = None) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    def interpolate_curl(self, field: np.ndarray, xs: np.ndarray, ys: np.ndarray, zs: np.ndarray, constants: np.ndarray, tetids: np.ndarray | None = None) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
         """
         Interpolates the curl of the field at the given points.
         """
-        pass
+        raise NotImplementedError()
     
     def empty_tet_matrix(self) -> np.ndarray:
         nnz = self.n_tets*self.n_tet_dofs**2
@@ -151,7 +151,7 @@ class FEMBasis:
     def interpolate_index(self, xs: np.ndarray,
                     ys: np.ndarray,
                     zs: np.ndarray,
-                    tetids: np.ndarray = None) -> np.ndarray:
+                    tetids: np.ndarray | None = None) -> np.ndarray:
         raise NotImplementedError()
     
     def map_edge_to_field(self, edge_ids: np.ndarray) -> np.ndarray:

emerge/_emerge/elements/index_interp.py

@@ -14,7 +14,7 @@
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, see
 # <https://www.gnu.org/licenses/>.
-from numba import njit, f8, c16, i8, types
+from numba import njit, f8, c16, i8, types # type: ignore
 import numpy as np
 
 

emerge/_emerge/elements/ned2_interp.py

@@ -14,7 +14,7 @@
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, see
 # <https://www.gnu.org/licenses/>.
-from numba import njit, f8, c16, i8, types
+from numba import njit, f8, c16, i8, types # type: ignore
 import numpy as np
 from ..mth.optimized import compute_distances
 

emerge/_emerge/elements/nedelec2.py

@@ -61,14 +61,14 @@ class Nedelec2(FEMBasis):
         self.tri_to_field[7,:] = np.arange(ntris) + 2*nedges + ntris
 
         ##
-        self._field: np.ndarray = None
+        self._field: np.ndarray | None = None
         self.n_tet_dofs = 20
         self.n_tri_dofs = 8
         self._all_tet_ids = np.arange(self.ntets)
 
         self.empty_tri_rowcol()
     
-    def interpolate(self, field: np.ndarray, xs: np.ndarray, ys: np.ndarray, zs:np.ndarray, tetids: np.ndarray = None) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    def interpolate(self, field: np.ndarray, xs: np.ndarray, ys: np.ndarray, zs:np.ndarray, tetids: np.ndarray | None = None) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
         ''' 
         Interpolate the provided field data array at the given xs, ys and zs coordinates
         '''
@@ -76,7 +76,7 @@ class Nedelec2(FEMBasis):
             tetids = self._all_tet_ids
         return ned2_tet_interp(np.array([xs, ys, zs]), field, self.mesh.tets, self.mesh.tris, self.mesh.edges, self.mesh.nodes, self.tet_to_field, tetids)
     
-    def interpolate_curl(self, field: np.ndarray, xs: np.ndarray, ys: np.ndarray, zs:np.ndarray, c: np.ndarray, tetids: np.ndarray = None) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    def interpolate_curl(self, field: np.ndarray, xs: np.ndarray, ys: np.ndarray, zs:np.ndarray, c: np.ndarray, tetids: np.ndarray | None = None) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
         """
         Interpolates the curl of the field at the given points.
         """
@@ -87,7 +87,7 @@ class Nedelec2(FEMBasis):
     def interpolate_index(self, xs: np.ndarray,
                         ys: np.ndarray,
                         zs: np.ndarray,
-                        tetids: np.ndarray = None) -> np.ndarray:
+                        tetids: np.ndarray | None = None) -> np.ndarray:
         if tetids is None:
             tetids = self._all_tet_ids
 

emerge/_emerge/elements/nedleg2.py

@@ -22,7 +22,7 @@ from .femdata import FEMBasis
 from .ned2_interp import ned2_tri_interp_full, ned2_tri_interp_curl
 from ..mth.optimized import matinv
 from ..cs import CoordinateSystem
-
+from ..const import MU0, C0
 
 ## TODO: TEMPORARY SOLUTION FIX THIS
 
@@ -46,21 +46,21 @@ class FieldFunctionClass:
                  tris: np.ndarray,
                  tri_to_field: np.ndarray,
                  EH: str = 'E',
-                 diadic: np.ndarray = None,
-                 beta: float = None,
-                 constant: float = 1.0):
+                 diadic: np.ndarray | None = None,
+                 beta: float | None = None,
+                 constant: float | int | complex = 1.0):
         self.field: np.ndarray = field
         self.cs: CoordinateSystem = cs
         self.nodes: np.ndarray = nodes
         self.tris: np.ndarray = tris
         self.tri_to_field: np.ndarray = tri_to_field
         self.eh: str = EH
-        self.diadic: np.ndarray = diadic
-        self.beta: float = beta
+        self.diadic: np.ndarray | None = diadic
+        self.beta: float | None = beta
         self.constant: float = constant
         if EH == 'H':
             if diadic is None:
-                self.diadic = np.eye(3)[:,:,np.newaxis()] * np.ones((self.tris.shape[1]))
+                self.diadic = np.eye(3)[:,:,np.newaxis()] * np.ones((self.tris.shape[1])) # type: ignore
 
     def __call__(self, xs: np.ndarray,
              ys: np.ndarray,
@@ -158,7 +158,7 @@ class NedelecLegrange2(FEMBasis):
 
     def interpolate_Hf(self, field: np.ndarray, k0: float, ur: np.ndarray, beta: float) -> FieldFunctionClass:
         '''Generates the Interpolation function as a function object for a given coordiante basis and origin.'''
-        constant = 1j/ ((k0*299792458)*(4*np.pi*1e-7))
+        constant = 1j / ((k0*C0)*MU0)
         urinv = np.zeros_like(ur)
         
         for i in range(ur.shape[2]):
@@ -179,10 +179,10 @@ class NedelecLegrange2(FEMBasis):
                                self.local_nodes, 
                                self.tri_to_field)
     
-    def tri_interpolate_curl(self, field, xs: np.ndarray, ys: np.ndarray, diadic: np.ndarray = None, beta: float = 0) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    def tri_interpolate_curl(self, field, xs: np.ndarray, ys: np.ndarray, diadic: np.ndarray | None = None, beta: float = 0.0) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
         coordinates = np.array([xs, ys])
         if diadic is None:
-            diadic = np.eye(3)[:,:,np.newaxis()] * np.ones((self.mesh.n_tris))
+            diadic = np.eye(3)[:,:,np.newaxis()] * np.ones((self.mesh.n_tris)) # type: ignore
         return ned2_tri_interp_curl(coordinates, 
                                field, 
                                self.mesh.tris,  

emerge/_emerge/geo/horn.py

@@ -19,7 +19,7 @@ from ..geometry import GeoVolume
 from ..cs import CoordinateSystem
 from ..selection import FaceSelection
 
-import gmsh
+import gmsh # type: ignore
 
 class Horn(GeoVolume):
 

emerge/_emerge/geo/modeler.py

@@ -17,9 +17,9 @@
 
 from __future__ import annotations
 import numpy as np
-from typing import Callable, Iterable, Any
-from .shapes import Box, Sphere, Cyllinder, CoaxCyllinder, Alignment
-from ..geometry import GeoVolume, GeoObject, GeoSurface
+from typing import Callable, Iterable
+from .shapes import Box, Cyllinder, Alignment
+from ..geometry import GeoVolume, GeoObject
 from .operations import rotate, mirror, translate, add, subtract, embed
 from numbers import Number
 from functools import reduce
@@ -57,18 +57,16 @@ def get_count(args) -> int:
             return get_count(arg)
     return 1
 
-def get_item(value, n: int):
+def get_item(value: Number | Series | list, n: int) -> Number | Series | Iterable | None:
     if isinstance(value, Number):
         return value
     elif isinstance(value, Series):
         return value[n]
     elif isinstance(value, Iterable):
-        typ = type(value)
-        return typ([get_item(v,n) for v in value])
+        return type(value)([get_item(v, n) for v in value])
     return None
 
 def unpack(*args):
-    output = []
     N = get_count(args)
     return tuple(zip(*[[get_item(a,n) for a in args] for n in range(N)]))
 
@@ -86,7 +84,7 @@ class PartialFunction:
         self.identity: bool = identity
         self.permute: bool = permute
         self.N: int = 1
-        self.kwargset: list[dict] = None
+        self.kwargset: list[dict] | None = None
 
         for key, value in self.kwargs.items():
             if not isinstance(value, Series):
@@ -98,7 +96,7 @@ class PartialFunction:
             self.N = self.N + 1
     
     def _compile(self) -> None:
-        kwargset = []
+        kwargset: list = []
         N = self.N
 
         if self.identity:
@@ -116,7 +114,8 @@ class PartialFunction:
         self.kwargset = kwargset
 
     def __call__(self, objects: list[GeoObject], index: int) -> list[GeoObject]:
-        
+        if self.kwargset is None:
+            raise ValueError('self.kwargset is not yet defined.')
         kwargs = self.kwargset[index]
         if kwargs is None:
             return objects
@@ -159,7 +158,7 @@ class NDimContainer:
         return n
     
     @property
-    def dimtup(self) -> tuple[int]:
+    def dimtup(self) -> tuple[int, ...]:
         """A dimension tuple containing the dimensions of the NDimContainer
 
         Returns:
@@ -179,7 +178,7 @@ class NDimContainer:
                 self.expanded_dims.append((i,n,N))
         
         if self.Ncopies > 1:
-            self.expanded_dims.append((i+1, (1, self.Ncopies)))
+            self.expanded_dims.append((i+1, 1, self.Ncopies))
 
         self.map = np.arange(self.Ntot).reshape(self.dimtup)
 
@@ -215,7 +214,7 @@ class NDimContainer:
             number: int) -> list:
         dimindex, niter, Nvariations = self.expanded_dims[dim_ex_dim]
         slclist = [slice(None) for _ in self.dimensions]
-        slclist[dimindex] = number
+        slclist[dimindex] = number # type: ignore
         return list(self.map[tuple(slclist)].flatten())
         
         
@@ -286,7 +285,7 @@ class Modeler:
         tags = []
         for obj in objs:
             tags.extend(obj.tags)
-        gmshobj = GeoObject.from_dimtags(objs[0].dim, tags)
+        gmshobj = GeoObject.from_dimtags([(objs[0].dim, tag) for tag in tags])
         for obj in objs:
             gmshobj._take_tools(obj)
         return gmshobj
@@ -388,12 +387,12 @@ class Modeler:
                   position: tuple[float | Series, float | Series, float | Series],
                   cs: CoordinateSystem = GCS,
                   merge: bool = False,
-                  NPoly: int = False):
+                  NPoly: int = False) -> GeoVolume | list[GeoVolume]:
         
         N_objects = self.nvars()
         Rs, Hs, Ps = unpack(radius, height, position)
         N = len(Rs)
-        cyls = []
+        cyls: list[GeoObject] = []
         
         for _ in range(N_objects):
             for r,h,p in zip(Rs, Hs, Ps):
@@ -408,7 +407,7 @@ class Modeler:
         self._apply_presteps(cyls)
 
         if merge:
-            cyls = self._merge_object(cyls)
+            return self._merge_object(cyls)
         
         return cyls
     
@@ -434,7 +433,7 @@ class Modeler:
         N_objects = self.nvars()
         Ws, Ds, Hs, Ps = unpack(width, depth, height, position)
         N = len(Ws)
-        boxes = []
+        boxes: list[GeoVolume] = []
         
         for _ in range(N_objects):
             for w, d, h, p in zip(Ws, Ds, Hs, Ps):
@@ -444,6 +443,6 @@ class Modeler:
         self._apply_presteps(boxes)
 
         if merge:
-            boxes = self._merge_object(boxes)
+            return self._merge_object(boxes)
         
         return boxes

emerge/_emerge/geo/operations.py

@@ -16,12 +16,12 @@
 # <https://www.gnu.org/licenses/>.
 
 from typing import TypeVar
-from ..geometry import GeoSurface, GeoVolume
+from ..geometry import GeoSurface, GeoVolume, GeoObject, GeoPoint, GeoEdge
 from ..cs import CoordinateSystem, GCS
 import gmsh
 import numpy as np
 
-T = TypeVar('T', GeoSurface, GeoVolume)
+T = TypeVar('T', GeoSurface, GeoVolume, GeoObject, GeoPoint, GeoEdge)
 
 def _gen_mapping(obj_in, obj_out) -> dict:
     tag_mapping: dict[int, dict] = {0: dict(),
@@ -60,7 +60,7 @@ def add(main: T, tool: T,
         main._exists = False
     if remove_tool:
         tool._exists = False
-    return output
+    return output # 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
+    return output # 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
+    return output #type:ignore
 
 def embed(main: GeoVolume, other: GeoSurface) -> None:
     ''' Embeds a surface into a volume in the GMSH model.
@@ -138,7 +138,7 @@ def embed(main: GeoVolume, other: GeoSurface) -> None:
     None
     '''
     gmsh.model.geo.synchronize()
-    gmsh.model.mesh.embed(other.dim, [other.tag,], main.dim, main.tags)
+    gmsh.model.mesh.embed(other.dim, other.tags, main.dim, main.tags)
 
 def rotate(main: GeoVolume, 
            c0: tuple[float, float, float],
@@ -189,10 +189,10 @@ def translate(main: GeoVolume,
 
     return main
 
-def mirror(main: GeoVolume,
+def mirror(main: GeoObject,
            origin: tuple[float, float, float] = (0.0, 0.0, 0.0),
            direction: tuple[float, float, float] = (1.0, 0.0, 0.0),
-           make_copy: bool = True) -> GeoVolume:
+           make_copy: bool = True) -> GeoObject:
     """Mirrors a GeoVolume object along a miror plane defined by a direction originating at a point
 
     Args:
@@ -203,6 +203,9 @@ def mirror(main: GeoVolume,
     Returns:
         GeoVolume: The mirrored GeoVolume object
     """
+    origin = np.array(origin)
+    direction = np.array(direction)
+
     a, b, c = direction
     x0, y0, z0 = origin
     d = -(a*x0 + b*y0 + c*z0)
@@ -220,9 +223,9 @@ def mirror(main: GeoVolume,
         fp.mirror(origin, direction)
     return mirror_obj
 
-def change_coordinate_system(main: GeoVolume,
+def change_coordinate_system(main: GeoObject,
                              new_cs: CoordinateSystem = GCS,
-                             old_cs: CoordinateSystem = GCS):
+                             old_cs: CoordinateSystem = GCS) -> GeoObject:
     """Moves the GeoVolume object from a current coordinate system to a new one.
 
     The old and new coordinate system by default are the global coordinate system.