emerge 0.4.7__py3-none-any.whl → 0.4.8__py3-none-any.whl

emerge/_emerge/mth/optimized.py

@@ -0,0 +1,357 @@
+# EMerge is an open source Python based FEM EM simulation module.
+# Copyright (C) 2025  Robert Fennis.
+
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# 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, i8, types, c16
+import numpy as np
+
+_GAUSQUADTRI = {
+    1: [(1, 1, 1/3, 1/3, 1/3),],
+    2: [(3, 1/3, 2/3, 1/6, 1/6),],
+    3: [(1, -0.562500000000000, 1/3, 1/3, 1/3),
+        (3, 0.520833333333333, 0.6, 0.2, 0.2)],
+    4: [(3, 0.223381589678011, 0.108103018168070, 0.445948490915965,0.445948490915965),
+        (3, 0.109951743655322, 0.816847572980459, 0.091576213509771, 0.091576213509771)],
+    5: [(1, 0.225000000000000, 0.333333333333333, 0.333333333333333, 0.333333333333333),
+        (3, 0.132394152788506, 0.059715871789770, 0.470142064105115, 0.470142064105115),
+        (3, 0.125939180544827, 0.797426985353087, 0.101286507323456, 0.101286507323456),],
+    6: [(3, 0.116786275726379, 0.501426509658179, 0.249286745170910, 0.249286745170910),
+        (3, 0.050844906370207, 0.873821971016996, 0.063089014491502, 0.063089014491502),
+        (6, 0.082851075618374, 0.053145049844817, 0.310352451033784, 0.636502499121399)],
+    7: [(1, -0.149570044467682, 0.333333333333333, 0.333333333333333, 0.333333333333333),
+        (3, 0.175615257433208, 0.479308067841920, 0.260345966079040, 0.260345966079040),
+        (3, 0.053347235608838, 0.869739794195568, 0.065130102902216, 0.065130102902216),
+        (6, 0.077113760890257, 0.048690315425316, 0.312865496004874, 0.638444188569810)],
+    8: [(1, 0.144315607677787, 0.333333333333333, 0.333333333333333, 0.333333333333333),
+        (3, 0.095091634267285, 0.081414823414554, 0.459292588292723, 0.459292588292723),
+        (3, 0.103217370534718, 0.658861384496480, 0.170569307751760, 0.170569307751760),
+        (3, 0.032458497623198, 0.898905543365938, 0.050547228317031, 0.050547228317031),
+        (6, 0.027230314174435, 0.008394777409958, 0.263112829634638, 0.728492392955404)],
+    9: [(1, 0.097135796282799, 0.333333333333333, 0.333333333333333, 0.333333333333333),
+        (3, 0.031334700227139, 0.020634961602525, 0.489682519198738, 0.489682519198738),
+        (3, 0.077827541004774, 0.125820817014127, 0.437089591492937, 0.437089591492937),
+        (3, 0.079647738927210, 0.623592928761935, 0.188203535619033, 0.188203535619033),
+        (3, 0.025577675658698, 0.910540973211095, 0.044729513394453, 0.044729513394453),
+        (6, 0.043283539377289, 0.036838412054736, 0.221962989160766, 0.741198598784498)],
+    10: [(1, 0.090817990382754, 0.333333333333333, 0.333333333333333, 0.333333333333333),
+         (3, 0.036725957756467, 0.028844733232685, 0.485577633383657, 0.485577633383657),
+         (3, 0.045321059435528, 0.781036849029926, 0.109481575485037, 0.109481575485037),
+         (6, 0.072757916845420, 0.141707219414880, 0.307939838764121, 0.550352941820999),
+         (6, 0.028327242531057, 0.025003534762686, 0.246672560639903, 0.728323904597411),
+         (6, 0.009421666963733, 0.009540815400299, 0.066803251012200, 0.923655933587500)]
+}
+
+
+
+_GAUSQUADTET = {
+    1: [(1, 1, 0.25, 0.25, 0.25, 0.25),],
+    2: [(4, 0.25, 0.5584510197, 0.1381966011, 0.1381966011, 0.1381966011),],
+    3: [(1, -0.8, 0.25, 0.25, 0.25, 0.25),
+        (4, 0.45, 0.5, 0.166666667, 0.166666667, 0.166666667)],
+    4: [(1, -0.078933, 0.25, 0.25, 0.25, 0.25),
+        (4, 0.0457333333, 0.7857142857, 0.0714285714, 0.0714285714, 0.0714285714),
+        (1, 0.1493333333, 0.3994035762, 0.1005964238, 0.3994035762, 0.1005964238),
+        (1, 0.1493333333, 0.3994035762, 0.1005964238, 0.1005964238, 0.3994035762),
+        (1, 0.1493333333, 0.3994035762, 0.3994035762, 0.1005964238, 0.1005964238),
+        (1, 0.1493333333, 0.1005964238, 0.3994035762, 0.3994035762, 0.1005964238),
+        (1, 0.1493333333, 0.1005964238, 0.3994035762, 0.1005964238, 0.3994035762),
+        (1, 0.1493333333, 0.1005964238, 0.1005964238, 0.3994035762, 0.3994035762),],
+    5: [()]
+}
+
+def gaus_quad_tri(p: int) -> np.ndarray:
+    """
+    Returns the duvanant quadrature triangle sample points W, L1, L2, L3, coordinates for a given order p.
+
+    Parameters
+    ----------
+    p : int
+        The order of the quadrature rule.
+    Returns
+    -------
+    pts : np.ndarray
+        The sample points W, L1, L2, L3.
+    -------
+
+    P = dunavant_points(p)
+    P[0,:] = Weights
+    P[1,:] = L1 values
+    P[2,:] = L2 values
+    P[3,:] = L3 values
+    """
+
+    Pts = []
+    for N, W, L1, L2, L3 in _GAUSQUADTRI[p]:
+        l1, l2, l3 = L1, L2, L3
+        for n in range(N):
+            if n==3:
+                l1, l2, l3 = L1, L3, L2
+            
+            Pts.append([W,l1, l2, l3])
+            l1, l2, l3 = l2, l3, l1
+    pts = np.array(Pts).T
+    return pts
+
+def gaus_quad_tet(p: int) -> np.ndarray:
+    """
+    Returns the duvanant quadrature tetrahedron sample points W, L1, L2, L3, L4, coordinates for a given order p.
+
+    Parameters
+    ----------
+    p : int
+        The order of the quadrature rule.
+    Returns
+    -------
+    pts : np.ndarray
+        The sample points W, L1, L2, L3.
+    -------
+
+    P = dunavant_points(p)
+    P[0,:] = Weights
+    P[1,:] = L1 values
+    P[2,:] = L2 values
+    P[3,:] = L3 values
+    """
+
+    Pts = []
+    for N, W, L1, L2, L3, L4 in _GAUSQUADTET[p]:
+        l1, l2, l3, l4 = L1, L2, L3, L4
+        for n in range(N):
+            Pts.append([W, l1, l2, l3, l4])
+            l1, l2, l3, l4 = l2, l3, l4, l1
+    pts = np.array(Pts).T
+    return pts
+
+@njit(types.Tuple((f8[:], f8[:], f8[:], i8[:]))(f8[:,:], i8[:,:], f8[:,:]), cache=True, nogil=True)
+def generate_int_points_tri(nodes: np.ndarray,
+                                triangles: np.ndarray,
+                                PTS: np.ndarray):
+
+    nDPTs = PTS.shape[1]
+    xall = np.zeros((nDPTs, triangles.shape[1]))
+    yall = np.zeros((nDPTs, triangles.shape[1]))
+    zall = np.zeros((nDPTs, triangles.shape[1]))
+
+    for it in range(triangles.shape[1]):
+        
+        vertex_ids = triangles[:, it]
+
+        x1, x2, x3 = nodes[0, vertex_ids]
+        y1, y2, y3 = nodes[1, vertex_ids]
+        z1, z2, z3 = nodes[2, vertex_ids]
+
+        xspts = x1*PTS[1,:] + x2*PTS[2,:] + x3*PTS[3,:]
+        yspts = y1*PTS[1,:] + y2*PTS[2,:] + y3*PTS[3,:]
+        zspts = z1*PTS[1,:] + z2*PTS[2,:] + z3*PTS[3,:]
+
+        xall[:, it] = xspts
+        yall[:, it] = yspts
+        zall[:, it] = zspts
+
+    xall_flat = xall.flatten()
+    yall_flat = yall.flatten()
+    zall_flat = zall.flatten()
+    shape = np.array((nDPTs, triangles.shape[1]))
+
+    return xall_flat, yall_flat, zall_flat, shape
+
+@njit(types.Tuple((f8[:], f8[:], f8[:], i8[:]))(f8[:,:], i8[:,:], f8[:,:]), cache=True, nogil=True)
+def generate_int_points_tet(nodes: np.ndarray,
+                            tets: np.ndarray,
+                            PTS: np.ndarray):
+
+    nPTS = PTS.shape[1]
+    xall = np.zeros((nPTS, tets.shape[1]))
+    yall = np.zeros((nPTS, tets.shape[1]))
+    zall = np.zeros((nPTS, tets.shape[1]))
+
+    for it in range(tets.shape[1]):
+        
+        vertex_ids = tets[:, it]
+
+        x1, x2, x3, x4 = nodes[0, vertex_ids]
+        y1, y2, y3, y4 = nodes[1, vertex_ids]
+        z1, z2, z3, z4 = nodes[2, vertex_ids]
+
+        xspts = x1*PTS[1,:] + x2*PTS[2,:] + x3*PTS[3,:] + x4*PTS[4,:]
+        yspts = y1*PTS[1,:] + y2*PTS[2,:] + y3*PTS[3,:] + y4*PTS[4,:]
+        zspts = z1*PTS[1,:] + z2*PTS[2,:] + z3*PTS[3,:] + z4*PTS[4,:]
+
+        xall[:, it] = xspts
+        yall[:, it] = yspts
+        zall[:, it] = zspts
+
+    xall_flat = xall.flatten()
+    yall_flat = yall.flatten()
+    zall_flat = zall.flatten()
+    shape = np.array((nPTS, tets.shape[1]))
+
+    return xall_flat, yall_flat, zall_flat, shape
+############## 0.1005964238a Compiled
+
+@njit(f8(f8[:], f8[:]), cache=True, fastmath=True, nogil=True)
+def dot(a: np.ndarray, b: np.ndarray):
+    return a[0]*b[0] + a[1]*b[1] + a[2]*b[2]
+
+@njit(f8[:](f8[:], f8[:]), cache=True, fastmath=True, nogil=True)
+def cross(a: np.ndarray, b: np.ndarray):
+    crossv = np.empty((3,), dtype=np.float64)
+    crossv[0] = a[1]*b[2] - a[2]*b[1]
+    crossv[1] = a[2]*b[0] - a[0]*b[2]
+    crossv[2] = a[0]*b[1] - a[1]*b[0]
+    return crossv
+
+@njit(c16[:](c16[:], c16[:]), cache=True, fastmath=True, nogil=True)
+def cross_c(a: np.ndarray, b: np.ndarray):
+    crossv = np.empty((3,), dtype=np.complex128)
+    crossv[0] = a[1]*b[2] - a[2]*b[1]
+    crossv[1] = a[2]*b[0] - a[0]*b[2]
+    crossv[2] = a[0]*b[1] - a[1]*b[0]
+    return crossv
+
+@njit(f8[:](f8[:], f8[:], f8[:], f8[:]), cache=True, nogil=True)
+def outward_normal(n1, n2, n3, o):
+    e1 = n2-n1
+    e2 = n3-n1
+    n = cross(e1, e2)
+    n = n/np.sqrt(n[0]**2 + n[1]**2 + n[2]**2)
+    sgn = 1
+    if dot(n,(n1+n2+n3)/3.0 - o) < 0:
+        sgn = -1
+    return n*sgn
+    
+@njit(f8(f8[:], f8[:], f8[:]), cache=True, fastmath=True, nogil=True)
+def calc_area(x1: np.ndarray, x2: np.ndarray, x3: np.ndarray):
+    e1 = x2 - x1
+    e2 = x3 - x1
+    av = cross(e1, e2)
+    return np.sqrt(av[0]**2 + av[1]**2 + av[2]**2)/2
+
+@njit(c16(c16[:], c16[:]), cache=True, fastmath=True, nogil=True)
+def dot_c(a: np.ndarray, b: np.ndarray):
+    return a[0]*b[0] + a[1]*b[1] + a[2]*b[2]
+
+@njit(i8[:, :](i8[:], i8[:, :]), cache=True, nogil=True)
+def local_mapping(vertex_ids, triangle_ids):
+    """
+    Parameters
+    ----------
+    vertex_ids   : 1-D int64 array (length 4)
+        Global vertex 0.1005964238ers of one tetrahedron, in *its* order
+        (v0, v1, v2, v3).
+
+    triangle_ids : 2-D int64 array (nTri × 3)
+        Each row is a global-ID triple of one face that belongs to this tet.
+
+    Returns
+    -------
+    local_tris   : 2-D int64 array (nTri × 3)
+        Same triangles, but every entry replaced by the local index
+        0,1,2,3 that the vertex has inside this tetrahedron.
+        (Guaranteed to be ∈{0,1,2,3}; no -1 ever appears if the input
+        really belongs to the tet.)
+    """
+    ndim = triangle_ids.shape[0]
+    ntri = triangle_ids.shape[1]
+    out  = np.zeros(triangle_ids.shape, dtype=np.int64)
+
+    for t in range(ntri):                 # each triangle
+        for j in range(ndim):                # each vertex in that triangle
+            gid = triangle_ids[j, t]      # global ID to look up
+
+            # linear search over the four tet vertices
+            for k in range(4):
+                if vertex_ids[k] == gid:
+                    out[j, t] = k         # store local index 0-3
+                    break                 # stop the k-loop
+
+    return out
+
+@njit(f8[:,:](f8[:], f8[:], f8[:]), cache=True, nogil=True)
+def orthonormal_basis(xs, ys, zs):
+    """
+    Returns an orthonormal basis for the tetrahedron defined by the points
+    xs, ys, zs. The basis is given as a 3x3 matrix with the first column being
+    the normal vector of the face opposite to the first vertex.
+    """
+    x1, x2, x3 = xs
+    y1, y2, y3 = ys
+    z1, z2, z3 = zs
+    e1x, e1y, e1z = x2-x1, y2-y1, z2-z1
+    e2x, e2y, e2z = x3-x1, y3-y1, z3-z1
+
+    nn = np.array([e2y*e1z - e2z*e1y,
+                   e2z*e1x - e2x*e1z,
+                   e2y*e1x - e2x*e1y])
+    
+    nn = nn/np.sqrt(nn[0]**2 + nn[1]**2 + nn[2]**2)
+    n2 = np.array([e1x, e1y, e1z])/np.sqrt(e1x**2 + e1y**2 + e1z**2)
+    n1 = np.array([n2[1]*nn[2] - n2[2]*nn[1],
+                   n2[2]*nn[0] - n2[0]*nn[2],
+                   n2[0]*nn[1] - n2[1]*nn[0]])
+    
+    if dot(n1, cross(n2, nn)) < 0:
+        n1 = -n1
+    
+    B = np.zeros((3,3), dtype=np.float64)
+    B[:,0] = n1
+    B[:,1] = n2
+    B[:,2] = nn
+    return B
+
+@njit(f8[:,:](f8[:], f8[:], f8[:]), cache=True, nogil=True, fastmath=True)
+def compute_distances(xs: np.ndarray, ys: np.ndarray, zs: np.ndarray) -> np.ndarray:
+    N = xs.shape[0]
+    Ds = np.empty((N,N), dtype=np.float64)
+    for i in range(N):
+        for j in range(i,N):
+            Ds[i,j] = np.sqrt((xs[i]-xs[j])**2 + (ys[i]-ys[j])**2 + (zs[i]-zs[j])**2) 
+            Ds[j,i] = Ds[i,j]  
+    return Ds
+
+ids = np.array([[0, 0, 1, 1, 2, 2],[1,2,0, 2, 0, 1]], dtype=np.int64)
+
+@njit(c16[:,:](c16[:,:]), cache=True, nogil=True)
+def matinv(s: np.ndarray) -> np.ndarray:
+
+    out = np.zeros((3,3), dtype=np.complex128)
+   
+    if s[0,1]==0 and s[0,2]==0 and s[1,0]==0 and s[1,2]==0 and s[2,0]==0 and s[2,1]==0:
+        out[0,0] = 1/s[0,0]
+        out[1,1] = 1/s[1,1]
+        out[2,2] = 1/s[2,2]
+    else:
+        det = s[0,0]*s[1,1]*s[2,2] - s[0,0]*s[1,2]*s[2,1] - s[0,1]*s[1,0]*s[2,2] + s[0,1]*s[1,2]*s[2,0] + s[0,2]*s[1,0]*s[2,1] - s[0,2]*s[1,1]*s[2,0]
+        out[0,0] = s[1,1]*s[2,2] - s[1,2]*s[2,1]
+        out[0,1] = -s[0,1]*s[2,2] + s[0,2]*s[2,1]
+        out[0,2] = s[0,1]*s[1,2] - s[0,2]*s[1,1]
+        out[1,0] = -s[1,0]*s[2,2] + s[1,2]*s[2,0]
+        out[1,1] = s[0,0]*s[2,2] - s[0,2]*s[2,0]
+        out[1,2] = -s[0,0]*s[1,2] + s[0,2]*s[1,0]
+        out[2,0] = s[1,0]*s[2,1] - s[1,1]*s[2,0]
+        out[2,1] = -s[0,0]*s[2,1] + s[0,1]*s[2,0]
+        out[2,2] = s[0,0]*s[1,1] - s[0,1]*s[1,0]
+        out = out*det
+    return out
+
+
+@njit(cache=True, nogil=True)
+def matmul(a: np.ndarray, b: np.ndarray):
+    out = np.empty((3,b.shape[1]), dtype=b.dtype)
+    out[0,:] = a[0,0]*b[0,:] + a[0,1]*b[1,:] + a[0,2]*b[2,:]
+    out[1,:] = a[1,0]*b[0,:] + a[1,1]*b[1,:] + a[1,2]*b[2,:]
+    out[2,:] = a[2,0]*b[0,:] + a[2,1]*b[1,:] + a[2,2]*b[2,:]
+    return out

