emerge 0.5.5__py3-none-any.whl → 0.6.0__py3-none-any.whl

emerge/__init__.py

@@ -18,6 +18,7 @@ along with this program; if not, see
 """
 import os
 
+__version__ = "0.6.0"
 
 ############################################################
 #               HANDLE ENVIRONMENT VARIABLES              #
@@ -43,7 +44,7 @@ from loguru import logger
 LOG_CONTROLLER.set_default()
 logger.debug('Importing modules')
 
-from ._emerge.simmodel import Simulation3D
+from ._emerge.simmodel import Simulation
 from ._emerge.material import Material
 from ._emerge import bc
 from ._emerge.solver import SolverBicgstab, SolverGMRES, SolveRoutine, ReverseCuthillMckee, Sorter, SolverPardiso, SolverUMFPACK, SolverSuperLU, EMSolver
@@ -57,5 +58,7 @@ from ._emerge.periodic import RectCell, HexCell
 from ._emerge.mesher import Algorithm2D, Algorithm3D
 from . import lib
 from ._emerge.howto import _HowtoClass
+
 howto = _HowtoClass()
+
 logger.debug('Importing complete!')

emerge/_emerge/cs.py

@@ -128,7 +128,7 @@ def _parse_vector(vec: np.ndarray | tuple[float, float, float] | list[float] | A
         return np.array(vec)
     elif isinstance(vec, Axis):
         return vec.vector
-    return None
+    return np.array(vec)
 
 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.
@@ -145,7 +145,7 @@ def _parse_axis(vec: np.ndarray | tuple[float, float, float] | list[float] | Axi
         return Axis(np.array(vec))
     elif isinstance(vec, Axis):
         return vec
-    return None
+    return Axis(np.array(vec))
 
 @dataclass
 class Plane:

emerge/_emerge/elements/ned2_interp.py

@@ -525,7 +525,7 @@ def ned2_tri_interp_full(coords: np.ndarray,
         if inside.sum() == 0:
             continue
         
-        ######### INSIDE THE TETRAHEDRON #########
+        ######### INSIDE THE TRIANGLE #########
         
         x = xs[inside==1]
         y = ys[inside==1]
@@ -533,26 +533,23 @@ def ned2_tri_interp_full(coords: np.ndarray,
         xvs = nodes[0, tris[:,itri]]
         yvs = nodes[1, tris[:,itri]]
 
-        Ds = compute_distances(xvs, yvs, 0*xvs)
-
-        L1 = Ds[0,1]
-        L2 = Ds[1,2]
-        L3 = Ds[0,2]
-
-        mult = np.array([L1,L2,L3,L3,L1,L2,L3,L1,1,1,1,1,1,1])
-
         a_s, b_s, c_s, A = tri_coefficients(xvs, yvs)
         
-        e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14 = Etri*mult
+        e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14 = Etri
 
         a1, a2, a3 = a_s
         b1, b2, b3 = b_s
         c1, c2, c3 = c_s
 
-        ex =  (e1*(b1*(a2 + b2*x + c2*y) - b2*(a1 + b1*x + c1*y))*(a1 + b1*x + c1*y) + e2*(b2*(a3 + b3*x + c3*y) - b3*(a2 + b2*x + c2*y))*(a2 + b2*x + c2*y) + e3*(b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y))*(a1 + b1*x + c1*y) - e4*(b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y) + e5*(b1*(a2 + b2*x + c2*y) - b2*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y) + e6*(b2*(a3 + b3*x + c3*y) - b3*(a2 + b2*x + c2*y))*(a3 + b3*x + c3*y) + e7*(b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y))*(a3 + b3*x + c3*y) + e8*(b1*(a2 + b2*x + c2*y) - b2*(a1 + b1*x + c1*y))*(a3 + b3*x + c3*y))/(8*A**3)
-        ey =  (e1*(c1*(a2 + b2*x + c2*y) - c2*(a1 + b1*x + c1*y))*(a1 + b1*x + c1*y) + e2*(c2*(a3 + b3*x + c3*y) - c3*(a2 + b2*x + c2*y))*(a2 + b2*x + c2*y) + e3*(c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y))*(a1 + b1*x + c1*y) - e4*(c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y) + e5*(c1*(a2 + b2*x + c2*y) - c2*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y) + e6*(c2*(a3 + b3*x + c3*y) - c3*(a2 + b2*x + c2*y))*(a3 + b3*x + c3*y) + e7*(c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y))*(a3 + b3*x + c3*y) + e8*(c1*(a2 + b2*x + c2*y) - c2*(a1 + b1*x + c1*y))*(a3 + b3*x + c3*y))/(8*A**3)
-        ez =  (a1 + b1*x + c1*y)*(e10*(-A + a1 + b1*x + c1*y) + e11*(-A + a1 + b1*x + c1*y) + e12*(a2 + b2*x + c2*y) + e13*(a2 + b2*x + c2*y) + e14*(a2 + b2*x + c2*y) + e9*(-A + a1 + b1*x + c1*y))/(2*A**2)
+        # original Nedelec-1 order 2 formulation 
+        # ex =  (e1*(b1*(a2 + b2*x + c2*y) - b2*(a1 + b1*x + c1*y))*(a1 + b1*x + c1*y) + e2*(b2*(a3 + b3*x + c3*y) - b3*(a2 + b2*x + c2*y))*(a2 + b2*x + c2*y) + e3*(b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y))*(a1 + b1*x + c1*y) - e4*(b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y) + e5*(b1*(a2 + b2*x + c2*y) - b2*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y) + e6*(b2*(a3 + b3*x + c3*y) - b3*(a2 + b2*x + c2*y))*(a3 + b3*x + c3*y) + e7*(b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y))*(a3 + b3*x + c3*y) + e8*(b1*(a2 + b2*x + c2*y) - b2*(a1 + b1*x + c1*y))*(a3 + b3*x + c3*y))/(8*A**3)
+        # ey =  (e1*(c1*(a2 + b2*x + c2*y) - c2*(a1 + b1*x + c1*y))*(a1 + b1*x + c1*y) + e2*(c2*(a3 + b3*x + c3*y) - c3*(a2 + b2*x + c2*y))*(a2 + b2*x + c2*y) + e3*(c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y))*(a1 + b1*x + c1*y) - e4*(c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y) + e5*(c1*(a2 + b2*x + c2*y) - c2*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y) + e6*(c2*(a3 + b3*x + c3*y) - c3*(a2 + b2*x + c2*y))*(a3 + b3*x + c3*y) + e7*(c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y))*(a3 + b3*x + c3*y) + e8*(c1*(a2 + b2*x + c2*y) - c2*(a1 + b1*x + c1*y))*(a3 + b3*x + c3*y))/(8*A**3)
+        # ez =  (a1 + b1*x + c1*y)*(e10*(-A + a1 + b1*x + c1*y) + e11*(-A + a1 + b1*x + c1*y) + e12*(a2 + b2*x + c2*y) + e13*(a2 + b2*x + c2*y) + e14*(a2 + b2*x + c2*y) + e9*(-A + a1 + b1*x + c1*y))/(2*A**2)
         
+        # New Nedelec-1 order 2 formulation
+        ex = (-2*A*(e1*(b1*(a2 + b2*x + c2*y) - b2*(a1 + b1*x + c1*y)) + e2*(b2*(a3 + b3*x + c3*y) - b3*(a2 + b2*x + c2*y)) + e3*(b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y))) - e4*((b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y) + (b2*(a3 + b3*x + c3*y) - b3*(a2 + b2*x + c2*y))*(a1 + b1*x + c1*y)) - e5*(b1*(a2 + b2*x + c2*y) - b2*(a1 + b1*x + c1*y))*(a1 - a2 + b1*x - b2*x + c1*y - c2*y) - e6*(b2*(a3 + b3*x + c3*y) - b3*(a2 + b2*x + c2*y))*(a2 - a3 + b2*x - b3*x + c2*y - c3*y) - e7*(b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y))*(a1 - a3 + b1*x - b3*x + c1*y - c3*y) + e8*((b1*(a2 + b2*x + c2*y) - b2*(a1 + b1*x + c1*y))*(a3 + b3*x + c3*y) + (b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y)))/(8*A**3)
+        ey = (-2*A*(e1*(c1*(a2 + b2*x + c2*y) - c2*(a1 + b1*x + c1*y)) + e2*(c2*(a3 + b3*x + c3*y) - c3*(a2 + b2*x + c2*y)) + e3*(c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y))) - e4*((c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y) + (c2*(a3 + b3*x + c3*y) - c3*(a2 + b2*x + c2*y))*(a1 + b1*x + c1*y)) - e5*(c1*(a2 + b2*x + c2*y) - c2*(a1 + b1*x + c1*y))*(a1 - a2 + b1*x - b2*x + c1*y - c2*y) - e6*(c2*(a3 + b3*x + c3*y) - c3*(a2 + b2*x + c2*y))*(a2 - a3 + b2*x - b3*x + c2*y - c3*y) - e7*(c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y))*(a1 - a3 + b1*x - b3*x + c1*y - c3*y) + e8*((c1*(a2 + b2*x + c2*y) - c2*(a1 + b1*x + c1*y))*(a3 + b3*x + c3*y) + (c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y)))/(8*A**3)
+        ez = (-e10*(a2 + b2*x + c2*y)*(A - a2 - b2*x - c2*y)/2 - e11*(a3 + b3*x + c3*y)*(A - a3 - b3*x - c3*y)/2 + e12*(a1 + b1*x + c1*y)*(a2 + b2*x + c2*y) + e13*(a2 + b2*x + c2*y)*(a3 + b3*x + c3*y) + e14*(a1 + b1*x + c1*y)*(a3 + b3*x + c3*y) - e9*(a1 + b1*x + c1*y)*(A - a1 - b1*x - c1*y)/2)/A**2
         Ex[inside] = ex
         Ey[inside] = ey
         Ez[inside] = ez
@@ -621,23 +618,21 @@ def ned2_tri_interp_curl(coords: np.ndarray,
 
         a_s, b_s, c_s, A = tri_coefficients(xvs, yvs)
 
-        Ds = compute_distances(xvs, yvs, 0*xvs)
-
-        L1 = Ds[0,1]
-        L2 = Ds[1,2]
-        L3 = Ds[0,2]
-
-        mult = np.array([L1,L2,L3,L3,L1,L2,L3,L1,1,1,1,1,1,1])
-        
-        e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14 = Etri*mult
+        e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14 = Etri
 
         a1, a2, a3 = a_s
         b1, b2, b3 = b_s
         c1, c2, c3 = c_s
-
-        hx =  (4*A*(c1*(e10*(-A + a1 + b1*x + c1*y) + e11*(-A + a1 + b1*x + c1*y) + e12*(a2 + b2*x + c2*y) + e13*(a2 + b2*x + c2*y) + e14*(a2 + b2*x + c2*y) + e9*(-A + a1 + b1*x + c1*y)) + (a1 + b1*x + c1*y)*(c1*e10 + c1*e11 + c1*e9 + c2*e12 + c2*e13 + c2*e14)) + jB*(e1*(c1*(a2 + b2*x + c2*y) - c2*(a1 + b1*x + c1*y))*(a1 + b1*x + c1*y) + e2*(c2*(a3 + b3*x + c3*y) - c3*(a2 + b2*x + c2*y))*(a2 + b2*x + c2*y) + e3*(c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y))*(a1 + b1*x + c1*y) - e4*(c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y) + e5*(c1*(a2 + b2*x + c2*y) - c2*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y) + e6*(c2*(a3 + b3*x + c3*y) - c3*(a2 + b2*x + c2*y))*(a3 + b3*x + c3*y) + e7*(c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y))*(a3 + b3*x + c3*y) + e8*(c1*(a2 + b2*x + c2*y) - c2*(a1 + b1*x + c1*y))*(a3 + b3*x + c3*y)))/(8*A**3)
-        hy =  (4*A*(b1*(e10*(-A + a1 + b1*x + c1*y) + e11*(-A + a1 + b1*x + c1*y) + e12*(a2 + b2*x + c2*y) + e13*(a2 + b2*x + c2*y) + e14*(a2 + b2*x + c2*y) + e9*(-A + a1 + b1*x + c1*y)) + (a1 + b1*x + c1*y)*(b1*e10 + b1*e11 + b1*e9 + b2*e12 + b2*e13 + b2*e14)) - jB*(e1*(b1*(a2 + b2*x + c2*y) - b2*(a1 + b1*x + c1*y))*(a1 + b1*x + c1*y) + e2*(b2*(a3 + b3*x + c3*y) - b3*(a2 + b2*x + c2*y))*(a2 + b2*x + c2*y) + e3*(b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y))*(a1 + b1*x + c1*y) - e4*(b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y) + e5*(b1*(a2 + b2*x + c2*y) - b2*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y) + e6*(b2*(a3 + b3*x + c3*y) - b3*(a2 + b2*x + c2*y))*(a3 + b3*x + c3*y) + e7*(b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y))*(a3 + b3*x + c3*y) + e8*(b1*(a2 + b2*x + c2*y) - b2*(a1 + b1*x + c1*y))*(a3 + b3*x + c3*y)))/(8*A**3)
-        hz =  (-3*a1*b1*c2*e1 - 3*a1*b1*c3*e3 + 3*a1*b2*c1*e1 + a1*b2*c3*e4 + a1*b2*c3*e8 + 3*a1*b3*c1*e3 - a1*b3*c2*e4 - a1*b3*c2*e8 - 3*a2*b1*c2*e5 + 2*a2*b1*c3*e4 - a2*b1*c3*e8 + 3*a2*b2*c1*e5 - 3*a2*b2*c3*e2 - 2*a2*b3*c1*e4 + a2*b3*c1*e8 + 3*a2*b3*c2*e2 + a3*b1*c2*e4 - 2*a3*b1*c2*e8 - 3*a3*b1*c3*e7 - a3*b2*c1*e4 + 2*a3*b2*c1*e8 - 3*a3*b2*c3*e6 + 3*a3*b3*c1*e7 + 3*a3*b3*c2*e6 - 3*b1**2*c2*e1*x - 3*b1**2*c3*e3*x + 3*b1*b2*c1*e1*x - 3*b1*b2*c2*e5*x + 3*b1*b2*c3*e4*x + 3*b1*b3*c1*e3*x - 3*b1*b3*c2*e8*x - 3*b1*b3*c3*e7*x - 3*b1*c1*c2*e1*y - 3*b1*c1*c3*e3*y - 3*b1*c2**2*e5*y + 3*b1*c2*c3*e4*y - 3*b1*c2*c3*e8*y - 3*b1*c3**2*e7*y + 3*b2**2*c1*e5*x - 3*b2**2*c3*e2*x - 3*b2*b3*c1*e4*x + 3*b2*b3*c1*e8*x + 3*b2*b3*c2*e2*x - 3*b2*b3*c3*e6*x + 3*b2*c1**2*e1*y + 3*b2*c1*c2*e5*y + 3*b2*c1*c3*e8*y - 3*b2*c2*c3*e2*y - 3*b2*c3**2*e6*y + 3*b3**2*c1*e7*x + 3*b3**2*c2*e6*x + 3*b3*c1**2*e3*y - 3*b3*c1*c2*e4*y + 3*b3*c1*c3*e7*y + 3*b3*c2**2*e2*y + 3*b3*c2*c3*e6*y)/(8*A**3)
+        
+        # original Nedelec-1 order 2 formulation 
+        #hx =  (4*A*(c1*(e10*(-A + a1 + b1*x + c1*y) + e11*(-A + a1 + b1*x + c1*y) + e12*(a2 + b2*x + c2*y) + e13*(a2 + b2*x + c2*y) + e14*(a2 + b2*x + c2*y) + e9*(-A + a1 + b1*x + c1*y)) + (a1 + b1*x + c1*y)*(c1*e10 + c1*e11 + c1*e9 + c2*e12 + c2*e13 + c2*e14)) + jB*(e1*(c1*(a2 + b2*x + c2*y) - c2*(a1 + b1*x + c1*y))*(a1 + b1*x + c1*y) + e2*(c2*(a3 + b3*x + c3*y) - c3*(a2 + b2*x + c2*y))*(a2 + b2*x + c2*y) + e3*(c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y))*(a1 + b1*x + c1*y) - e4*(c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y) + e5*(c1*(a2 + b2*x + c2*y) - c2*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y) + e6*(c2*(a3 + b3*x + c3*y) - c3*(a2 + b2*x + c2*y))*(a3 + b3*x + c3*y) + e7*(c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y))*(a3 + b3*x + c3*y) + e8*(c1*(a2 + b2*x + c2*y) - c2*(a1 + b1*x + c1*y))*(a3 + b3*x + c3*y)))/(8*A**3)
+        # hy =  (4*A*(b1*(e10*(-A + a1 + b1*x + c1*y) + e11*(-A + a1 + b1*x + c1*y) + e12*(a2 + b2*x + c2*y) + e13*(a2 + b2*x + c2*y) + e14*(a2 + b2*x + c2*y) + e9*(-A + a1 + b1*x + c1*y)) + (a1 + b1*x + c1*y)*(b1*e10 + b1*e11 + b1*e9 + b2*e12 + b2*e13 + b2*e14)) - jB*(e1*(b1*(a2 + b2*x + c2*y) - b2*(a1 + b1*x + c1*y))*(a1 + b1*x + c1*y) + e2*(b2*(a3 + b3*x + c3*y) - b3*(a2 + b2*x + c2*y))*(a2 + b2*x + c2*y) + e3*(b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y))*(a1 + b1*x + c1*y) - e4*(b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y) + e5*(b1*(a2 + b2*x + c2*y) - b2*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y) + e6*(b2*(a3 + b3*x + c3*y) - b3*(a2 + b2*x + c2*y))*(a3 + b3*x + c3*y) + e7*(b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y))*(a3 + b3*x + c3*y) + e8*(b1*(a2 + b2*x + c2*y) - b2*(a1 + b1*x + c1*y))*(a3 + b3*x + c3*y)))/(8*A**3)
+        # hz =  (-3*a1*b1*c2*e1 - 3*a1*b1*c3*e3 + 3*a1*b2*c1*e1 + a1*b2*c3*e4 + a1*b2*c3*e8 + 3*a1*b3*c1*e3 - a1*b3*c2*e4 - a1*b3*c2*e8 - 3*a2*b1*c2*e5 + 2*a2*b1*c3*e4 - a2*b1*c3*e8 + 3*a2*b2*c1*e5 - 3*a2*b2*c3*e2 - 2*a2*b3*c1*e4 + a2*b3*c1*e8 + 3*a2*b3*c2*e2 + a3*b1*c2*e4 - 2*a3*b1*c2*e8 - 3*a3*b1*c3*e7 - a3*b2*c1*e4 + 2*a3*b2*c1*e8 - 3*a3*b2*c3*e6 + 3*a3*b3*c1*e7 + 3*a3*b3*c2*e6 - 3*b1**2*c2*e1*x - 3*b1**2*c3*e3*x + 3*b1*b2*c1*e1*x - 3*b1*b2*c2*e5*x + 3*b1*b2*c3*e4*x + 3*b1*b3*c1*e3*x - 3*b1*b3*c2*e8*x - 3*b1*b3*c3*e7*x - 3*b1*c1*c2*e1*y - 3*b1*c1*c3*e3*y - 3*b1*c2**2*e5*y + 3*b1*c2*c3*e4*y - 3*b1*c2*c3*e8*y - 3*b1*c3**2*e7*y + 3*b2**2*c1*e5*x - 3*b2**2*c3*e2*x - 3*b2*b3*c1*e4*x + 3*b2*b3*c1*e8*x + 3*b2*b3*c2*e2*x - 3*b2*b3*c3*e6*x + 3*b2*c1**2*e1*y + 3*b2*c1*c2*e5*y + 3*b2*c1*c3*e8*y - 3*b2*c2*c3*e2*y - 3*b2*c3**2*e6*y + 3*b3**2*c1*e7*x + 3*b3**2*c2*e6*x + 3*b3*c1**2*e3*y - 3*b3*c1*c2*e4*y + 3*b3*c1*c3*e7*y + 3*b3*c2**2*e2*y + 3*b3*c2*c3*e6*y)/(8*A**3)
+       
+        # New Nedelec-1 order 2 formulation
+        hx = (4*A*(2*c1*e12*(a2 + b2*x + c2*y) + 2*c1*e14*(a3 + b3*x + c3*y) + c1*e9*(a1 + b1*x + c1*y) - c1*e9*(A - a1 - b1*x - c1*y) + c2*e10*(a2 + b2*x + c2*y) - c2*e10*(A - a2 - b2*x - c2*y) + 2*c2*e12*(a1 + b1*x + c1*y) + 2*c2*e13*(a3 + b3*x + c3*y) + c3*e11*(a3 + b3*x + c3*y) - c3*e11*(A - a3 - b3*x - c3*y) + 2*c3*e13*(a2 + b2*x + c2*y) + 2*c3*e14*(a1 + b1*x + c1*y)) + jB*(2*A*(e1*(c1*(a2 + b2*x + c2*y) - c2*(a1 + b1*x + c1*y)) + e2*(c2*(a3 + b3*x + c3*y) - c3*(a2 + b2*x + c2*y)) + e3*(c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y))) + e4*((c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y) + (c2*(a3 + b3*x + c3*y) - c3*(a2 + b2*x + c2*y))*(a1 + b1*x + c1*y)) + e5*(c1*(a2 + b2*x + c2*y) - c2*(a1 + b1*x + c1*y))*(a1 - a2 + b1*x - b2*x + c1*y - c2*y) + e6*(c2*(a3 + b3*x + c3*y) - c3*(a2 + b2*x + c2*y))*(a2 - a3 + b2*x - b3*x + c2*y - c3*y) + e7*(c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y))*(a1 - a3 + b1*x - b3*x + c1*y - c3*y) - e8*((c1*(a2 + b2*x + c2*y) - c2*(a1 + b1*x + c1*y))*(a3 + b3*x + c3*y) + (c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y))))/(8*A**3)
+        hy = (4*A*(-2*b1*e12*(a2 + b2*x + c2*y) - 2*b1*e14*(a3 + b3*x + c3*y) - b1*e9*(a1 + b1*x + c1*y) + b1*e9*(A - a1 - b1*x - c1*y) - b2*e10*(a2 + b2*x + c2*y) + b2*e10*(A - a2 - b2*x - c2*y) - 2*b2*e12*(a1 + b1*x + c1*y) - 2*b2*e13*(a3 + b3*x + c3*y) - b3*e11*(a3 + b3*x + c3*y) + b3*e11*(A - a3 - b3*x - c3*y) - 2*b3*e13*(a2 + b2*x + c2*y) - 2*b3*e14*(a1 + b1*x + c1*y)) - jB*(2*A*(e1*(b1*(a2 + b2*x + c2*y) - b2*(a1 + b1*x + c1*y)) + e2*(b2*(a3 + b3*x + c3*y) - b3*(a2 + b2*x + c2*y)) + e3*(b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y))) + e4*((b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y) + (b2*(a3 + b3*x + c3*y) - b3*(a2 + b2*x + c2*y))*(a1 + b1*x + c1*y)) + e5*(b1*(a2 + b2*x + c2*y) - b2*(a1 + b1*x + c1*y))*(a1 - a2 + b1*x - b2*x + c1*y - c2*y) + e6*(b2*(a3 + b3*x + c3*y) - b3*(a2 + b2*x + c2*y))*(a2 - a3 + b2*x - b3*x + c2*y - c3*y) + e7*(b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y))*(a1 - a3 + b1*x - b3*x + c1*y - c3*y) - e8*((b1*(a2 + b2*x + c2*y) - b2*(a1 + b1*x + c1*y))*(a3 + b3*x + c3*y) + (b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y))))/(8*A**3)
+        hz = (4*A*(e1*(b1*c2 - b2*c1) + e2*(b2*c3 - b3*c2) + e3*(b1*c3 - b3*c1)) - e4*(b1*(c2*(a3 + b3*x + c3*y) - c3*(a2 + b2*x + c2*y)) + b2*(c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y)) - (b1*c3 - b3*c1)*(a2 + b2*x + c2*y) - (b2*c3 - b3*c2)*(a1 + b1*x + c1*y)) + e4*(c1*(b2*(a3 + b3*x + c3*y) - b3*(a2 + b2*x + c2*y)) + c2*(b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y)) + (b1*c3 - b3*c1)*(a2 + b2*x + c2*y) + (b2*c3 - b3*c2)*(a1 + b1*x + c1*y)) - e5*(b1 - b2)*(c1*(a2 + b2*x + c2*y) - c2*(a1 + b1*x + c1*y)) + e5*(c1 - c2)*(b1*(a2 + b2*x + c2*y) - b2*(a1 + b1*x + c1*y)) + 2*e5*(b1*c2 - b2*c1)*(a1 - a2 + b1*x - b2*x + c1*y - c2*y) - e6*(b2 - b3)*(c2*(a3 + b3*x + c3*y) - c3*(a2 + b2*x + c2*y)) + e6*(c2 - c3)*(b2*(a3 + b3*x + c3*y) - b3*(a2 + b2*x + c2*y)) + 2*e6*(b2*c3 - b3*c2)*(a2 - a3 + b2*x - b3*x + c2*y - c3*y) - e7*(b1 - b3)*(c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y)) + e7*(c1 - c3)*(b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y)) + 2*e7*(b1*c3 - b3*c1)*(a1 - a3 + b1*x - b3*x + c1*y - c3*y) + e8*(b2*(c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y)) + b3*(c1*(a2 + b2*x + c2*y) - c2*(a1 + b1*x + c1*y)) - (b1*c2 - b2*c1)*(a3 + b3*x + c3*y) - (b1*c3 - b3*c1)*(a2 + b2*x + c2*y)) - e8*(c2*(b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y)) + c3*(b1*(a2 + b2*x + c2*y) - b2*(a1 + b1*x + c1*y)) + (b1*c2 - b2*c1)*(a3 + b3*x + c3*y) + (b1*c3 - b3*c1)*(a2 + b2*x + c2*y)))/(8*A**3)     
         
         Ex[inside] = hx*dc[0,0]
         Ey[inside] = hy*dc[1,1]

emerge/_emerge/elements/nedleg2.py

@@ -28,13 +28,13 @@ from ..const import MU0, C0
 
 class FieldFunctionClass:
     """ This Class serves as a picklable class so that ModalPort boundary conditions
