emerge 0.5.2__py3-none-any.whl → 0.5.3__py3-none-any.whl

emerge/_emerge/simmodel.py

@@ -51,11 +51,9 @@ Known problems/solutions:
 --------------------------
 """
 
-
 class SimulationError(Exception):
     pass
 
-
 ############################################################
 #                 BASE 3D SIMULATION MODEL                 #
 ############################################################
@@ -93,7 +91,6 @@ class Simulation3D:
         
         self.mesh: Mesh3D = Mesh3D(self.mesher)
         self.select: Selector = Selector()
-        self.set_loglevel(loglevel)
 
         ## STATES
         self.__active: bool = False
@@ -102,9 +99,6 @@ class Simulation3D:
 
         self.display: PVDisplay = PVDisplay(self.mesh)
 
-        if logfile:
-            self.set_logfile()
-
         self.save_file: bool = save_file
         self.load_file: bool = load_file
 
@@ -115,6 +109,10 @@ class Simulation3D:
 
         self._initialize_simulation()
 
+        self.set_loglevel(loglevel)
+        if logfile:
+            self.set_logfile()
+
         self._update_data()
     
 
@@ -286,6 +284,8 @@ class Simulation3D:
             loglevel ('DEBUG','INFO','WARNING','ERROR'): The loglevel
         """
         LOG_CONTROLLER.set_std_loglevel(loglevel)
+        if loglevel not in ('TRACE','DEBUG'):
+            gmsh.option.setNumber("General.Terminal", 0)
 
     def set_logfile(self) -> None:
         """Adds a file output for the logger."""
@@ -318,7 +318,6 @@ class Simulation3D:
 
         return None
         
-    
     def set_periodic_cell(self, cell: PeriodicCell, excluded_faces: list[FaceSelection] | None = None):
         """Set the given periodic cell object as the simulations peridicity.
 
@@ -332,7 +331,7 @@ class Simulation3D:
     def commit_geometry(self, *geometries: GeoObject | list[GeoObject]) -> None:
         """Finalizes and locks the current geometry state of the simulation.
 
