emerge 1.0.4__py3-none-any.whl → 1.0.6__py3-none-any.whl

emerge/__init__.py

@@ -18,7 +18,7 @@ along with this program; if not, see
 """
 import os
 
-__version__ = "1.0.4"
+__version__ = "1.0.6"
 
 ############################################################
 #               HANDLE ENVIRONMENT VARIABLES              #
@@ -33,7 +33,7 @@ os.environ["OPENBLAS_NUM_THREADS"] = NTHREADS
 os.environ["VECLIB_NUM_THREADS"] = NTHREADS
 os.environ["VECLIB_MAXIMUM_THREADS"] = NTHREADS
 os.environ["NUMEXPR_NUM_THREADS"] = NTHREADS
-os.environ["NUMBA_NUM_THREADS"] = "4"
+os.environ["NUMBA_NUM_THREADS"] = os.getenv("NUMBA_NUM_THREADS", default="4")
 os.environ.setdefault("NUMBA_THREADING_LAYER", "workqueue")
 
 ############################################################

emerge/_emerge/geo/horn.py

@@ -17,6 +17,7 @@
 
 from ..geometry import GeoVolume
 from ..cs import CoordinateSystem
+from ..selection import FaceSelection
 
 import gmsh # type: ignore
 
@@ -103,4 +104,19 @@ class Horn(GeoVolume):
         
         pc = p0 + dax * height/2
         self._add_face_pointer('front', pc - height/2*dax, -dax)
-        self._add_face_pointer('back', pc + height/2*dax, dax)
+        self._add_face_pointer('back', pc + height/2*dax, dax)
+        
+    @property
+    def front(self) -> FaceSelection:
+        """The first local -Z face of the Horn."""
+        return self.face('front')
+    
+    @property
+    def back(self) -> FaceSelection:
+        """The back local +Z face of the Horn."""
+        return self.face('back')
+    
+    @property
+    def sides(self) -> FaceSelection:
+        """The outside faces excluding the top and bottom."""
+        return self.boundary(exclude=('front','back'))

emerge/_emerge/geo/operations.py

@@ -51,11 +51,13 @@ def add(main: T, tool: T,
     GeoSurface | GeoVolume
         A new object that is the union of the main and tool objects.
     '''
+    
     out_dim_tags, out_dim_tags_map = gmsh.model.occ.fuse(main.dimtags, tool.dimtags, removeObject=remove_object, removeTool=remove_tool)
     if out_dim_tags[0][0] == 3:
         output = GeoVolume([dt[1] for dt in out_dim_tags])._take_tools(tool,main)
     elif out_dim_tags[0][0] == 2:
         output = GeoSurface([dt[1] for dt in out_dim_tags])._take_tools(tool,main)
+    
     if remove_object:
         main._exists = False
     if remove_tool:
@@ -306,10 +308,10 @@ def unite(*objects: GeoObject) -> GeoObject:
     
     main._exists = False
     dts = []
-    for other in rest:
+    for other in objects:
         dts.extend(other.dimtags)
         other._exists = False
-    new_dimtags, mapping = gmsh.model.occ.fuse(main.dimtags, dts)
+    new_dimtags, mapping = gmsh.model.occ.fuse(dts, main.dimtags)
     
     new_obj = GeoObject.from_dimtags(new_dimtags)._take_tools(*objects)
     new_obj.set_material(main.material)

emerge/_emerge/geo/pcb.py

@@ -1331,7 +1331,6 @@ class PCB:
         poly._aux_data['width'] = stripline.width*self.unit
         poly._aux_data['height'] = height*self.unit
         poly._aux_data['vdir'] = self.cs.zax
-        poly._aux_data['idir'] = Axis(self.cs.xax.np*stripline.dirright[0] + self.cs.yax.np*stripline.dirright[1])
         
         return poly
 
@@ -1346,6 +1345,7 @@ class PCB:
                   point: StripLine,
                   height: float,
                   width_multiplier: float = 5.0,
+                  width: float | None = None,
                   name: str | None = 'ModalPort'
                   ) -> GeoSurface:
         """Generate a wave-port as a GeoSurface.
@@ -1365,11 +1365,16 @@ class PCB:
         
         height = (self.thickness + height)
         
+        if width is not None:
+            W = width
+        else:
+            W = point.width*width_multiplier
+            
         ds = point.dirright