-    can actually be stored with the Simulation3D class. Functions aren't picklable in 
+    can actually be stored with the Simulation class. Functions aren't picklable in 
     Python. 
     
     I am not happy with the existence of this class, it feels too ad-hoc but for now it
     is the simplest way. It stores all actually required information needed to do a
     surface field interpolation without needing to store the Mesh3D and SurfaceMesh class
-    objects plus the NedelecLegrange2 classes with the Simulation3D. 
+    objects plus the NedelecLegrange2 classes with the Simulation. 
 
     As it stands currently, only the GMSH mesh is stored plus the geometry objects. The
     mesh is reconstructed as it is deterministic.
@@ -103,6 +103,8 @@ class NedelecLegrange2(FEMBasis):
 
         self.cs: CoordinateSystem = cs
 
+        LGORDER = 2
+        
         ## 
         nodes = self.mesh.nodes
         self.local_nodes: np.ndarray = np.array(self.cs.in_local_cs(nodes[0,:], nodes[1,:], nodes[2,:]))
@@ -113,15 +115,23 @@ class NedelecLegrange2(FEMBasis):
         self.n_tris: int = self.mesh.n_tris
         self.n_tri_dofs: int = None
 
-        self.n_field: int = 2*self.n_edges + 2*self.n_tris + self.n_nodes + self.n_edges
+        if LGORDER == 2:
+            self.n_field: int = 2*self.n_edges + 2*self.n_tris + self.n_nodes + self.n_edges
+        else:
+            self.n_field: int = 2*self.n_edges + 2*self.n_tris + self.n_nodes + self.n_edges*2 + self.n_tris
+        
         self.n_xy: int = 2*self.n_edges + 2*self.n_tris
