emerge 1.0.1__tar.gz → 1.0.2__tar.gz

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

@@ -1,5 +1,5 @@
 [tool.bumpversion]
-current_version = "1.0.1"
+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.1 → emerge-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emerge
-Version: 1.0.1
+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
@@ -44,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]
 ```
 
@@ -55,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
 
@@ -90,6 +101,7 @@ To run this FEM library you need the following libraries
 Optional:
  - scikit-umfpack
  - cudss
+ - ezdxf
 
 ## Resources / Manual
 

{emerge-1.0.1 → 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.1 → emerge-1.0.2}/emerge/__init__.py

@@ -18,7 +18,7 @@ along with this program; if not, see
 """
 import os
 
-__version__ = "1.0.1"
+__version__ = "1.0.2"
 
 ############################################################
 #               HANDLE ENVIRONMENT VARIABLES              #
@@ -33,11 +33,10 @@ 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.1 → 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.1 → 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.1 → 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.1 → emerge-1.0.2}/emerge/_emerge/geo/pcb.py

@@ -958,6 +958,7 @@ class PCB:
                  stack: list[PCBLayer] = None,
                  name: str | None = None,
                  trace_thickness: float | None = None,
+                 zs: np.ndarray | None = None
                  ):
         """Creates a new PCB layout class instance
 
@@ -975,8 +976,11 @@ class PCB:
 
         self.thickness: float = thickness
         self._stack: list[PCBLayer] = []
-        
-        if stack is not None:
+        if zs is not None:
+            self._zs = zs
+            self.thickness = np.max(zs)-np.min(zs)
+            self._stack = [PCBLayer(th, material) for th in np.diff(self._zs)]
+        elif stack is not None:
             self._stack = stack
             ths = [ly.th for ly in stack]
             zbot = -sum(ths)

{emerge-1.0.1 → emerge-1.0.2}/emerge/_emerge/geo/pcb_tools/dxf.py

@@ -325,8 +325,9 @@ def import_dxf(filename: str,
                unit: float | None = None,
                cs: CoordinateSystem | None = GCS,
                trace_material: Material = PEC) -> PCB:
+    
     polies = extract_polygons_with_meta(filename)
-    prop = inspect_pcb_from_dxf('LP5G_Chb3.dxf')
+    prop = inspect_pcb_from_dxf(filename)
     
     if prop['units']['name'] == 'unitless':
         if unit is None:
@@ -335,7 +336,7 @@ def import_dxf(filename: str,
     else:
         pcb_unit = 0.001 * prop['units']['to_mm']
     
-    if prop['thickness']==0.0:
+    if prop['thickness'] == 0.0:
         if thickness is None:
             raise RouteException(f'Cannot generate PCB because no thickness is found int he DXF file and none is provided in the import_dxf function.')
         pcb_thickness = thickness
@@ -346,7 +347,7 @@ def import_dxf(filename: str,
         cs = GCS
     
     zs = sorted(list(set([pol['z'] for pol in polies])))
-    pcb = PCB(pcb_thickness, pcb_unit, cs, material=material, trace_material=trace_material, _zs=zs)
+    pcb = PCB(pcb_thickness, pcb_unit, cs, material=material, trace_material=trace_material)
     
     for poly in polies:
         xs, ys = zip(*poly['ring'])

{emerge-1.0.1 → emerge-1.0.2}/emerge/_emerge/geo/polybased.py

@@ -24,66 +24,7 @@ from typing import Generator, Callable
 from ..selection import FaceSelection
 from typing import Literal
 from functools import reduce
-from numba import njit
 
-@njit(cache=True)
-def _subsample_coordinates(xs: np.ndarray, ys: np.ndarray, tolerance: float, xmin: float) -> tuple[np.ndarray, np.ndarray]:
-    """This function takes a set of x and y coordinates in a finely sampled set and returns a reduced
-    set of numbers that traces the input curve within a provided tolerance.
-
-    Args:
-        xs (np.ndarray): The set of X-coordinates
-        ys (np.ndarray): The set of Y-coordinates
-        tolerance (float): The maximum deviation of the curve in meters
-        xmin (float): The minimal distance to the next point.
-
-    Returns:
-        np.ndarray: The output X-coordinates
-        np.ndarray: The output Y-coordinates
-    """
-    N = xs.shape[0]
-    ids = np.zeros((N,), dtype=np.int32)
-    store_index = 1
-    start_index = 0
-    final_index = 0
-    for iteration in range(N):
-        i1 = start_index
-        done = 0
-        for i2 in range(i1+1,N):
-            x_true = xs[i1:i2+1]
-            y_true = ys[i1:i2+1]
-
-            x_f = np.linspace(xs[i1],xs[i2], i2-i1+1)
-            y_f = np.linspace(ys[i1],ys[i2], i2-i1+1)
-            error = np.max(np.sqrt((x_f-x_true)**2 + (y_f-y_true)**2))
-            ds = np.sqrt((xs[i2]-xs[i1])**2 + (ys[i2]-ys[i1])**2)
-            # If at the end
-            if i2==N-1: 
-                ids[store_index] = i2-1
-                final_index = store_index + 1
-                done = 1
-                break
-            # If not yet past the minimum distance, accumulate more
-            if ds < xmin:
-                continue
-            # If the end is less than a minimum distance
-            if np.sqrt((ys[-1]-ys[i2])**2 + (xs[-1]-xs[i2])**2) < xmin:
-                imid = i1 + (N-1-i1)//2
-                ids[store_index] = imid
-                ids[store_index+1] = N-1
-                final_index = store_index + 2
-                done = 1
-                break
-            if error < tolerance:
-                continue
-            else:
-                ids[store_index] = i2-1
-                start_index = i2
-                store_index = store_index + 1
-                break
-        if done==1:
-            break
-    return xs[ids[0:final_index]], ys[ids[0:final_index]]
 
 def _discretize_curve(xfunc: Callable, yfunc: Callable, 
                       t0: float, t1: float, xmin: float, tol: float=1e-4) -> tuple[np.ndarray, np.ndarray]:
@@ -100,6 +41,8 @@ def _discretize_curve(xfunc: Callable, yfunc: Callable,
     Returns:
         tuple[np.ndarray, np.ndarray]: _description_
     """
+    from ..mth.optimized import _subsample_coordinates
+    
     td = np.linspace(t0, t1, 10001)
     xs = xfunc(td)
     ys = yfunc(td)

{emerge-1.0.1 → emerge-1.0.2}/emerge/_emerge/mesh3d.py

@@ -18,25 +18,14 @@
 from __future__ import annotations
 import gmsh # type: ignore
 import numpy as np
-from numba import njit, f8 # type: ignore
 from .mesher import Mesher
 from typing import Union, List, Tuple, Callable, Any
 from collections import defaultdict
 from .geometry import GeoVolume
-from .mth.optimized import outward_normal
 from loguru import logger
-from functools import cache
 from .bc import Periodic
-from .mth.pairing import pair_coordinates
 from .material import Material
 
-@njit(f8(f8[:], f8[:], f8[:]), cache=True, nogil=True)
-def area(x1: np.ndarray, x2: np.ndarray, x3: np.ndarray):
-    e1 = x2 - x1
-    e2 = x3 - x1
-    av = np.array([e1[1]*e2[2] - e1[2]*e2[1], e1[2]*e2[0] - e1[0]*e2[2], e1[0]*e2[1] - e1[1]*e2[0]])
-    return np.sqrt(av[0]**2 + av[1]**2 + av[2]**2)/2
-
 def shortest_distance(point_cloud):
     """
     Compute the shortest distance between any two points in a 3D point cloud.
@@ -172,7 +161,7 @@ class Mesh3D(Mesh):
     def n_nodes(self) -> int:
         '''Return the number of nodes'''
         return self.nodes.shape[1]
-
+    
     def get_edge(self, i1: int, i2: int, skip: bool = False) -> int:
         '''Return the edge index given the two node indices'''
         if i1==i2:
@@ -204,21 +193,6 @@ class Mesh3D(Mesh):
         if output is None:
             raise ValueError(f'There is no tetrahedron with indices {i1}, {i2}, {i3}, {i4}')
         return output
-    
-    def boundary_triangles(self, dimtags: list[tuple[int, int]] | None = None) -> np.ndarray:
-        if dimtags is None:
-            outputtags = []
-            for tags in self.ftag_to_tri.values():
-                outputtags.extend(tags)
-            return np.array(outputtags)
-        else:
-            dts = []
-            for dimtag in dimtags:
-                if dimtag[0]==2:
-                    dts.append(dimtag)
-                elif dimtag[0]==3:
-                    dts.extend(gmsh.model.get_boundary(dimtags))
-            return self.get_triangles([tag[1] for tag in dts])
         
 
     def get_tetrahedra(self, vol_tags: Union[int, list[int]]) -> np.ndarray:
@@ -317,7 +291,16 @@ class Mesh3D(Mesh):
         return np.array(sorted(list(set(edges))))
     
     
-    def update(self, periodic_bcs: list[Periodic] | None = None):
+    def _pre_update(self, periodic_bcs: list[Periodic] | None = None):
+        """Builds the mesh data properties
+
+        Args:
+            periodic_bcs (list[Periodic] | None, optional): A list of periodic boundary conditions. Defaults to None.
+
+        Returns:
+            None: None
+        """
+        from .mth.optimized import area
         
         logger.trace('Generating mesh data.')
         if periodic_bcs is None:
@@ -357,7 +340,7 @@ class Mesh3D(Mesh):
     
         for bc in periodic_bcs:
             logger.trace(f'reassigning ordered node numbers for periodic boundary {bc}')
-            nodemap, ids1, ids2 = self._derive_node_map(bc)
+            nodemap, ids1, ids2 = self._pre_derive_node_map(bc)
             nodemap = {int(a): int(b) for a,b in nodemap.items()}
             self.nodes[:,ids2] = self.nodes[:,ids1]
             for itet in range(self.tets.shape[1]):
@@ -508,6 +491,11 @@ class Mesh3D(Mesh):
 
         self.defined = True
         
+
+        ############################################################
+        #                            GMSH CACHE                   #
+        ############################################################
+
         for dim in (0,1,2,3):
             dts= gmsh.model.get_entities(dim)
             for dt in dts:
@@ -519,7 +507,7 @@ class Mesh3D(Mesh):
 
     ## Higher order functions
 
-    def _derive_node_map(self, bc: Periodic) -> tuple[dict[int, int], np.ndarray, np.ndarray]:
+    def _pre_derive_node_map(self, bc: Periodic) -> tuple[dict[int, int], np.ndarray, np.ndarray]:
         """Computes an old to new node index mapping that preserves global sorting
 
         Since basis function field direction is based on the order of indices in tetrahedron
@@ -534,6 +522,8 @@ class Mesh3D(Mesh):
             tuple[dict[int, int], np.ndarray, np.ndarray]: The node index mapping and the node index arrays
         """
 
+        from .mth.pairing import pair_coordinates
+        
         node_ids_1 = []
         node_ids_2 = []
 
@@ -566,7 +556,7 @@ class Mesh3D(Mesh):
         return conv_map, np.array(node_ids_2_unsorted), np.array(node_ids_2_sorted)
 
 
-    def retreive(self, volumes: list[GeoVolume]) -> list[Material]:
+    def _get_material_assignment(self, volumes: list[GeoVolume]) -> list[Material]:
         '''Retrieve the material properties of the geometry'''
         #arry = np.zeros((3,3,self.n_tets,), dtype=np.complex128)
         for vol in volumes:
@@ -818,6 +808,8 @@ class SurfaceMesh(Mesh):
     def update(self) -> None:
         ## First Edges
 
+        from .mth.optimized import outward_normal, area
+        
         edges = set()
         for i in range(self.n_tris):
             i1, i2, i3 = self.tris[:,i]

{emerge-1.0.1/emerge/_emerge → emerge-1.0.2/emerge/_emerge/mth}/_cache_check.py

@@ -15,12 +15,12 @@
 # along with this program; if not, see
 # <https://www.gnu.org/licenses/>.
 
-from numba.core import event, types
+from numba.core import event
 from numba import njit
 
 _COMPILE_MESSAGE = """
  [ EMERGE ]
-⚠  Numba is compiling optimized code; this may take a few minutes.
+⚠  Numba will be compiling optimized code in this first run; this may take a few minutes.
    • Additional functions may be compiled on-the-fly.
    • Compilation happens only once-subsequent runs load from cache.
    Please wait…"""

{emerge-1.0.1 → emerge-1.0.2}/emerge/_emerge/mth/optimized.py

@@ -17,8 +17,7 @@
 
 from numba import njit, f8, i8, types, c16
 import numpy as np
-
-
+from . import _cache_check
 
 ############################################################
 #             TRIANGLE GAUSS QUADRATURE POINTS            #
@@ -446,4 +445,71 @@ def matmul(M: np.ndarray, vecs: np.ndarray):
     out[0,:] = M[0,0]*vecs[0,:] + M[0,1]*vecs[1,:] + M[0,2]*vecs[2,:]
     out[1,:] = M[1,0]*vecs[0,:] + M[1,1]*vecs[1,:] + M[1,2]*vecs[2,:]
     out[2,:] = M[2,0]*vecs[0,:] + M[2,1]*vecs[1,:] + M[2,2]*vecs[2,:]
-    return out
+    return out
+
+@njit(cache=True)
+def _subsample_coordinates(xs: np.ndarray, ys: np.ndarray, tolerance: float, xmin: float) -> tuple[np.ndarray, np.ndarray]:
+    """This function takes a set of x and y coordinates in a finely sampled set and returns a reduced
+    set of numbers that traces the input curve within a provided tolerance.
+
+    Args:
+        xs (np.ndarray): The set of X-coordinates
+        ys (np.ndarray): The set of Y-coordinates
+        tolerance (float): The maximum deviation of the curve in meters
+        xmin (float): The minimal distance to the next point.
+
+    Returns:
+        np.ndarray: The output X-coordinates
+        np.ndarray: The output Y-coordinates
+    """
+    N = xs.shape[0]
+    ids = np.zeros((N,), dtype=np.int32)
+    store_index = 1
+    start_index = 0
+    final_index = 0
+    for iteration in range(N):
+        i1 = start_index
+        done = 0
+        for i2 in range(i1+1,N):
+            x_true = xs[i1:i2+1]
+            y_true = ys[i1:i2+1]
+
+            x_f = np.linspace(xs[i1],xs[i2], i2-i1+1)
+            y_f = np.linspace(ys[i1],ys[i2], i2-i1+1)
+            error = np.max(np.sqrt((x_f-x_true)**2 + (y_f-y_true)**2))
+            ds = np.sqrt((xs[i2]-xs[i1])**2 + (ys[i2]-ys[i1])**2)
+            # If at the end
+            if i2==N-1: 
+                ids[store_index] = i2-1
+                final_index = store_index + 1
+                done = 1
+                break
+            # If not yet past the minimum distance, accumulate more
+            if ds < xmin:
+                continue
+            # If the end is less than a minimum distance
+            if np.sqrt((ys[-1]-ys[i2])**2 + (xs[-1]-xs[i2])**2) < xmin:
+                imid = i1 + (N-1-i1)//2
+                ids[store_index] = imid
+                ids[store_index+1] = N-1
+                final_index = store_index + 2
+                done = 1
+                break
+            if error < tolerance:
+                continue
+            else:
+                ids[store_index] = i2-1
+                start_index = i2
+                store_index = store_index + 1
+                break
+        if done==1:
+            break
+    return xs[ids[0:final_index]], ys[ids[0:final_index]]
+
+
+@njit(f8(f8[:], f8[:], f8[:]), cache=True, nogil=True)
+def area(x1: np.ndarray, x2: np.ndarray, x3: np.ndarray):
+    e1 = x2 - x1
+    e2 = x3 - x1
+    av = np.array([e1[1]*e2[2] - e1[2]*e2[1], e1[2]*e2[0] - e1[0]*e2[2], e1[0]*e2[1] - e1[1]*e2[0]])
+    return np.sqrt(av[0]**2 + av[1]**2 + av[2]**2)/2