-        x0 = point.x - ds[0]*point.width*width_multiplier/2
-        y0 = point.y - ds[1]*point.width*width_multiplier/2
+        x0 = point.x - ds[0]*W/2
+        y0 = point.y - ds[1]*W/2
         z0 =  - self.thickness
-        ax1 = np.array([ds[0], ds[1], 0])*self.unit*point.width*width_multiplier
+        ax1 = np.array([ds[0], ds[1], 0])*self.unit*W
         ax2 = np.array([0,0,1])*height*self.unit
 
         plate = Plate(np.array([x0,y0,z0])*self.unit, ax1, ax2, name=name)
@@ -1443,7 +1448,7 @@ class PCB:
         tag_wire = gmsh.model.occ.addWire(ltags)
         planetag = gmsh.model.occ.addPlaneSurface([tag_wire,])
         poly = GeoPolygon([planetag,], name=name)
-        poly._store('thickness', self.thickness)
+        poly._store('thickness', self.trace_thickness)
         return poly
     
     @overload
@@ -1508,6 +1513,5 @@ class PCB:
         
         if merge:
             polys = unite(*polys)
-            
         return polys
 

emerge/_emerge/geo/polybased.py

@@ -24,6 +24,7 @@ from typing import Generator, Callable
 from ..selection import FaceSelection
 from typing import Literal
 from functools import reduce