-
         ######## MESH Derived
         Nn = self.mesh.n_nodes
         Ne = self.mesh.n_edges
         Nt = self.mesh.n_tris
 
-        self.tri_to_field: np.ndarray = np.zeros((8 + 6, self.n_tris), dtype=int)
+        
+        
+        if LGORDER==3:
+            self.tri_to_field: np.ndarray = np.zeros((8 + 10, self.n_tris), dtype=int)
+        else:
+            self.tri_to_field: np.ndarray = np.zeros((8 + 6, self.n_tris), dtype=int)
 
         self.tri_to_field[:3,:] = self.mesh.tri_to_edge
         self.tri_to_field[3,:] = np.arange(Nt) + Ne
@@ -129,13 +139,21 @@ class NedelecLegrange2(FEMBasis):
         self.tri_to_field[7,:] = np.arange(Nt) + 2*Ne + Nt
         self.tri_to_field[8:11,:] = self.mesh.tris + (2*Ne + 2*Nt) # + E + T + E + T
         self.tri_to_field[11:14,:] = self.mesh.tri_to_edge + (2*Ne + 2*Nt + Nn)
-    
+        
+        if LGORDER==3:
+            # Legrange 3
+            self.tri_to_field[14:17,:] = self.mesh.tri_to_edge + (2*Ne + 2*Nt + Nn + Ne)
+            self.tri_to_field[17,:] = np.arange(Nt) + (2*Ne + 2*Nt + Nn + Ne + Ne)
+        
         self.edge_to_field: np.ndarray = np.zeros((5,Ne), dtype=int) #edge mode 1, edge mode 2, edge legrande mode, edge vertex mode 1, edge vertex mode 2
 
         self.edge_to_field[0,:] = np.arange(Ne)
         self.edge_to_field[1,:] = np.arange(Ne) + Nt + Ne