-        The geometries may be provided (legacy behavior) but are automatically managed underwater.
+        The geometries may be provided (legacy behavior) but are automatically managed in the background.
         
         """
         geometries_parsed: Any = None
@@ -375,7 +374,12 @@ class Simulation3D:
         self.mesher.set_mesh_size(self.mw.get_discretizer(), self.mw.resolution)
         
         try:
+            gmsh.logger.start()
             gmsh.model.mesh.generate(3)
+            logs = gmsh.logger.get()
+            gmsh.logger.stop()
+            for log in logs:
+                logger.trace('[GMSH] '+log)
         except Exception:
             logger.error('GMSH Mesh error detected.')
             print(_GMSH_ERROR_TEXT)

emerge/_emerge/simulation_data.py

@@ -18,7 +18,7 @@
 from __future__ import annotations
 import numpy as np
 from loguru import logger
-from typing import TypeVar, Generic, Any, List, Union, Dict
+from typing import TypeVar, Generic, Any, List, Union, Dict, Generator
 from collections import defaultdict
 
 T = TypeVar("T")
@@ -187,6 +187,10 @@ class DataContainer:
         self.entries.append(entry)
         return entry
     
+    def iterate(self) -> Generator[tuple[dict[str, float], dict[str, Any]], None, None]:
+        for entry in self.entries:
+            yield entry.vars, entry.data
+
     @property
     def last(self) -> DataEntry:
         """Returns the last added entry"""

emerge/_emerge/solve_interfaces/cudss_interface.py

@@ -0,0 +1,238 @@
+# EMerge is an open source Python based FEM EM simulation module.
+# Copyright (C) 2025  Robert Fennis.
+
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, see
+# <https://www.gnu.org/licenses/>.
+
+import cupy as cp # ty: ignore
+import nvmath.bindings.cudss as cudss # ty: ignore
+from nvmath import CudaDataType # ty: ignore
+
+from scipy.sparse import csr_matrix
+import numpy as np
+
+from loguru import logger
+
+
+############################################################
+#                         CONSTANTS                        #
+############################################################
+
+ALG_NEST_DISS_METIS = cudss.AlgType.ALG_DEFAULT
+ALG_COLAMD = cudss.AlgType.ALG_1
+ALG_COLAMD_BLOCK_TRI = cudss.AlgType.ALG_2
+ALG_AMD = cudss.AlgType.ALG_3
+
+FLOAT64 = CudaDataType.CUDA_R_64F
+FLOAT32 = CudaDataType.CUDA_R_32F
+COMPLEX128 = CudaDataType.CUDA_C_64F
+COMPLEX64 = CudaDataType.CUDA_C_32F
+INT64 = CudaDataType.CUDA_R_64I
+INT32 = CudaDataType.CUDA_R_32I
+
+INDEX_BASE = cudss.IndexBase.ZERO
+
+def _c_pointer(arry) -> int:
+    return int(arry.data.ptr)
+
+############################################################
+#                         INTERFACE                        #
+############################################################
+
+class CuDSSInterface:
+    def __init__(self):
+        self.A_cu = None
+        self.b_cu = None
+        self.x_cu = None
+        self.A_cobj = None
+        self.b_cobj = None
+        self.x_cobj = None
+        self.A_pattern = None
+
+        self._handle = cudss.create()
+        self._config = cudss.config_create()
+        self._data = cudss.data_create(self._handle)
+
+        self.MTYPE = cudss.MatrixType.SYMMETRIC
+        self.MVIEW = cudss.MatrixViewType.FULL
+        self.RALG = cudss.AlgType.ALG_DEFAULT
+        self.VTYPE = CudaDataType.CUDA_R_64F
+
+        self._INDPTR = None
+        self._ROW_START: int | None = None
+        self._ROW_END: int | None = None
+        self._IND = None
+        self._VAL = None
+        self._NNZ: int | None = None
+        self._COMP: bool = True
+        self._PRES: int = 2
+        self._COL_IDS = None
+
+        self._initialized = False
+
+        param = cudss.ConfigParam.REORDERING_ALG
+        dtype = cudss.get_config_param_dtype(int(param))
+        reorder_alg = np.array(self.RALG, dtype=dtype)
+
+        cudss.config_set(
+            self._config,   
+            int(param),
+            reorder_alg.ctypes.data, 
+            reorder_alg.nbytes
+        )
+
+    def set_algorithm(self, alg_type: cudss.AlgType):
+        self.RALG = alg_type
+    
+    def init_type(self):
+        if self._PRES == 1:
+            if self._COMP:
+                self.c_dtype = cp.complex64
+                self.VTYPE = COMPLEX64
+            else:
+                self.c_dtype = cp.float32
+                self.VTYPE = FLOAT32
+        else:
+            if self._COMP:
+                self.c_dtype = cp.complex128
+                self.VTYPE = COMPLEX128
+            else:
+                self.c_dtype = cp.float64
+                self.VTYPE = FLOAT64
+
+    def submit_matrix(self, A: csr_matrix):
+        self.N = A.shape[0]
+
+        if np.iscomplexobj(A):
+            self._COMP = True
+        else:
+            self._COMP = False
+        
+        self.init_type()
+
+        self.A_cu = cp.sparse.csr_matrix(A).astype(self.c_dtype)
+
+        self._INDPTR = cp.ascontiguousarray(self.A_cu.indptr.astype(cp.int32))
+        self._IND = cp.ascontiguousarray(self.A_cu.indices.astype(cp.int32))
+        self._VAL = cp.ascontiguousarray(self.A_cu.data)
+        self._NNZ = int(self._VAL.size)
+        self._ROW_START = self._INDPTR[:-1]
+        self._ROW_END = self._INDPTR[1:]
+        self._COL_IDS = self.A_cu.indices.astype(cp.int32)
+
+    def submit_vector(self, b: np.ndarray):
+        self.b_cu = cp.array(b).astype(self.c_dtype)
+    
+    def create_solvec(self):
+        self.x_cu = cp.empty_like(self.b_cu)
+
+    def _update_dss_data(self):
+        cudss.matrix_set_values(self.A_cobj, _c_pointer(self._VAL))
+
+        
+        self.b_cobj = cudss.matrix_create_dn(self.N, 1, self.N, _c_pointer(self.b_cu),
+                                    int(self.VTYPE), int(cudss.Layout.COL_MAJOR))
+        self.x_cobj = cudss.matrix_create_dn(self.N, 1, self.N, _c_pointer(self.x_cu),
+                                    int(self.VTYPE), int(cudss.Layout.COL_MAJOR))
+
+    def _create_dss_data(self):
+        self.A_cobj = cudss.matrix_create_csr(
+            self.N,self.N,self._NNZ,
+            _c_pointer(self._ROW_START),
+            _c_pointer(self._ROW_END),
+            _c_pointer(self._COL_IDS),
+            _c_pointer(self._VAL),
+            int(INT32), 
+            int(self.VTYPE),
+            int(self.MTYPE),
+            int(self.MVIEW),
+            int(INDEX_BASE),
+        )
+
+        self.b_cobj = cudss.matrix_create_dn(self.N, 1, self.N, _c_pointer(self.b_cu),
+                                    int(self.VTYPE), int(cudss.Layout.COL_MAJOR))
+        self.x_cobj = cudss.matrix_create_dn(self.N, 1, self.N, _c_pointer(self.x_cu),
+                                    int(self.VTYPE), int(cudss.Layout.COL_MAJOR))
+
+    def from_symbolic(self, A: csr_matrix, b: np.ndarray) -> np.ndarray:
+        """Solves Ax=b starting from the symbolic factorization
+
+        Args:
+            A (csr_matrix): The input sparse matrix
+            b (np.ndarray): The solution vector b
+
+        Returns:
+            np.ndarray: The solved vector
+        """
+        self.submit_matrix(A)
+        self.submit_vector(b)
+        self.create_solvec()
+        self._create_dss_data()
+        self._symbolic()
+        self._numeric(False)
+        return self._solve()
+
+    def from_numeric(self, A: csr_matrix, b: np.ndarray) -> np.ndarray:
+        """Solves Ax=b starting from the Numeric factorization
+
+        Args:
+            A (csr_matrix): The input sparse matrix
+            b (np.ndarray): The solution vector b
+
+        Returns:
+            np.ndarray: The solved vector
+        """
+        self.submit_matrix(A)
+        self.submit_vector(b)
+        self.create_solvec()
+        self._update_dss_data()
+        self._numeric(True)
+        return self._solve()
+
+    def from_solve(self, b: np.ndarray) -> np.ndarray:
+        """Solves Ax=b only with a new b vector.
+
+        Args:
+            A (csr_matrix): The input sparse matrix
+            b (np.ndarray): The solution vector b
+
+        Returns:
+            np.ndarray: The solved vector
+        """
+        self.submit_vector(b)
+        self.create_solvec()
+        return self._solve()
+
+    def _symbolic(self):
+        logger.trace('Executing symbolic factorization')
+        cudss.execute(self._handle, cudss.Phase.ANALYSIS, self._config, self._data, 
+                      self.A_cobj, self.x_cobj, self.b_cobj)
+
+    def _numeric(self, refactorize: bool = False):
+        if refactorize:
+            logger.trace('Refactoring matrix')
+            phase = cudss.Phase.REFACTORIZATION
+        else:
+            phase = cudss.Phase.FACTORIZATION
+        logger.trace('Executing numerical factorization')
+        cudss.execute(self._handle, phase, self._config, self._data, 
+                      self.A_cobj, self.x_cobj, self.b_cobj)
+                      
+    def _solve(self) -> np.ndarray:
+        logger.trace('Solving matrix problem')
+        cudss.execute(self._handle, cudss.Phase.SOLVE, self._config, self._data, 
+                      self.A_cobj, self.x_cobj, self.b_cobj)
+        cp.cuda.runtime.deviceSynchronize()
+        x_host = cp.asnumpy(self.x_cu).ravel()
+        return x_host