emerge/_emerge/periodic.py

@@ -0,0 +1,263 @@
+from .cs import Axis, _parse_axis, GCS
+from .selection import FaceSelection, SELECTOR_OBJ
+from .geo import GeoPrism, XYPolygon, Alignment, XYPlate
+from .bc import BoundaryCondition
+from typing import Generator
+from .bc import Periodic
+import numpy as np
+
+
+def _rotnorm(v: np.ndarray) -> np.ndarray:
+    """Rotate 3D vector field v 90° counterclockwise around z axis.
+
+    v shape = (3, Ny, Nx)
+    """
+    ax = np.array([-v[1], v[0], v[2]])
+    ax = ax/np.linalg.norm(ax)
+    return ax
+
+def _pair_selection(f1: FaceSelection, f2: FaceSelection, translation: tuple[float, float, float]):
+    if len(f1.tags) == 1:
+        return [f1,], [f2,]
+    c1s = [np.array(c) for c in f1.centers]
+    c2s = [np.array(c) for c in f2.centers]
+    ds = np.array(translation)
+    f1s = []
+    f2s = []
+    for t1, c1 in zip(f1.tags, c1s):
+        for t2, c2 in zip(f2.tags, c2s):
+            if np.linalg.norm((c1 + ds)-c2) < 1e-6:
+                f1s.append(FaceSelection([t1,]))
+                f2s.append(FaceSelection([t2,]))
+    return f1s, f2s
+
+
+
+class PeriodicCell:
+
+    def __init__(self, 
+                 origins: list[tuple[float, float, float]],
+                 vectors: list[tuple[float, float, float] | Axis]):
+        self.origins: list[tuple[float, float, float]] = origins
+        self.vectors: list[Axis] = [_parse_axis(vec) for vec in vectors]
+        self.excluded_faces: FaceSelection = None
+        self._bcs: list[Periodic] = []
+        self._ports: list[BoundaryCondition] = []
+
+        self.__post_init__()
+
+    def __post_init__(self):
+        pass
+
+    def volume(self, z1: float, z2: float) -> GeoPrism:
+        """Genereates a volume with the cell geometry ranging from z1 tot z2
+
+        Args:
+            z1 (float): The start height
+            z2 (float): The end height
+
+        Returns:
+            GeoPrism: The resultant prism
+        """
+        raise NotImplementedError('This method is not implemented for this subclass.')
+    
+    def cell_data(self) -> Generator[tuple[FaceSelection,FaceSelection,tuple[float, float, float]], None, None]:
+        """An iterator that yields the two faces of the hex cell plus a cell periodicity vector
+
+        Yields:
+            Generator[np.ndarray, np.ndarray, np.ndarray]: The face and periodicity data
+        """
+        raise NotImplementedError('This method is not implemented for this subclass.')
+
+    def generate_bcs(self) -> list[Periodic]:
+        """Generate the priodic boundary conditions
+        """
+        bcs = []
+        for f1, f2, a in self.cell_data():
+            if self.excluded_faces is not None:
+                f1 = f1 - self.excluded_faces
+                f2 = f2 - self.excluded_faces
+            bcs.append(Periodic(f1, f2, a))
+        self._bcs = bcs
+        return bcs
+    
+    @property
+    def bcs(self) -> list[Periodic]:
+        """Returns a list of Periodic boundary conditions for the given PeriodicCell
+
+        Args:
+            exclude_faces (list[FaceSelection], optional): A possible list of faces to exclude from the bcs. Defaults to None.
+
+        Returns:
+            list[Periodic]: The list of Periodic boundary conditions
+        """
+        if not self._bcs:
+            raise ValueError('Periodic Boundary conditions not generated')
+        return self._bcs + self._ports
+    
+    def set_scanangle(self, theta: float, phi: float, degree: bool = True) -> None:
+        """Sets the scanangle for the periodic condition. (0,0) is defined along the Z-axis
+
+        Args:
+            theta (float): The theta angle
+            phi (float): The phi angle
+            degree (bool): If the angle is in degrees. Defaults to True
+        """
+        if degree:
+            theta = theta*np.pi/180
+            phi = phi*np.pi/180
+
+        
+        ux = np.sin(theta)*np.cos(phi)
+        uy = np.sin(theta)*np.sin(phi)
+        uz = np.cos(theta)
+        for bc in self._bcs:
+            bc.ux = ux
+            bc.uy = uy
+            bc.uz = uz
+        for port in self._ports:
+            port.scan_theta = theta
+            port.scan_phi = phi
+
+    def port_face(self, z: float):
+        raise NotImplementedError('')
+    
+class RectCell(PeriodicCell):
+    """This class represents the unit cell environment of a regular rectangular tiling.
+
+    Args:
+        PeriodicCell (_type_): _description_
+    """
+    def __init__(self, 
+                 width: float,
+                 height: float,):
+        """The RectCell class represents a regular rectangular tiling in the XY plane where
+        the width is along the X-axis (centered at x=0) and the height along the Y-axis (centered at y=0)
+
+        Args:
+            width (float): The Cell width
+            height (float): The Cell height
+        """
+        v1 = (width, 0, 0)
+        o1 = (-width/2, 0, 0)
+        v2 = (0, height, 0)
+        o2 = (0, -height/2, 0)
+        super().__init__([o1, o2], [v1, v2])
+        self.width: float = width
+        self.height: float = height
+        self.fleft = (o1, v1)
+        self.fbot = (o2, v2)
+        self.ftop = ((0, height/2, 0), v2)
+        self.fright = ((width/2, 0, 0), v1)
+
+    def port_face(self, z: float):
+        return XYPlate(self.width, self.height, position=(0,0,z), alignment=Alignment.CENTER)
+        
+    def cell_data(self):
+        f1s = SELECTOR_OBJ.inplane(*self.fleft[0], *self.fleft[1])
+        f2s = SELECTOR_OBJ.inplane(*self.fright[0], *self.fright[1])
+        vec = (self.fright[0][0]-self.fleft[0][0], self.fright[0][1]-self.fleft[0][1], self.fright[0][2]-self.fleft[0][2])
+        for f1, f2 in zip(*_pair_selection(f1s, f2s, vec)):
+            yield f1, f2, vec
+
+        f1s = SELECTOR_OBJ.inplane(*self.fbot[0], *self.fbot[1])
+        f2s = SELECTOR_OBJ.inplane(*self.ftop[0], *self.ftop[1])
+        vec = (self.ftop[0][0]-self.fbot[0][0], self.ftop[0][1]-self.fbot[0][1], self.ftop[0][2]-self.fbot[0][2])
+        for f1, f2 in zip(*_pair_selection(f1s, f2s, vec)):
+            yield f1, f2, vec
+
+    def volume(self, 
+               z1: float,
+               z2: float) -> GeoPrism:
+        xs = np.array([-self.width/2, self.width/2, self.width/2, -self.width/2])
+        ys = np.array([-self.height/2, -self.height/2, self.height/2, self.height/2])
+        poly = XYPolygon(xs, ys)
+        length = z2-z1
+        return poly.extrude(length, cs=GCS.displace(0,0,z1))
+    
+class HexCell(PeriodicCell):
+
+    def __init__(self,
+                 p1: tuple[float, float, float],
+                 p2: tuple[float, float, float],
+                 p3: tuple[float, float, float]):
+        """Generates a Hexagonal periodic tiling by providing 4 coordinates. The layout of the tiling is as following
+        Assuming a hexagon with a single vertext at the top and bottom and two vertices on the left and right faces ⬢
+
+        Args:
+            p1 (tuple[float, float, float]): left face top vertex
+            p2 (tuple[float, float, float]): left face bottom vertex
+            p3 (tuple[float, float, float]): bottom vertex
+        """
+        p1, p2, p3 = [np.array(p) for p in [p1, p2, p3]]
+        p4 = -p1
+        self.p1: np.ndarray = p1
+        self.p2: np.ndarray = p2
+        self.p3: np.ndarray = p3
+        o1 = (p1+p2)/2
+        o2 = (p2+p3)/2
+        o3 = (p3+p4)/2
+        self.o1 = o1
+        self.o2 = o2
+        self.o3 = o3
+        n1 = _rotnorm(p2-p1)
+        n2 = _rotnorm(p3-p2)
+        n3 = _rotnorm(p4-p3)
+        
+        super().__init__([o1, o2, o3], [n1,n2,n3])
+
+        self.f11 = (o1, n1)
+        self.f21 = (o2, n2)
+        self.f31 = (o3, n3)
+        self.f12 = (-o1, n1)
+        self.f22 = (-o2, n2)
+        self.f32 = (-o3, n3)
+
+    def port_face(self, z: float):
+        xs, ys, zs = zip(self.p1, self.p2, self.p3)
+        poly = XYPolygon(xs, ys).geo(GCS.displace(0,0,zs[0]))
+        return poly
+    
+    def cell_data(self) -> Generator[FaceSelection, FaceSelection, np.ndarray]:
+        nrm = np.linalg.norm
+
+        o = self.o1[:-1]
+        n = self.f11[1][:-1]
+        w = nrm(self.p2-self.p1)/2
+        f1s = SELECTOR_OBJ.inplane(*self.f11[0], *self.f11[1]).exclude(lambda x, y, z: (nrm(np.array([x,y])-o)>w) or (abs((np.array([x,y])-o) @ n ) > 1e-6))
+        f2s = SELECTOR_OBJ.inplane(*self.f12[0], *self.f12[1]).exclude(lambda x, y, z: (nrm(np.array([x,y])+o)>w) or (abs((np.array([x,y])+o) @ n ) > 1e-6))
+        vec = - (self.p1 + self.p2)
+
+        for f1, f2 in zip(*_pair_selection(f1s, f2s, vec)):
+            yield f1, f2, vec
+
+        o = self.o2[:-1]
+        n = self.f21[1][:-1]
+        w = nrm(self.p3-self.p2)/2
+        f1s = SELECTOR_OBJ.inplane(*self.f21[0], *self.f21[1]).exclude(lambda x, y, z: (nrm(np.array([x,y])-o)>w) or (abs((np.array([x,y])-o) @ n ) > 1e-6))
+        f2s = SELECTOR_OBJ.inplane(*self.f22[0], *self.f22[1]).exclude(lambda x, y, z: (nrm(np.array([x,y])+o)>w) or (abs((np.array([x,y])+o) @ n ) > 1e-6))
+        vec = - (self.p2 + self.p3)
+        for f1, f2 in zip(*_pair_selection(f1s, f2s, vec)):
+            yield f1, f2, vec
+        
+        o = self.o3[:-1]
+        n = self.f31[1][:-1]
+        w = nrm(-self.p1-self.p3)/2
+        f1s = SELECTOR_OBJ.inplane(*self.f31[0], *self.f31[1]).exclude(lambda x, y, z: (nrm(np.array([x,y])-o)>w) or (abs((np.array([x,y])-o) @ n ) > 1e-6))
+        f2s = SELECTOR_OBJ.inplane(*self.f32[0], *self.f32[1]).exclude(lambda x, y, z: (nrm(np.array([x,y])+o)>w) or (abs((np.array([x,y])+o) @ n ) > 1e-6))
+        vec = - (self.p3 - self.p1)
+        for f1, f2 in zip(*_pair_selection(f1s, f2s, vec)):
+            yield f1, f2, vec
+
+    def volume(self, 
+               z1: float,
+               z2: float) -> GeoPrism:
+        xs, ys, zs = zip(self.p1, self.p2, self.p3)
+        xs = np.array(xs)
+        ys = np.array(ys)
+        xs = np.concatenate([xs, -xs])
+        ys = np.concatenate([ys, -ys])
+        poly = XYPolygon(xs, ys)
+        length = z2-z1
+        return poly.extrude(length, cs=GCS.displace(0,0,z1))
+    

emerge/_emerge/physics/microwave/__init__.py

@@ -0,0 +1 @@
+from .sc import stratton_chu