-        self.edge_to_field[2,:] = np.arange(Ne) + Ne*2 + Nt*2 + Nn
-        self.edge_to_field[3:,:] = self.mesh.edges + Ne*2 + Nt*2
+        self.edge_to_field[2:4,:] = self.mesh.edges + Ne*2 + Nt*2
+        self.edge_to_field[4,:] = np.arange(Ne) + Ne*2 + Nt*2 + Nn
+        
+        if LGORDER==3:
+            self.edge_to_field[5:,:] = np.arange(Ne)  + Ne*2 + Nt*2 + Nn + Ne
 
         ##
         self._field: np.ndarray = None   
@@ -148,12 +166,6 @@ class NedelecLegrange2(FEMBasis):
     
     def interpolate_Ef(self, field: np.ndarray) -> FieldFunctionClass:
         '''Generates the Interpolation function as a function object for a given coordiante basis and origin.'''
-        
-        # def func(xs: np.ndarray, ys: np.ndarray, zs: np.ndarray) -> np.ndarray:
-        #     xl, yl, zl = self.cs.in_local_cs(xs, ys, zs)
-        #     Exl, Eyl, Ezl = self.tri_interpolate(field, xl, yl)
-        #     Ex, Ey, Ez = self.cs.in_global_basis(Exl, Eyl, Ezl)
-        #     return np.array([Ex, Ey, Ez])
         return FieldFunctionClass(field, self.cs, self.local_nodes, self.mesh.tris, self.tri_to_field, 'E')
 
     def interpolate_Hf(self, field: np.ndarray, k0: float, ur: np.ndarray, beta: float) -> FieldFunctionClass:
@@ -164,11 +176,6 @@ class NedelecLegrange2(FEMBasis):
         for i in range(ur.shape[2]):
             urinv[:,:,i] = matinv(ur[:,:,i])
 
-        # def func(xs: np.ndarray, ys: np.ndarray, zs: np.ndarray) -> np.ndarray:
-        #     xl, yl, _ = self.cs.in_local_cs(xs, ys, zs)
-        #     Exl, Eyl, Ezl = self.tri_interpolate_curl(field, xl, yl, urinv, beta)
-        #     Ex, Ey, Ez = self.cs.in_global_basis(Exl, Eyl, Ezl)
-        #     return np.array([Ex, Ey, Ez])*constant
         return FieldFunctionClass(field, self.cs, self.local_nodes, self.mesh.tris, self.tri_to_field, 'H', urinv, beta, constant)
     
     def tri_interpolate(self, field, xs: np.ndarray, ys: np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
@@ -189,29 +196,4 @@ class NedelecLegrange2(FEMBasis):
                                self.local_nodes, 
                                self.tri_to_field,
                                diadic,
-                               beta)
-    
-    
-    # def interpolate_curl(self, field: np.ndarray, xs: np.ndarray, ys: np.ndarray, zs:np.ndarray, c: np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
-    #     """
-    #     Interpolates the curl of the field at the given points.
-    #     """
-    #     return ned2_tet_interp_curl(np.array([xs, ys,zs]), field, self.mesh.tets, self.mesh.tris, self.mesh.edges, self.mesh.nodes, self.tet_to_field, c)
-    
-    # def fieldf(self, field: np.ndarray, basis: np.ndarray = None, origin: np.ndarray = None) -> Callable:
-    #     if basis is None:
-    #         basis = np.eye(3)
-
-    #     if origin is None:
-    #         origin = np.zeros(3)
-        
-    #     ibasis = np.linalg.pinv(basis)
-    #     def func(xs: np.ndarray, ys: np.ndarray, zs: np.ndarray) -> np.ndarray:
-    #         xyz = np.array([xs, ys, zs]) + origin[:, np.newaxis]
-    #         xyzg = basis @ xyz
-    #         return ibasis @ np.array(self.interpolate(field, xyzg[0,:], xyzg[1,:], xyzg[2,:]))
-    #     return func
-    
-    ###### INDEX MAPPINGS
-
-    
+                               beta)

