emerge 1.0.0__tar.gz → 1.0.2__tar.gz

{emerge-1.0.0 → emerge-1.0.2}/.bumpversion.toml

@@ -1,5 +1,5 @@
 [tool.bumpversion]
-current_version = "1.0.0"
+current_version = "1.0.2"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]
 search = "{current_version}"

{emerge-1.0.0 → emerge-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emerge
-Version: 1.0.0
+Version: 1.0.2
 Summary: An open source EM FEM simulator in Python
 Project-URL: Homepage, https://github.com/FennisRobert/EMerge
 Project-URL: Issues, https://github.com/FennisRobert/EMerge/issues
@@ -20,6 +20,8 @@ Provides-Extra: cudss
 Requires-Dist: cupy-cuda12x; extra == 'cudss'
 Requires-Dist: nvidia-cudss-cu12; extra == 'cudss'
 Requires-Dist: nvmath-python[cu12]; extra == 'cudss'
+Provides-Extra: dxf
+Requires-Dist: ezdxf; extra == 'dxf'
 Provides-Extra: umfpack
 Requires-Dist: scikit-umfpack; (sys_platform != 'win32') and extra == 'umfpack'
 Description-Content-Type: text/markdown
@@ -42,8 +44,17 @@ pip install emerge
 On MacOS and Linux you can install it with the very fast UMFPACK through scikit-umfpack
 
 ```
-brew install swig suite-sparse #MacOS
+brew install cmake swig suite-sparse #MacOS
 sudo apt-get install libsuitesparse-dev #Linux
+```
+Then on MacOS do:
+```
+export PKG_CONFIG_PATH="/opt/homebrew/lib/pkgconfig:$PKG_CONFIG_PATH"
+export CFLAGS="-I/opt/homebrew/include"
+export LDFLAGS="-L/opt/homebrew/lib"
+```
+Finally:
+```
 pip install emerge[umfpack]
 ```
 
@@ -53,11 +64,13 @@ If you have a new NVidia card you can try the first test implementation of the c
 ```
 pip install emerge[cudss]
 ```
-The `scikit-umfpack` solver can be installed on Windows as well from binaries with conda. This is a bit more complicated and is described in the installation guide.
+The `scikit-umfpack` solver can be installed on Windows as well from binaries with conda. This is a bit more complicated and is described in the installation guide which can be downloaded from the official website: 
+
+https://www.emerge-software.com/resources
 
 ## Compatibility
 
-As far as I know, the library should work on all systems. PyPARDISO is not supported on ARM but the current SuperLU and UMFPACK solvers work on ARM as well. Both SuperLU and UMFPACK can run on multi-processing implementations as long as you do entry-point protection:
+As far as I know, the library should work on all systems. PARDISO is not supported on ARM but the current SuperLU and UMFPACK solvers work on ARM as well. Both SuperLU and UMFPACK can run on multi-processing implementations as long as you do entry-point protection:
 ```
 import emerge as em
 
@@ -88,6 +101,7 @@ To run this FEM library you need the following libraries
 Optional:
  - scikit-umfpack
  - cudss
+ - ezdxf
 
 ## Resources / Manual
 

{emerge-1.0.0 → emerge-1.0.2}/README.md

@@ -16,8 +16,17 @@ pip install emerge
 On MacOS and Linux you can install it with the very fast UMFPACK through scikit-umfpack
 
 ```
-brew install swig suite-sparse #MacOS
+brew install cmake swig suite-sparse #MacOS
 sudo apt-get install libsuitesparse-dev #Linux
+```
+Then on MacOS do:
+```
+export PKG_CONFIG_PATH="/opt/homebrew/lib/pkgconfig:$PKG_CONFIG_PATH"
+export CFLAGS="-I/opt/homebrew/include"
+export LDFLAGS="-L/opt/homebrew/lib"
+```
+Finally:
+```
 pip install emerge[umfpack]
 ```
 
@@ -27,11 +36,13 @@ If you have a new NVidia card you can try the first test implementation of the c
 ```
 pip install emerge[cudss]
 ```
-The `scikit-umfpack` solver can be installed on Windows as well from binaries with conda. This is a bit more complicated and is described in the installation guide.
+The `scikit-umfpack` solver can be installed on Windows as well from binaries with conda. This is a bit more complicated and is described in the installation guide which can be downloaded from the official website: 
+
+https://www.emerge-software.com/resources
 
 ## Compatibility
 
-As far as I know, the library should work on all systems. PyPARDISO is not supported on ARM but the current SuperLU and UMFPACK solvers work on ARM as well. Both SuperLU and UMFPACK can run on multi-processing implementations as long as you do entry-point protection:
+As far as I know, the library should work on all systems. PARDISO is not supported on ARM but the current SuperLU and UMFPACK solvers work on ARM as well. Both SuperLU and UMFPACK can run on multi-processing implementations as long as you do entry-point protection:
 ```
 import emerge as em
 
@@ -62,6 +73,7 @@ To run this FEM library you need the following libraries
 Optional:
  - scikit-umfpack
  - cudss
+ - ezdxf
 
 ## Resources / Manual
 

{emerge-1.0.0 → emerge-1.0.2}/emerge/__init__.py

@@ -18,7 +18,7 @@ along with this program; if not, see
 """
 import os
 
-__version__ = "1.0.0"
+__version__ = "1.0.2"
 
 ############################################################
 #               HANDLE ENVIRONMENT VARIABLES              #
@@ -27,17 +27,16 @@ __version__ = "1.0.0"
 NTHREADS = "1"
 os.environ["EMERGE_STD_LOGLEVEL"] = os.getenv("EMERGE_STD_LOGLEVEL", default="INFO")
 os.environ["EMERGE_FILE_LOGLEVEL"] = os.getenv("EMERGE_FILE_LOGLEVEL", default="DEBUG")
-os.environ["OMP_NUM_THREADS"] = os.getenv("OMP_NUM_THREADS", default="4")
+os.environ["OMP_NUM_THREADS"] = os.getenv("OMP_NUM_THREADS", default="1")
 os.environ["MKL_NUM_THREADS"] = os.getenv("MKL_NUM_THREADS", default="4")
 os.environ["OPENBLAS_NUM_THREADS"] = NTHREADS
 os.environ["VECLIB_MAXIMUM_THREADS"] = NTHREADS
 os.environ["NUMEXPR_NUM_THREADS"] = NTHREADS
 
-
 ############################################################
 #                      IMPORT MODULES                     #
 ############################################################
-from ._emerge import _cache_check
+
 from ._emerge.logsettings import LOG_CONTROLLER
 from loguru import logger
 
@@ -54,8 +53,7 @@ from ._emerge.coord import Line
 from ._emerge import geo
 from ._emerge.selection import Selection, FaceSelection, DomainSelection, EdgeSelection
 from ._emerge.geometry import select
-from ._emerge.mth.common_functions import norm, coax_rout, coax_rin
-from ._emerge.physics.microwave.sc import stratton_chu
+#from ._emerge.mth.common_functions import norm, coax_rout, coax_rin
 from ._emerge.periodic import RectCell, HexCell
 from ._emerge.mesher import Algorithm2D, Algorithm3D
 from . import lib
@@ -65,10 +63,11 @@ howto = _HowtoClass()
 
 logger.debug('Importing complete!')
 
-
 ############################################################
 #                         CONSTANTS                        #
 ############################################################
 
 CENTER = geo.Alignment.CENTER
-CORNER = geo.Alignment.CORNER
+CORNER = geo.Alignment.CORNER
+EISO = lib.EISO
+EOMNI = lib.EOMNI

{emerge-1.0.0 → emerge-1.0.2}/emerge/_emerge/elements/femdata.py

@@ -19,9 +19,7 @@ from __future__ import annotations
 from ..mesh3d import Mesh3D
 import numpy as np
 from typing import Callable
-from scipy.sparse import csr_matrix # type: ignore
 
-from ..mth.optimized import matmul
 
 class FEMBasis:
 
@@ -48,6 +46,8 @@ class FEMBasis:
     
     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.'''
+        from ..mth.optimized import matmul
+        
         if basis is None:
             basis = np.eye(3)
 
@@ -124,7 +124,8 @@ class FEMBasis:
         N = self.n_tri_dofs**2
         return slice(itri*N,(itri+1)*N)
     
-    def generate_csr(self, data: np.ndarray) -> csr_matrix:
+    def generate_csr(self, data: np.ndarray):
+        from scipy.sparse import csr_matrix # type: ignore
         ids = np.argwhere(data!=0)[:,0]
         return csr_matrix((data[ids], (self._rows[ids], self._cols[ids])), shape=(self.n_field, self.n_field))
     ### QUANTITIES

{emerge-1.0.0 → emerge-1.0.2}/emerge/_emerge/elements/nedelec2.py

@@ -19,9 +19,6 @@ from __future__ import annotations
 import numpy as np
 from ..mesh3d import Mesh3D
 from .femdata import FEMBasis
-from .ned2_interp import ned2_tet_interp, ned2_tet_interp_curl
-from ..mth.optimized import local_mapping
-from .index_interp import index_interp
 
 ############### Nedelec2 Class
 
@@ -72,6 +69,7 @@ class Nedelec2(FEMBasis):
         ''' 
         Interpolate the provided field data array at the given xs, ys and zs coordinates
         '''
+        from .ned2_interp import ned2_tet_interp
         if tetids is None:
             tetids = self._all_tet_ids
         vals = 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)
@@ -83,8 +81,11 @@ class Nedelec2(FEMBasis):
         """
         Interpolates the curl of the field at the given points.
         """
+        from .ned2_interp import ned2_tet_interp_curl
+        
         if tetids is None:
             tetids = self._all_tet_ids
+        
         vals = 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, tetids)
         if not usenan:
             vals = np.nan_to_num(vals)
@@ -97,7 +98,7 @@ class Nedelec2(FEMBasis):
                         usenan: bool = True) -> np.ndarray:
         if tetids is None:
             tetids = self._all_tet_ids
-
+        from .index_interp import index_interp
         vals = index_interp(np.array([xs, ys, zs]), self.mesh.tets, self.mesh.nodes, tetids)
         if not usenan:
             vals[vals==-1]==0
@@ -106,15 +107,18 @@ class Nedelec2(FEMBasis):
     ###### INDEX MAPPINGS
 
     def local_tet_to_triid(self, itet: int) -> np.ndarray:
+        from ..mth.optimized import local_mapping
         tri_ids = self.tet_to_field[6:10, itet] - self.n_edges
         global_tri_map = self.mesh.tris[:, tri_ids]
         return local_mapping(self.mesh.tets[:, itet], global_tri_map)
 
     def local_tet_to_edgeid(self, itet: int) -> np.ndarray:
+        from ..mth.optimized import local_mapping
         global_edge_map = self.mesh.edges[:, self.tet_to_field[:6,itet]]
         return local_mapping(self.mesh.tets[:, itet], global_edge_map)
 
     def local_tri_to_edgeid(self, itri: int) -> np.ndarray:
+        from ..mth.optimized import local_mapping
         global_edge_map = self.mesh.edges[:, self.tri_to_field[:3,itri]]
         return local_mapping(self.mesh.tris[:, itri], global_edge_map)
     

{emerge-1.0.0 → emerge-1.0.2}/emerge/_emerge/elements/nedleg2.py

@@ -19,8 +19,6 @@ from __future__ import annotations
 import numpy as np
 from ..mesh3d import SurfaceMesh
 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
 
@@ -74,6 +72,8 @@ class FieldFunctionClass:
         return np.array([Fx, Fy, Fz])*self.constant
     
     def calcE(self, xs: np.ndarray, ys: np.ndarray, usenan: bool = False) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        from .ned2_interp import ned2_tri_interp_full
+        
         coordinates = np.array([xs, ys])
         vals = ned2_tri_interp_full(coordinates, 
                                self.field, 
@@ -85,6 +85,7 @@ class FieldFunctionClass:
         return vals
     
     def calcH(self, xs: np.ndarray, ys: np.ndarray, usenan: bool = False) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        from .ned2_interp import ned2_tri_interp_curl
         coordinates = np.array([xs, ys])
         
         vals = ned2_tri_interp_curl(coordinates, 
@@ -176,6 +177,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.'''
+        from ..mth.optimized import matinv
         constant = 1j / ((k0*C0)*MU0)
         urinv = np.zeros_like(ur)
         
@@ -185,6 +187,7 @@ class NedelecLegrange2(FEMBasis):
         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, usenan: bool = False) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        from .ned2_interp import ned2_tri_interp_full
         coordinates = np.array([xs, ys])
         vals = ned2_tri_interp_full(coordinates, 
                                field, 
@@ -196,6 +199,7 @@ class NedelecLegrange2(FEMBasis):
         return vals
     
     def tri_interpolate_curl(self, field, xs: np.ndarray, ys: np.ndarray, diadic: np.ndarray | None = None, beta: float = 0.0, usenan: bool = False) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        from .ned2_interp import ned2_tri_interp_curl
         coordinates = np.array([xs, ys])
         if diadic is None:
             diadic = np.eye(3)[:,:,np.newaxis()] * np.ones((self.mesh.n_tris)) # type: ignore

{emerge-1.0.0 → emerge-1.0.2}/emerge/_emerge/geo/__init__.py

@@ -15,7 +15,7 @@
 # along with this program; if not, see
 # <https://www.gnu.org/licenses/>.
 
-from .pcb import PCB
+from .pcb import PCB, PCBLayer
 from .pmlbox import pmlbox
 from .horn import Horn
 from .shapes import Cylinder, CoaxCylinder, Box, XYPlate, HalfSphere, Sphere, Plate, OldBox, Alignment, Cone