+from loguru import logger
 
 
 def _discretize_curve(xfunc: Callable, yfunc: Callable, 
@@ -230,7 +231,22 @@ class GeoPrism(GeoVolume):
         tagslist = [self._face_tags(name) for name in  self._face_pointers.keys() if name not in exclude]
         
         tags = list(reduce(lambda a,b: a+b, tagslist))
-        return FaceSelection(tags)       
+        return FaceSelection(tags)
+    
+    @property
+    def front(self) -> FaceSelection:
+        """The first local -Z face of the prism."""
+        return self.face('front')
+    
+    @property
+    def back(self) -> FaceSelection:
+        """The back local +Z face of the prism."""
+        return self.face('back')
+    
+    @property
+    def sides(self) -> FaceSelection:
+        """The outside faces excluding the top and bottom."""
+        return self.boundary(exclude=('front','back'))
 
 class XYPolygon:
     """This class generalizes a polygon in an un-embedded XY space that can be embedded in 3D space.
@@ -362,10 +378,20 @@ class XYPolygon:
         self._check()
 
         ptags = []
+        
         xg, yg, zg = cs.in_global_cs(self.x, self.y, 0*self.x)
 
         points = dict()
         for x,y,z in zip(xg, yg, zg):
+            reuse = False
+            for key, (px, py, pz) in points.items():
+                if ((x-px)**2 + (y-py)**2 + (z-pz)**2)**0.5 < 1e-12:
+                    ptags.append(key)
+                    reuse = True
+                    break
+            if reuse:
+                logger.warning(f'Reusing {ptags[-1]}')
+                continue
             ptag = gmsh.model.occ.add_point(x,y,z)
             points[ptag] = (x,y,z)
             ptags.append(ptag)

emerge/_emerge/geo/shapes.py

@@ -97,6 +97,35 @@ class Box(GeoVolume):
         self._add_face_pointer('top', pc + height/2*hax, hax)
         self._add_face_pointer('bottom', pc - height/2*hax, -hax)
         
+    @property
+    def left(self) -> FaceSelection:
+        """The left (-X) face."""
+        return self.face('left')
+    
+    @property
+    def right(self) -> FaceSelection:
+        """The right (+X) face."""
+        return self.face('right')
+    
+    @property
+    def top(self) -> FaceSelection:
+        """The top (+Z) face."""
+        return self.face('top')
+    
+    @property
+    def bottom(self) -> FaceSelection:
+        """The bottom (-Z) face."""
+        return self.face('bottom')
+    
+    @property
+    def front(self) -> FaceSelection:
+        """The front (-Y) face."""
+        return self.face('front')
+    
+    @property
+    def back(self) -> FaceSelection:
+        """The back (+Y) face."""
+        return self.face('back')
     
     def outside(self, *exclude: Literal['bottom','top','right','left','front','back']) -> FaceSelection:
         """Select all outside faces except for the once specified by outside
@@ -131,6 +160,11 @@ class Sphere(GeoVolume):
         x,y,z = position
         self.tags: list[int] = [gmsh.model.occ.addSphere(x,y,z,radius),]
 
+    @property
+    def outside(self) -> FaceSelection:
+        """The outside boundary of the sphere.
+        """
+        return self.boundary()
 
 class XYPlate(GeoSurface):
     """Generates and XY-plane oriented plate
@@ -301,6 +335,21 @@ class Cylinder(GeoVolume):
 
         xo, yo, zo = self.cs.in_global_cs(x.flatten(), y.flatten(), z.flatten())
         return xo, yo, zo
+    
+    @property
+    def front(self) -> FaceSelection:
+        """The first local -Z face of the cylinder."""
+        return self.face('front')
+    
+    @property
+    def back(self) -> FaceSelection:
+        """The back local +Z face of the cylinder."""
+        return self.face('back')
+    
+    @property
+    def shell(self) -> FaceSelection:
+        """The outside faces excluding the top and bottom."""
+        return self.boundary(exclude=('front','back'))
 
 
 class CoaxCylinder(GeoVolume):
@@ -382,6 +431,16 @@ class CoaxCylinder(GeoVolume):
         xo, yo, zo = self.cs.in_global_cs(x.flatten(), y.flatten(), z.flatten())
         return xo, yo, zo
     
+    @property
+    def front(self) -> FaceSelection:
+        """The first local -Z face of the cylinder."""
+        return self.face('front')
+    
+    @property
+    def back(self) -> FaceSelection:
+        """The back local +Z face of the cylinder."""
+        return self.face('back')
+    
 class HalfSphere(GeoVolume):
     """A half sphere volume."""
     _default_name: str = 'HalfSphere'
@@ -411,7 +470,25 @@ class HalfSphere(GeoVolume):
         self._add_face_pointer('back',np.array(position), np.array(direction))
         self._add_face_pointer('bottom',np.array(position), np.array(direction))
         self._add_face_pointer('face',np.array(position), np.array(direction))
+        self._add_face_pointer('disc',np.array(position), np.array(direction))
 
+    @property
+    def outside(self) -> FaceSelection:
+        """The outside of the sphere excluding the flat disc face
+
+        Returns:
+            FaceSelection: _description_
+        """
+        return self.boundary(exclude=('disc',))
+    
+    @property
+    def disc(self) -> FaceSelection:
+        """The flat disc face that cuts the sphere in half
+
+        Returns:
+            FaceSelection: _description_
+        """
+        return self.face('disc')
 
 class OldBox(GeoVolume):
     '''The sided box class creates a box just like the Box class but with selectable face tags.
@@ -564,4 +641,19 @@ class Cone(GeoVolume):
         
         self._add_face_pointer('front', p0, ds)
         if r2>0:
-            self._add_face_pointer('back', p0+ds, ds)
+            self._add_face_pointer('back', p0+ds, ds)
+            
+    @property
+    def front(self) -> FaceSelection:
+        """The first local -Z face of the Cone."""
+        return self.face('front')
+    
+    @property
+    def back(self) -> FaceSelection:
+        """The back local +Z face of the Cone. If the tip of the cone has a 0 radius, no back face can be selected."""
+        return self.face('back')
+    
+    @property
+    def shell(self) -> FaceSelection:
+        """The outside faces excluding the top and bottom."""
+        return self.boundary(exclude=('front','back'))

emerge/_emerge/geometry.py

@@ -549,17 +549,26 @@ class GeoObject:
         self._priority = _GEOMANAGER.highest_priority()+10
         return self
     
-    def boundary(self, exclude: tuple[FaceNames,...] | None = None, 
+    def boundary(self, 
+                 exclude: Iterable[FaceNames,...] | str | None = None, 
                  tags: list[int] | None = None,
                  tool: GeoObject | None = None) -> FaceSelection:
         """Returns the complete set of boundary faces.
-
+        
         If implemented, it is possible to exclude a set of faces based on their name
-        or a list of tags (integers)
+        or a list of tags.
+        
+        Args:
+            exclude: (Iterable[str], str, None): A single string or list/tuple of strings.
+            tags: A list of face integers (if known)
+            tool: The tool object to base the selection face names one.
 
         Returns:
             FaceSelection: The selected faces
         """
+        if isinstance(exclude, str):
+            exclude = (exclude,)
+            
         if exclude is None:
             exclude = tuple()
             
@@ -572,17 +581,23 @@ class GeoObject:
         dimtags = gmsh.model.get_boundary(self.dimtags, True, False)
         return FaceSelection([t for d,t in dimtags if t not in tags])
     
-    def face(self, name: FaceNames, tool: GeoObject | None = None) -> FaceSelection:
+    def face(self, name: FaceNames = None, tool: GeoObject | None = None, no: FaceNames = None) -> FaceSelection:
         """Returns the FaceSelection for a given face name.
         
         The face name must be defined for the type of geometry.
 
+        FaceNames include: front, back, left, right, top, bottom, disc
+        
         Args:
             name (FaceNames): The name of the face to select.
+            tool (GeoObject, None): Which object should be used as a source for the face selection.
+            no (FaceNames): If everything BUT a face name should be selected, Equivalent to .boundary(exclude=name).
 
         Returns:
             FaceSelection: The selected face
         """
+        if no is not None:
+            return self.boundary(exclude=no)
         
         return FaceSelection(self._face_tags(name, tool))
 
@@ -593,6 +608,7 @@ class GeoObject:
 
         Args:
             name (FaceNames): The name of the face to select.
+            tool (GeoObject, None): The tool object to use as source of the selection.
 
         Returns:
             FaceSelection: The selected face
@@ -633,10 +649,12 @@ class GeoVolume(GeoObject):
     specific geometry data.'''
     dim = 3
     _default_name: str = 'GeoVolume'
+    
     def __init__(self, tag: int | Iterable[int], name: str | None = None):
         super().__init__(name=name)
         
         self.tags: list[int] = []
+        
         if isinstance(tag, Iterable):
             self.tags = list(tag)
         else:

emerge/_emerge/material.py

@@ -14,10 +14,11 @@
 # 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 __future__ import annotations
 import numpy as np
 from typing import Callable
 import inspect
+from .const import C0
 
 
 def num_args(func):
@@ -328,7 +329,7 @@ class Material:
         hex_str = self.color.lstrip('#')
         self._color_rgb = tuple(int(hex_str[i:i+2], 16)/255.0 for i in (0, 2, 4))
         self._metal: bool = _metal
-        
+    
     def __getstate__(self):
         state = self.__dict__.copy()
         for k in self._pickle_exclude:
@@ -401,6 +402,34 @@ class Material:
     def color_rgb(self) -> tuple[float,float,float]:
         return self._color_rgb
      
+    @staticmethod
+    def drude_model(conductivity: float, 
+                    colission_time: float, 
+                    er: float = 1.0,
+                    ur: float = 1.0, 
+                    color: str = "#aaaaaa", 
+                    opacity: float = 0.3,
+                    metal: bool = True) -> Material:
+        """Creates a Material using the Drume model for conductivity
+        Requires at least the DC bulk condutivity σ₀ [S/m] and the
+        collision time τ.
+
+        Args:
+            conductivity (float): The DC bulk conductivity σ₀ in S/m
+            colission_time (float): The collision time.
+            er (float, optional): The dielectric constant. Defaults to 1.0.
+            ur (float, optional): The relative permeability. Defaults to 1.0.
+            color (str, optional): The material rendering color. Defaults to "#aaaaaa".
+            opacity (float, optional): The material rendering opacity. Defaults to 0.3.
+            metal (bool, optional): If it should be rendered as a metal.. Defaults to True.
+
+        Returns:
+            Material: The resultant material.
+        """
+        colission_dist = colission_time/C0
+        fsigma = FreqDependent(scalar = lambda f: conductivity/(1 - 1j*2*np.pi*f*colission_dist))
+        return Material(er, ur, 0.0, fsigma, color=color, opacity=opacity, _metal=metal)
+    
 AIR = Material(color="#4496f3", opacity=0.05, name='Air')
 COPPER = Material(cond=5.8e7, color="#62290c", _metal=True, name='Copper')
 PEC = Material(color="#ff78aa", opacity=1.0, cond=1e30, _metal=True, name="PEC")

emerge/_emerge/mesher.py

@@ -280,7 +280,8 @@ class Mesher:
         for dimtag in dimtags:
             gmsh.model.mesh.setSizeFromBoundary(dimtag[0], dimtag[1], 0)
             
-    def set_boundary_size(self, boundary: GeoObject | Selection | Iterable, 
+    def set_boundary_size(self, 
+                          boundary: GeoObject | Selection | Iterable, 
                           size:float,
                           growth_rate: float = 1.4,
                           max_size: float | None = None) -> None:

emerge/_emerge/physics/microwave/assembly/assembler.py

@@ -105,7 +105,7 @@ class Assembler:
     def __init__(self, settings: Settings):
         
         self.cached_matrices = None
-        self.settings = settings
+        self.settings: Settings = settings
     
     def assemble_bma_matrices(self,
                               field: Nedelec2,

emerge/_emerge/physics/microwave/assembly/curlcurl.py

@@ -244,24 +244,24 @@ def ned2_tet_stiff_mass(tet_vertices, edge_lengths, local_edge_map, local_tri_ma
 
             L2 = edge_lengths[ej]
 
-            BB1 = matmul(Mm,GC)
-            BC1 = matmul(Mm,GD)
-            BD1 = dot_c(GA,BB1)
-            BE1 = dot_c(GA,BC1)
-            BF1 = dot_c(GB,BB1)
-            BG1 = dot_c(GB,BC1)
-
-            Q2 = L1*L2
-            Q = Q2*9*dot_c(cross_c(GA,GB),matmul(Ms,cross_c(GC,GD)))
-            Dmat[ei+0,ej+0] = Q*VAC
-            Dmat[ei+0,ej+10] = Q*VAD
-            Dmat[ei+10,ej+0] = Q*VBC
-            Dmat[ei+10,ej+10] = Q*VBD
+            erGF = matmul(Mm,GC)
+            erGC = matmul(Mm,GD)
+            erGD = dot_c(GA,erGF)
+            GE_MUL_erGF = dot_c(GA,erGC)
+            GE_MUL_erGC = dot_c(GB,erGF)
+            GA_MUL_erGF = dot_c(GB,erGC)
+
+            L12 = L1*L2
+            Factor = L12*9*dot_c(cross_c(GA,GB),matmul(Ms,cross_c(GC,GD)))
+            Dmat[ei+0,ej+0] = Factor*VAC
+            Dmat[ei+0,ej+10] = Factor*VAD
+            Dmat[ei+10,ej+0] = Factor*VBC
+            Dmat[ei+10,ej+10] = Factor*VBD
             
-            Fmat[ei+0,ej+0] = Q2*(VABCD*BD1-VABCC*BE1-VAACD*BF1+VAACC*BG1)
-            Fmat[ei+0,ej+10] = Q2*(VABDD*BD1-VABCD*BE1-VAADD*BF1+VAACD*BG1)
-            Fmat[ei+10,ej+0] = Q2*(VBBCD*BD1-VBBCC*BE1-VABCD*BF1+VABCC*BG1)
-            Fmat[ei+10,ej+10] = Q2*(VBBDD*BD1-VBBCD*BE1-VABDD*BF1+VABCD*BG1)       
+            Fmat[ei+0,ej+0] = L12*(VABCD*erGD-VABCC*GE_MUL_erGF-VAACD*GE_MUL_erGC+VAACC*GA_MUL_erGF)
+            Fmat[ei+0,ej+10] = L12*(VABDD*erGD-VABCD*GE_MUL_erGF-VAADD*GE_MUL_erGC+VAACD*GA_MUL_erGF)
+            Fmat[ei+10,ej+0] = L12*(VBBCD*erGD-VBBCC*GE_MUL_erGF-VABCD*GE_MUL_erGC+VABCC*GA_MUL_erGF)
+            Fmat[ei+10,ej+10] = L12*(VBBDD*erGD-VBBCD*GE_MUL_erGF-VABDD*GE_MUL_erGC+VABCD*GA_MUL_erGF)       
 
         for ej in range(4):
             ej1, ej2, fj = local_tri_map[:, ej]
@@ -292,29 +292,29 @@ def ned2_tet_stiff_mass(tet_vertices, edge_lengths, local_edge_map, local_tri_ma
             Lab2 = Ds[ej1, ej2]
             Lac2 = Ds[ej1, fj]
             
-            AB1 = cross_c(GA,GB)
-            AI1 = dot_c(AB1,matmul(Ms,cross_c(GC,GF)))
-            AJ1 = dot_c(AB1,matmul(Ms,cross_c(GD,GF)))
-            AK1 = dot_c(AB1,matmul(Ms,cross_c(GC,GD)))
-            BB1 = matmul(Mm,GF)
-            BC1 = matmul(Mm,GC)
-            BD1 = matmul(Mm,GD)
-            BE1 = dot_c(GA,BB1)
-            BF1 = dot_c(GA,BC1)
-            BG1 = dot_c(GB,BB1)
-            BH1 = dot_c(GB,BC1)
-            BI1 = dot_c(GA,BD1)
-            BJ1 = dot_c(GB,BD1)
+            CROSS_AE = cross_c(GA,GB)
+            CROSS_DF = dot_c(CROSS_AE,matmul(Ms,cross_c(GC,GF)))
+            CROSS_CD = dot_c(CROSS_AE,matmul(Ms,cross_c(GD,GF)))
+            AE_MUL_CF = dot_c(CROSS_AE,matmul(Ms,cross_c(GC,GD)))
+            erGF = matmul(Mm,GF)
+            erGC = matmul(Mm,GC)
+            erGD = matmul(Mm,GD)
+            GE_MUL_erGF = dot_c(GA,erGF)
+            GE_MUL_erGC = dot_c(GA,erGC)
+            GA_MUL_erGF = dot_c(GB,erGF)
+            GA_MUL_erGC = dot_c(GB,erGC)
+            GE_MUL_erGD = dot_c(GA,erGD)
+            GA_MUL_erGD = dot_c(GB,erGD)
             
-            Dmat[ei+0,ej+6] = L1*Lac2*(-6*VAD*AI1-3*VAC*AJ1-3*VAF*AK1)
-            Dmat[ei+0,ej+16] = L1*Lab2*(6*VAF*AK1+3*VAD*AI1-3*VAC*AJ1)
-            Dmat[ei+10,ej+6] = L1*Lac2*(-6*VBD*AI1-3*VBC*AJ1-3*VBF*AK1)
-            Dmat[ei+10,ej+16] = L1*Lab2*(6*VBF*AK1+3*VBD*AI1-3*VBC*AJ1)
-
-            Fmat[ei+0,ej+6] = L1*Lac2*(VABCD*BE1-VABDF*BF1-VAACD*BG1+VAADF*BH1)
-            Fmat[ei+0,ej+16] = L1*Lab2*(VABDF*BF1-VABCF*BI1-VAADF*BH1+VAACF*BJ1)
-            Fmat[ei+10,ej+6] = L1*Lac2*(VBBCD*BE1-VBBDF*BF1-VABCD*BG1+VABDF*BH1)
-            Fmat[ei+10,ej+16] = L1*Lab2*(VBBDF*BF1-VBBCF*BI1-VABDF*BH1+VABCF*BJ1)
+            Dmat[ei+0,ej+6] = L1*Lac2*(-6*VAD*CROSS_DF-3*VAC*CROSS_CD-3*VAF*AE_MUL_CF)
+            Dmat[ei+0,ej+16] = L1*Lab2*(6*VAF*AE_MUL_CF+3*VAD*CROSS_DF-3*VAC*CROSS_CD)
+            Dmat[ei+10,ej+6] = L1*Lac2*(-6*VBD*CROSS_DF-3*VBC*CROSS_CD-3*VBF*AE_MUL_CF)
+            Dmat[ei+10,ej+16] = L1*Lab2*(6*VBF*AE_MUL_CF+3*VBD*CROSS_DF-3*VBC*CROSS_CD)
+
+            Fmat[ei+0,ej+6] = L1*Lac2*(VABCD*GE_MUL_erGF-VABDF*GE_MUL_erGC-VAACD*GA_MUL_erGF+VAADF*GA_MUL_erGC)
+            Fmat[ei+0,ej+16] = L1*Lab2*(VABDF*GE_MUL_erGC-VABCF*GE_MUL_erGD-VAADF*GA_MUL_erGC+VAACF*GA_MUL_erGD)
+            Fmat[ei+10,ej+6] = L1*Lac2*(VBBCD*GE_MUL_erGF-VBBDF*GE_MUL_erGC-VABCD*GA_MUL_erGF+VABDF*GA_MUL_erGC)
+            Fmat[ei+10,ej+16] = L1*Lab2*(VBBDF*GE_MUL_erGC-VBBCF*GE_MUL_erGD-VABDF*GA_MUL_erGC+VABCF*GA_MUL_erGD)
     
     ## Mirror the transpose part of the previous iteration as its symmetrical
 
@@ -335,6 +335,7 @@ def ned2_tet_stiff_mass(tet_vertices, edge_lengths, local_edge_map, local_tri_ma
         GE = GLs[fi]
         Lac1 = Ds[ei1, fi]
         Lab1 = Ds[ei1, ei2]
+        
         for ej in range(4):
             ej1, ej2, fj = local_tri_map[:, ej]
             
@@ -366,44 +367,44 @@ def ned2_tet_stiff_mass(tet_vertices, edge_lengths, local_edge_map, local_tri_ma
             Lac2 = Ds[ej1, fj]
             Lab2 = Ds[ej1, ej2]
 
-            AB1 = cross_c(GA,GE)
-            AF1 = cross_c(GB,GE)
-            AG1 = cross_c(GA,GB)
-            AH1 = matmul(Ms,cross_c(GC,GF))
-            AI1 = matmul(Ms,cross_c(GD,GF))
-            AJ1 = matmul(Ms,cross_c(GC,GD))
-            AK1 = dot_c(AB1,AH1)
-            AL1 = dot_c(AB1,AI1)
-            AM1 = dot_c(AB1,AJ1)
-            AN1 = dot_c(AF1,AH1)
-            AO1 = dot_c(AF1,AI1)
-            AP1 = dot_c(AF1,AJ1)
-            AQ1 = dot_c(AG1,AH1)
-            AR1 = dot_c(AG1,AI1)
-            AS1 = dot_c(AG1,AJ1)
-            BB1 = matmul(Mm,GF)
-            BC1 = matmul(Mm,GC)
-            BD1 = matmul(Mm,GD)
-            BE1 = dot_c(GE,BB1)
-            BF1 = dot_c(GE,BC1)
-            BG1 = dot_c(GA,BB1)
-            BH1 = dot_c(GA,BC1)
-            BI1 = dot_c(GE,BD1)
-            BJ1 = dot_c(GA,BD1)
-            BK1 = dot_c(GB,BB1)
-            BL1 = dot_c(GB,BC1)
-            BM1 = dot_c(GB,BD1)
-
-            Q1 = 2*VAD*AN1+VAC*AO1+VAF*AP1
-            Q2 = -2*VAF*AP1-VAD*AN1+VAC*AO1
-            Dmat[ei+6,ej+6] = Lac1*Lac2*(4*VBD*AK1+2*VBC*AL1+2*VBF*AM1+Q1+2*VDE*AQ1+VCE*AR1+VEF*AS1)
-            Dmat[ei+6,ej+16] = Lac1*Lab2*(-4*VBF*AM1-2*VBD*AK1+2*VBC*AL1+Q2-2*VEF*AS1-VDE*AQ1+VCE*AR1)
-            Dmat[ei+16,ej+6] = Lab1*Lac2*(-4*VDE*AQ1-2*VCE*AR1-2*VEF*AS1-2*VBD*AK1-VBC*AL1-VBF*AM1+Q1)
-            Dmat[ei+16,ej+16] = Lab1*Lab2*(4*VEF*AS1+2*VDE*AQ1-2*VCE*AR1+2*VBF*AM1+VBD*AK1-VBC*AL1+Q2)
-            Fmat[ei+6,ej+6] = Lac1*Lac2*(VABCD*BE1-VABDF*BF1-VBCDE*BG1+VBDEF*BH1)
-            Fmat[ei+6,ej+16] = Lac1*Lab2*(VABDF*BF1-VABCF*BI1-VBDEF*BH1+VBCEF*BJ1)
-            Fmat[ei+16,ej+6] = Lab1*Lac2*(VBCDE*BG1-VBDEF*BH1-VACDE*BK1+VADEF*BL1)
-            Fmat[ei+16,ej+16] = Lab1*Lab2*(VBDEF*BH1-VBCEF*BJ1-VADEF*BL1+VACEF*BM1)
+            CROSS_AE = cross_c(GA,GE)
+            CROSS_BE = cross_c(GB,GE)
+            CROSS_AB = cross_c(GA,GB)
+            CROSS_CF = matmul(Ms,cross_c(GC,GF))
+            CROSS_DF = matmul(Ms,cross_c(GD,GF))
+            CROSS_CD = matmul(Ms,cross_c(GC,GD))
+            AE_MUL_CF = dot_c(CROSS_AE,CROSS_CF)
+            AE_MUL_DF = dot_c(CROSS_AE,CROSS_DF)
+            AE_MUL_CD = dot_c(CROSS_AE,CROSS_CD)
+            BE_MUL_CF = dot_c(CROSS_BE,CROSS_CF)
+            BE_MUL_DF = dot_c(CROSS_BE,CROSS_DF)
+            BE_MUL_CD = dot_c(CROSS_BE,CROSS_CD)
+            AB_MUL_CF = dot_c(CROSS_AB,CROSS_CF)
+            AB_MUL_DF = dot_c(CROSS_AB,CROSS_DF)
+            AB_MUL_CD = dot_c(CROSS_AB,CROSS_CD)
+            erGF = matmul(Mm,GF)
+            erGC = matmul(Mm,GC)
+            erGD = matmul(Mm,GD)
+            GE_MUL_erGF = dot_c(GE,erGF)
+            GE_MUL_erGC = dot_c(GE,erGC)
+            GA_MUL_erGF = dot_c(GA,erGF)
+            GA_MUL_erGC = dot_c(GA,erGC)
+            GE_MUL_erGD = dot_c(GE,erGD)
+            GA_MUL_erGD = dot_c(GA,erGD)
+            GB_MUL_erGF = dot_c(GB,erGF)
+            GB_MUL_erGC = dot_c(GB,erGC)
+            GB_MUL_erGD = dot_c(GB,erGD)
+
+            Q1 = 2*VAD*BE_MUL_CF+VAC*BE_MUL_DF+VAF*BE_MUL_CD
+            L12 = -2*VAF*BE_MUL_CD-VAD*BE_MUL_CF+VAC*BE_MUL_DF
+            Dmat[ei+6,ej+6] = Lac1*Lac2*(4*VBD*AE_MUL_CF+2*VBC*AE_MUL_DF+2*VBF*AE_MUL_CD+Q1+2*VDE*AB_MUL_CF+VCE*AB_MUL_DF+VEF*AB_MUL_CD)
+            Dmat[ei+6,ej+16] = Lac1*Lab2*(-4*VBF*AE_MUL_CD-2*VBD*AE_MUL_CF+2*VBC*AE_MUL_DF+L12-2*VEF*AB_MUL_CD-VDE*AB_MUL_CF+VCE*AB_MUL_DF)
+            Dmat[ei+16,ej+6] = Lab1*Lac2*(-4*VDE*AB_MUL_CF-2*VCE*AB_MUL_DF-2*VEF*AB_MUL_CD-2*VBD*AE_MUL_CF-VBC*AE_MUL_DF-VBF*AE_MUL_CD+Q1)
+            Dmat[ei+16,ej+16] = Lab1*Lab2*(4*VEF*AB_MUL_CD+2*VDE*AB_MUL_CF-2*VCE*AB_MUL_DF+2*VBF*AE_MUL_CD+VBD*AE_MUL_CF-VBC*AE_MUL_DF+L12)
+            Fmat[ei+6,ej+6] = Lac1*Lac2*(VABCD*GE_MUL_erGF-VABDF*GE_MUL_erGC-VBCDE*GA_MUL_erGF+VBDEF*GA_MUL_erGC)
+            Fmat[ei+6,ej+16] = Lac1*Lab2*(VABDF*GE_MUL_erGC-VABCF*GE_MUL_erGD-VBDEF*GA_MUL_erGC+VBCEF*GA_MUL_erGD)
+            Fmat[ei+16,ej+6] = Lab1*Lac2*(VBCDE*GA_MUL_erGF-VBDEF*GA_MUL_erGC-VACDE*GB_MUL_erGF+VADEF*GB_MUL_erGC)
+            Fmat[ei+16,ej+16] = Lab1*Lab2*(VBDEF*GA_MUL_erGC-VBCEF*GA_MUL_erGD-VADEF*GB_MUL_erGC+VACEF*GB_MUL_erGD)
 
     Dmat = Dmat*KA
     Fmat = Fmat*KB