emerge/_emerge/geo/__init__.py

@@ -18,7 +18,7 @@
 from .pcb import PCB
 from .pmlbox import pmlbox
 from .horn import Horn
-from .shapes import Cyllinder, CoaxCyllinder, Box, XYPlate, HalfSphere, Sphere, Plate, OldBox, Alignment
+from .shapes import Cylinder, CoaxCylinder, Box, XYPlate, HalfSphere, Sphere, Plate, OldBox, Alignment
 from .operations import subtract, add, embed, remove, rotate, mirror, change_coordinate_system, translate, intersect
 from .polybased import XYPolygon, GeoPrism
 from .step import STEPItems

emerge/_emerge/geo/modeler.py

@@ -18,7 +18,7 @@
 from __future__ import annotations
 import numpy as np
 from typing import Callable, Iterable
-from .shapes import Box, Cyllinder, Alignment
+from .shapes import Box, Cylinder, Alignment
 from ..geometry import GeoVolume, GeoObject
 from .operations import rotate, mirror, translate, add, subtract, embed
 from numbers import Number
@@ -400,7 +400,7 @@ class Modeler:
                 if NPoly:
                     cyl = XYPolygon.circle(r, Nsections=NPoly).extrude(h, cs2)
                 else:
-                    cyl  = Cyllinder(r,h, cs2)
+                    cyl  = Cylinder(r,h, cs2)
                 cyls.append(cyl)
 
         self.ndimcont.set_copies(N)

emerge/_emerge/geo/pcb.py

@@ -20,7 +20,7 @@ from __future__ import annotations
 from ..cs import CoordinateSystem, GCS, Axis
 from ..geometry import GeoPolygon, GeoVolume, GeoSurface
 from ..material import Material, AIR, COPPER
