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

emerge/_emerge/simmodel.py

@@ -27,12 +27,11 @@ from .plot.pyvista import PVDisplay
 from .dataset import SimulationDataset
 from .periodic import PeriodicCell
 from .bc import BoundaryCondition
-from typing import Literal, Type, Generator, Any
+from typing import Literal, Generator, Any
 from loguru import logger
 import numpy as np
-import sys
-import gmsh
-import joblib
+import gmsh # type: ignore
+import joblib # type: ignore
 import os
 import inspect
 from pathlib import Path
@@ -52,11 +51,9 @@ Known problems/solutions:
 --------------------------
 """
 
-
 class SimulationError(Exception):
     pass
 
-
 ############################################################
 #                 BASE 3D SIMULATION MODEL                 #
 ############################################################
@@ -94,18 +91,13 @@ class Simulation3D:
         
         self.mesh: Mesh3D = Mesh3D(self.mesher)
         self.select: Selector = Selector()
-        self.display: PVDisplay = None
-        self.set_loglevel(loglevel)
 
         ## STATES
         self.__active: bool = False
         self._defined_geometries: bool = False
-        self._cell: PeriodicCell = None
+        self._cell: PeriodicCell | None = None
 
-        self.display = PVDisplay(self.mesh)
-
-        if logfile:
-            self.set_logfile()
+        self.display: PVDisplay = PVDisplay(self.mesh)
 
         self.save_file: bool = save_file
         self.load_file: bool = load_file
@@ -117,6 +109,10 @@ class Simulation3D:
 
         self._initialize_simulation()
 
+        self.set_loglevel(loglevel)
+        if logfile:
+            self.set_logfile()
+
         self._update_data()
     
 
@@ -203,7 +199,9 @@ class Simulation3D:
         if self.save_file:
             self.save()
         # Finalize GMSH
-        gmsh.finalize()
+        if gmsh.isInitialized():
+            gmsh.finalize()
+
         logger.debug('GMSH Shut down successful')
         # set the state to active
         self.__active = False
@@ -214,28 +212,22 @@ class Simulation3D:
 
     def all_geometries(self) -> list[GeoObject]:
         """Returns all geometries stored in the simulation file."""
-        return [obj for obj in self.sim.default.values() if isinstance(obj, GeoObject)]
+        return [obj for obj in self.data.sim.default.values() if isinstance(obj, GeoObject)]
     
     def all_bcs(self) -> list[BoundaryCondition]:
         """Returns all boundary condition objects stored in the simulation file"""
-        return [obj for obj in self.sim.default.values() if isinstance(obj, BoundaryCondition)]
+        return [obj for obj in self.data.sim.default.values() if isinstance(obj, BoundaryCondition)]
     
     def _set_mesh(self, mesh: Mesh3D) -> None:
         """Set the current model mesh to a given mesh."""
         self.mesh = mesh
         self.mw.mesh = mesh
-        self.mesher.mesh = mesh
         self.display._mesh = mesh
     
     ############################################################
     #                       PUBLIC FUNCTIONS                  #
     ############################################################
 
-    @property
-    def passed_geometries(self) -> list[GeoObject]:
-        """"""
-        return self.data.sim['geometries']
-    
     def save(self) -> None:
         """Saves the current model in the provided project directory."""
         # Ensure directory exists
@@ -292,13 +284,15 @@ 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."""
         LOG_CONTROLLER.set_write_file(self.modelpath)
         
     def view(self, 
-             selections: list[Selection] = None, 
+             selections: list[Selection] | None = None, 
              use_gmsh: bool = False,
              volume_opacity: float = 0.1,
              surface_opacity: float = 1,
@@ -316,22 +310,15 @@ class Simulation3D:
             gmsh.model.occ.synchronize()
             gmsh.fltk.run()
             return
-        try:
-            for obj in self.data.sim['geometries']:
-                if obj.dim==2:
-                    opacity=surface_opacity
-                elif obj.dim==3:
-                    opacity=volume_opacity
-                self.display.add_object(obj, show_edges=show_edges, opacity=opacity)
-            if selections:
-                [self.display.add_object(sel, color='red', opacity=0.7) for sel in selections]
-            self.display.show()
-            return
-        except NotImplementedError as e:
-            logger.warning('The provided BaseDisplay class does not support object display. Please make' \
-            'sure that this method is properly implemented.')
-    
-    def set_periodic_cell(self, cell: PeriodicCell, excluded_faces: list[FaceSelection] = None):
+        for geo in _GEOMANAGER.all_geometries():
+            self.display.add_object(geo)
+        if selections:
+            [self.display.add_object(sel, color='red', opacity=0.7) for sel in selections]
+        self.display.show()
+
+        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.
 
         Args:
@@ -341,18 +328,20 @@ class Simulation3D:
         self.mw.bc._cell = cell
         self._cell = cell
 
-    def commit_geometry(self, *geometries: list[GeoObject]) -> None:
+    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
         if not geometries:
-            geometries = _GEOMANAGER.all_geometries()
+            geometries_parsed = _GEOMANAGER.all_geometries()
         else:
-            geometries = unpack_lists(geometries + tuple([item for item in self.data.sim.default.values() if isinstance(item, GeoObject)]))
-        self.data.sim['geometries'] = geometries
-        self.mesher.submit_objects(geometries)
+            geometries_parsed = unpack_lists(geometries + tuple([item for item in self.data.sim.default.values() if isinstance(item, GeoObject)]))
+        
+        self.data.sim['geometries'] = geometries_parsed
+        self.mesher.submit_objects(geometries_parsed)
         self._defined_geometries = True
         self.display._facetags = [dt[1] for dt in gmsh.model.get_entities(2)]
           
@@ -385,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)
@@ -438,9 +432,9 @@ class Simulation3D:
 
             logger.info(f'Iterating: {params}')
             if len(dims_flat)==1:
-                yield dims_flat[0][i_iter]
+                yield (dims_flat[0][i_iter],)
             else:
-                yield (dim[i_iter] for dim in dims_flat)
+                yield (dim[i_iter] for dim in dims_flat) # type: ignore
         self.mw.cache_matrices = True
 
     ############################################################

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")
@@ -84,7 +84,7 @@ def generate_ndim(
     outer_data: dict[str, list[float]],
     inner_data: list[float],
     outer_labels: tuple[str, ...]
-) -> np.ndarray:
+) -> tuple[np.ndarray,...]:
     """
     Generates an N-dimensional grid of values from flattened data, and returns each axis array plus the grid.
 
@@ -126,7 +126,7 @@ def generate_ndim(
     grid[tuple(idxs)] = values
 
     # Return each axis array followed by the grid
-    return (*axes, grid)
+    return tuple(axes) + (grid,)
 
 
 class DataEntry:
@@ -142,7 +142,7 @@ class DataEntry:
 
     def values(self) -> list[Any]:
         """ Return all values stored in the DataEntry"""
-        return self.data.values()
+        return list(self.data.values())
     
     def keys(self) -> list[str]:
         """ Return all names of data stored in the DataEntry"""
@@ -150,12 +150,15 @@ class DataEntry:
     
     def items(self) -> list[tuple[str, Any]]:
         """ Returns a list of all key: value pairs of the DataEntry."""
+        return list(self.data.items())
     
-    def __eq__(self, other: dict[str, float]) -> bool:
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, dict):
+            return False
         allkeys = set(list(self.vars.keys()) + list(other.keys()))
         return all(self.vars[key]==other[key] for key in allkeys)
     
-    def _dist(self, other: dict[str, float]) -> bool:
+    def _dist(self, other: dict[str, float]) -> float:
         return sum([(abs(self.vars.get(key,1e20)-other[key])/other[key]) for key in other.keys()])
     
     def __getitem__(self, key) -> Any:
@@ -184,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"""
@@ -218,18 +225,18 @@ class DataContainer:
     
 
 class BaseDataset(Generic[T,M]):
-    def __init__(self, datatype: T, matrixtype: M, scalar: bool):
+    def __init__(self, datatype: type[T], matrixtype: type[M], scalar: bool):
         self._datatype: type[T] = datatype
         self._matrixtype: type[M] = matrixtype
         self._variables: list[dict[str, float]] = []
         self._data_entries: list[T] = []
         self._scalar: bool = scalar
         
-        self._gritted: bool = None
-        self._axes: dict[str, np.ndarray] = None
-        self._ax_ids: dict[str, int] = None
-        self._ids: np.ndarray = None
-        self._gridobj: M = None
+        self._gritted: bool | None = None
+        self._axes: dict[str, np.ndarray]| None = None
+        self._ax_ids: dict[str, int]| None = None
+        self._ids: np.ndarray| None = None
+        self._gridobj: M | None = None
 
         self._data: dict[str, Any] = dict()
     
@@ -238,11 +245,11 @@ class BaseDataset(Generic[T,M]):
 
     @property
     def _fields(self) -> list[str]:
-        return self._datatype._fields
+        return self._datatype._fields # type: ignore
     
     @property
     def _copy(self) -> list[str]:
-        return self._datatype._copy
+        return self._datatype._copy # type: ignore
     
     def store(self, key: str, value: Any) -> None:
         """Stores a variable with some value in the provided key. 
@@ -335,7 +342,7 @@ class BaseDataset(Generic[T,M]):
         self._data_entries.append(new_entry)
         return new_entry
     
-    def _grid_axes(self) -> None:
+    def _grid_axes(self) -> bool:
         """This method attepmts to create a gritted version of the scalar dataset
 
         Returns:
@@ -405,7 +412,9 @@ class BaseDataset(Generic[T,M]):
         """
         if self._gritted is None:
             self._grid_axes()
+
         if self._gritted is False:
             logger.error('The dataset cannot be cast to a structured grid.')
             raise ValueError('Data not in regular grid')
+        
         return self._gridobj

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