-from .shapes import Box, Plate, Cyllinder
+from .shapes import Box, Plate, Cylinder
 from .polybased import XYPolygon
 from .operations import change_coordinate_system
 from .pcb_tools.macro import parse_macro
@@ -1247,14 +1247,14 @@ class PCB:
         plate = change_coordinate_system(plate, self.cs)
         return plate # type: ignore
 
-    def generate_vias(self, merge=False) -> list[Cyllinder] | Cyllinder:
+    def generate_vias(self, merge=False) -> list[Cylinder] | Cylinder:
         """Generates the via objects.
 
         Args:
             merge (bool, optional): Whether to merge the result into a final object. Defaults to False.
 
         Returns:
-            list[Cyllinder] | Cyllinder: Either al ist of cylllinders or a single one (merge=True)
+            list[Cylinder] | Cylinder: Either al ist of cylllinders or a single one (merge=True)
         """
         vias = []
         for via in self.vias:
@@ -1263,7 +1263,7 @@ class PCB:
             z0 = via.z1*self.unit
             xg, yg, zg = self.cs.in_global_cs(x0, y0, z0)
             cs = CoordinateSystem(self.cs.xax, self.cs.yax, self.cs.zax, np.array([xg, yg, zg]))
-            cyl = Cyllinder(via.radius*self.unit, (via.z2-via.z1)*self.unit, cs, via.segments)
+            cyl = Cylinder(via.radius*self.unit, (via.z2-via.z1)*self.unit, cs, via.segments)
             cyl.material = COPPER
             vias.append(cyl)
         if merge:

emerge/_emerge/geo/shapes.py

@@ -172,26 +172,26 @@ class Plate(GeoSurface):
         tags: list[int] = [gmsh.model.occ.addPlaneSurface([tag_wire,]),]
         super().__init__(tags)
 
-class Cyllinder(GeoVolume):
+class Cylinder(GeoVolume):
 
     def __init__(self, 
                  radius: float,
                  height: float,
                  cs: CoordinateSystem = None,
                  Nsections: int = None):
-        """Generates a Cyllinder object in 3D space.
+        """Generates a Cylinder object in 3D space.
         The cyllinder will always be placed in the origin of the provided CoordinateSystem.
         The bottom cyllinder plane is always placed in the XY-plane. The lenth of the cyllinder is
         oriented along the Z-axis.
 
         By default the cyllinder uses the Open Cascade modeling for a cyllinder. In this representation
         the surface of the cyllinder is approximated with a tolerance thay may be irregular.
-        As an alternative, the argument Nsections may be provided in which case the Cyllinder is replaced
+        As an alternative, the argument Nsections may be provided in which case the Cylinder is replaced
         by an extrusion of a regular N-sided polygon.
 
         Args:
-            radius (float): The radius of the Cyllinder
-            height (float): The height of the Cyllinder
+            radius (float): The radius of the Cylinder
+            height (float): The height of the Cylinder
             cs (CoordinateSystem, optional): The coordinate system. Defaults to None.
             Nsections (int, optional): The number of sections. Defaults to None.
         """
@@ -210,6 +210,10 @@ class Cyllinder(GeoVolume):
             super().__init__(cyl)
         self._add_face_pointer('front', cs.origin, -cs.zax.np)
         self._add_face_pointer('back', cs.origin+height*cs.zax.np, cs.zax.np)
+        self._add_face_pointer('bottom', cs.origin, -cs.zax.np)
+        self._add_face_pointer('top', cs.origin+height*cs.zax.np, cs.zax.np)
+        self._add_face_pointer('left', cs.origin, -cs.zax.np)
+        self._add_face_pointer('right', cs.origin+height*cs.zax.np, cs.zax.np)
             
         self.cs: CoordinateSystem = cs
         self.radius = radius
@@ -229,7 +233,7 @@ class Cyllinder(GeoVolume):
         xo, yo, zo = self.cs.in_global_cs(x.flatten(), y.flatten(), z.flatten())
         return xo, yo, zo
 
-class CoaxCyllinder(GeoVolume):
+class CoaxCylinder(GeoVolume):
     """A coaxial cylinder with an inner and outer radius."""
     
     def __init__(self, 
@@ -245,12 +249,12 @@ class CoaxCyllinder(GeoVolume):
 
         By default the coax uses the Open Cascade modeling for a cyllinder. In this representation
         the surface of the cyllinder is approximated with a tolerance thay may be irregular.
-        As an alternative, the argument Nsections may be provided in which case the Cyllinder is replaced
+        As an alternative, the argument Nsections may be provided in which case the Cylinder is replaced
         by an extrusion of a regular N-sided polygon.
 
         Args:
-            radius (float): The radius of the Cyllinder
-            height (float): The height of the Cyllinder
+            radius (float): The radius of the Cylinder
+            height (float): The height of the Cylinder
             cs (CoordinateSystem, optional): The coordinate system. Defaults to None.
             Nsections (int, optional): The number of sections. Defaults to None.
         """
@@ -263,8 +267,8 @@ class CoaxCyllinder(GeoVolume):
         self.rin = rin
         self.height = height
 
-        self.cyl_out = Cyllinder(rout, height, cs, Nsections=Nsections)
-        self.cyl_in = Cyllinder(rin, height, cs, Nsections=Nsections)
+        self.cyl_out = Cylinder(rout, height, cs, Nsections=Nsections)
+        self.cyl_in = Cylinder(rin, height, cs, Nsections=Nsections)
         self.cyl_in._exists = False
         self.cyl_out._exists = False
         cyltags, _ = gmsh.model.occ.cut(self.cyl_out.dimtags, self.cyl_in.dimtags)
@@ -273,6 +277,10 @@ class CoaxCyllinder(GeoVolume):
 
         self._add_face_pointer('front', cs.origin, -cs.zax.np)
         self._add_face_pointer('back', cs.origin+height*cs.zax.np, cs.zax.np)
+        self._add_face_pointer('bottom', cs.origin, -cs.zax.np)
+        self._add_face_pointer('top', cs.origin+height*cs.zax.np, cs.zax.np)
+        self._add_face_pointer('left', cs.origin, -cs.zax.np)
+        self._add_face_pointer('right', cs.origin+height*cs.zax.np, cs.zax.np)
 
         self.cs = cs
 
@@ -297,13 +305,28 @@ class HalfSphere(GeoVolume):
                  radius: float,
                  position: tuple = (0,0,0),
                  direction: tuple = (1,0,0)):
-        super().__init__([])
+        
         sphere = Sphere(radius, position=position)
         cx, cy, cz = position
 
-        box = Box(1.1*radius, 2.2*radius, 2.2*radius, position=(cx-radius*1.1,cy-radius*1.1, cz-radius*1.1))
+        dx, dy, dz = direction
+        fx = 0.5**dx
+        fy = 0.5**dy
+        fz = 0.5**dz
+        box = Box(2.2*radius*fx, 2.2*radius*fy, 2.2*radius*fz, position=(cx-radius*1.1*dx*0.5,cy-radius*1.1*dy*0.5, cz-radius*1.1*dz*0.5), alignment=Alignment.CENTER)
+        
+        dimtags, _ = gmsh.model.occ.cut(sphere.dimtags, box.dimtags)
+        
+        sphere._exists = False
+        box._exists = False
 
-        self.tag = subtract(sphere, box)[0].tag
+        super().__init__([dt[1] for dt in dimtags])
+        
+        self._add_face_pointer('front',np.array(position), np.array(direction))
+        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))
+        
 
 
 

emerge/_emerge/geometry.py

@@ -67,7 +67,13 @@ class _GeometryManager:
 
     def reset(self, modelname: str) -> None:
         self.geometry_list[modelname] = []
-        
+    
+    def lowest_priority(self) -> int:
+        return min([geo._priority for geo in self.all_geometries()])
+    
+    def highest_priority(self) -> int:
+        return min([geo._priority for geo in self.all_geometries()])
+    
 class _FacePointer:
     """The FacePointer class defines a face to be selectable as a
     face normal vector plus an origin. All faces of an object
@@ -387,6 +393,24 @@ class GeoObject:
         self._priority -= 1
         return self
 
+    def background(self) -> GeoObject:
+        """Set the priority to be on the background.
+
+        Returns:
+            GeoObject: _description_
+        """
+        self._priority = _GEOMANAGER.lowest_priority()-10
+        return self
+
+    def foreground(self) -> GeoObject:
+        """Set the priority to be on top.
+
+        Returns:
+            GeoObject: _description_
+        """
+        self._priority = _GEOMANAGER.highest_priority()+10
+        return self
+    
     def outside(self, *exclude: FaceNames, tags: list[int] | None = None) -> FaceSelection:
         """Returns the complete set of outside faces.
 
@@ -398,6 +422,8 @@ class GeoObject:
         """
         if tags is None:
             tags = []
+        for name in exclude:
+            tags.extend(self.face(name).tags)
         dimtags = gmsh.model.get_boundary(self.dimtags, True, False)
         return FaceSelection([t for d,t in dimtags if t not in tags])
     

emerge/_emerge/howto.py

@@ -27,11 +27,11 @@ class _HowtoClass:
         """
         To start a simulation simply create a model object through:
 
-        >>> model = emerge.Simulation3D('MyProjectName')
+        >>> model = emerge.Simulation('MyProjectName')
 
         Optionally, you can use a context manager for a more explicit handling of exiting the GMSH api and storing data after simulations.
 
-        >>> with emerge.Simulation3D('MyProjectName') as model:
+        >>> with emerge.Simulation('MyProjectName') as model:
 
         """
         pass
@@ -45,7 +45,7 @@ class _HowtoClass:
         >>> sphere = emerge.geo.Sphere(...)
         >>> pcb_layouter = emerge.geo.PCBLayout(...)
         >>> plate = emerge.geo.Plate(...)
-        >>> cyl = emerge.geo.Cyllinder(...)
+        >>> cyl = emerge.geo.Cylinder(...)
 
         After making geometries, you should pass all of them to
         the simulation object
@@ -77,7 +77,7 @@ class _HowtoClass:
         >>> face = cutout.face('front', tool=box)
         
         Exclusions or specific isolations can be added with optional arguments.
-        There is also a select object in your Simulation3D class that has various convenient selection options
+        There is also a select object in your Simulation class that has various convenient selection options
         >>> faces = model.select.face.inlayer()
         >>> faces = model.select.inplane()
         >>> faces = model.select.face.near(x,y,z)
@@ -99,15 +99,15 @@ class _HowtoClass:
 
         """
 
-    def run_frequency_domain(self):
+    def run_sweep(self):
         """
         You can run a frequency domain study by simply calling:\
         
-        >>> results = model.mw.frequency_domain(...)
+        >>> results = model.mw.run_sweep(...)
 
         You can distribute your frequency sweep across multiple threads using
         
-        >>> results = model.mw.frequency_domain(parallel=True, njobs=3)
+        >>> results = model.mw.run_sweep(parallel=True, njobs=3)
 
         The frequency domain study will return an MWSimData object that contains all data.
         """
@@ -154,7 +154,7 @@ class _HowtoClass:
     def save_and_load(self):
         """
         You can save your project data by setting save_file to True:
-        >>> model = emerge.Simulation3D(..., save_file=True)
+        >>> model = emerge.Simulation(..., save_file=True)
 
         Whenever you want, you can save all data by calling the .save() method
 
@@ -166,7 +166,7 @@ class _HowtoClass:
         
         You can load the data from a simulation using:
 
-        >>> model = emerge.Simulation3D(..., load_file=True)
+        >>> model = emerge.Simulation(..., load_file=True)
 
         The data from a simulation can be found in:
 

emerge/_emerge/material.py

@@ -18,6 +18,7 @@
 import numpy as np
 from dataclasses import dataclass
 from typing import Callable
+
 @dataclass
 class Material:
     """The Material class generalizes a material in the EMerge FEM environment.