emerge 0.6.7__py3-none-any.whl → 0.6.8__py3-none-any.whl

emerge/_emerge/physics/microwave/microwave_3d.py

@@ -269,7 +269,7 @@ class Microwave3D:
             Callable: The discretizer function
         """
         def disc(material: Material):
-            return 299792458/(max(self.frequencies) * np.real(material.neff))
+            return 299792458/(max(self.frequencies) * np.real(material.neff(max(self.frequencies))))
         return disc
     
     def _initialize_field(self):
@@ -467,10 +467,25 @@ class Microwave3D:
             raise SimulationError('Cannot proceed, the current basis class is undefined.')
 
         logger.debug('Retreiving material properties.')
-        ertet = self.mesh.retreive(lambda mat,x,y,z: mat.fer3d_mat(x,y,z), self.mesher.volumes)
-        urtet = self.mesh.retreive(lambda mat,x,y,z: mat.fur3d_mat(x,y,z), self.mesher.volumes)
-        condtet = self.mesh.retreive(lambda mat,x,y,z: mat.cond, self.mesher.volumes)[0,0,:]
+        
+        if freq is None:
+            freq = self.frequencies[0]
+        
+        materials = self.mesh.retreive(self.mesher.volumes)
 
+        ertet = np.zeros((3,3,self.mesh.n_tets), dtype=np.complex128)
+        tandtet = np.zeros((3,3,self.mesh.n_tets), dtype=np.complex128)
+        urtet = np.zeros((3,3,self.mesh.n_tets), dtype=np.complex128)
+        condtet = np.zeros((3,3,self.mesh.n_tets), dtype=np.complex128)
+        
+        for mat in materials:
+            ertet = mat.er(freq, ertet)
+            tandtet = mat.tand(freq, tandtet)
+            urtet = mat.ur(freq, urtet)
+            condtet = mat.cond(freq, condtet)
+        
+        ertet = ertet * (1-1j*tandtet)
+        
         er = np.zeros((3,3,self.mesh.n_tris,), dtype=np.complex128)
         ur = np.zeros((3,3,self.mesh.n_tris,), dtype=np.complex128)
         cond = np.zeros((self.mesh.n_tris,), dtype=np.complex128)
@@ -479,7 +494,7 @@ class Microwave3D:
             itet = self.mesh.tri_to_tet[0,itri]
             er[:,:,itri] = ertet[:,:,itet]
             ur[:,:,itri] = urtet[:,:,itet]
-            cond[itri] = condtet[itet]
+            cond[itri] = condtet[0,0,itet]
 
         itri_port = self.mesh.get_triangles(port.tags)
 
@@ -488,11 +503,7 @@ class Microwave3D:
         ermax = np.max(er[:,:,itri_port].flatten())
         urmax = np.max(ur[:,:,itri_port].flatten())
 
-        if freq is None:
-            freq = self.frequencies[0]
-        
         k0 = 2*np.pi*freq/299792458
-        kmax = k0*np.sqrt(ermax.real*urmax.real)
         
         Amatrix, Bmatrix, solve_ids, nlf = self.assembler.assemble_bma_matrices(self.basis, er, ur, cond, k0, port, self.bc)
         
@@ -511,8 +522,7 @@ class Microwave3D:
             else:
                 
                 target_kz = ermean*urmean*0.7*k0
-
-    
+                
         logger.debug(f'Solving for {solve_ids.shape[0]} degrees of freedom.')
 
         eigen_values, eigen_modes, report = self.solveroutine.eig_boundary(Amatrix, Bmatrix, solve_ids, nmodes, direct, target_kz, sign=-1)
@@ -550,12 +560,10 @@ class Microwave3D:
             Ez = np.max(np.abs(Efz))
             Exy = np.max(np.abs(Efxy))
             
-            # Exy = np.max(np.max(Emode))
-            # Ez = 0
-            if Ez/Exy < 1e-3 and not TEM:
+            if Ez/Exy < 1e-1 and not TEM:
                 logger.debug('Low Ez/Et ratio detected, assuming TE mode')
                 mode.modetype = 'TE'
-            elif Ez/Exy > 1e-3 and not TEM:
+            elif Ez/Exy > 1e-1 and not TEM:
                 logger.debug('High Ez/Et ratio detected, assuming TM mode')
                 mode.modetype = 'TM'
             elif TEM:
@@ -621,9 +629,7 @@ class Microwave3D:
         if self.basis is None:
             raise SimulationError('Cannot proceed, the simulation basis class is undefined.')
 
-        er = self.mesh.retreive(lambda mat,x,y,z: mat.fer3d_mat(x,y,z), self.mesher.volumes)
-        ur = self.mesh.retreive(lambda mat,x,y,z: mat.fur3d_mat(x,y,z), self.mesher.volumes)
-        cond = self.mesh.retreive(lambda mat,x,y,z: mat.cond, self.mesher.volumes)[0,0,:]
+        materials = self.mesh.retreive(self.mesher.volumes)
 
         ### Does this move
         logger.debug('Initializing frequency domain sweep.')
@@ -674,7 +680,8 @@ class Microwave3D:
             freq_groups = [self.frequencies[i:i+n] for i in range(0, len(self.frequencies), n)]
 
         results: list[SimJob] = []
-
+        matset: list[tuple[np.ndarray, np.ndarray, np.ndarray]] = []
+        
         ## Single threaded
         job_id = 1
 
@@ -691,7 +698,7 @@ class Microwave3D:
                     logger.debug(f'Simulation frequency = {freq/1e9:.3f} GHz') 
                     if automatic_modal_analysis:
                         self._compute_modes(freq)
-                    job = self.assembler.assemble_freq_matrix(self.basis, er, ur, cond, 
+                    job, mats = self.assembler.assemble_freq_matrix(self.basis, materials, 
                                                             self.bc.boundary_conditions, 
                                                             freq, 
                                                             cache_matrices=self.cache_matrices)
@@ -700,6 +707,7 @@ class Microwave3D:
                     job.id = job_id
                     job_id += 1
                     jobs.append(job)
+                    matset.append(mats)
                 
                 logger.info(f'Starting single threaded solve of {len(jobs)} jobs.')
                 group_results = [run_job_single(job) for job in jobs]
@@ -716,7 +724,7 @@ class Microwave3D:
                         logger.debug(f'Simulation frequency = {freq/1e9:.3f} GHz') 
                         if automatic_modal_analysis:
                             self._compute_modes(freq)
-                        job = self.assembler.assemble_freq_matrix(self.basis, er, ur, cond, 
+                        job, mats = self.assembler.assemble_freq_matrix(self.basis, materials, 
                                                                 self.bc.boundary_conditions, 
                                                                 freq, 
                                                                 cache_matrices=self.cache_matrices)
@@ -725,6 +733,7 @@ class Microwave3D:
                         job.id = job_id
                         job_id += 1
                         jobs.append(job)
+                        matset.append(mats)
                     
                     logger.info(f'Starting distributed solve of {len(jobs)} jobs with {njobs} threads.')
                     group_results = list(executor.map(run_job, jobs))
@@ -749,8 +758,8 @@ class Microwave3D:
                         if automatic_modal_analysis:
                             self._compute_modes(freq)
                         
-                        job = self.assembler.assemble_freq_matrix(
-                            self.basis, er, ur, cond,
+                        job, mats = self.assembler.assemble_freq_matrix(
+                            self.basis, materials,
                             self.bc.boundary_conditions,
                             freq,
                             cache_matrices=self.cache_matrices
@@ -761,6 +770,7 @@ class Microwave3D:
                         job.id = job_id
                         job_id += 1
                         jobs.append(job)
+                        matset.append(mats)
 
                     logger.info(
                         f'Starting distributed solve of {len(jobs)} jobs '
@@ -783,7 +793,7 @@ class Microwave3D:
 
         self.solveroutine.reset()
         ### Compute S-parameters and return
-        self._post_process(results, er, ur, cond)
+        self._post_process(results, matset)
         return self.data
     
     def eigenmode(self, search_frequency: float,
@@ -817,19 +827,21 @@ class Microwave3D:
         if self.basis is None:
             raise SimulationError('Cannot proceed. The simulation basis class is undefined.')
 
-        er = self.mesh.retreive(lambda mat,x,y,z: mat.fer3d_mat(x,y,z), self.mesher.volumes)
-        ur = self.mesh.retreive(lambda mat,x,y,z: mat.fur3d_mat(x,y,z), self.mesher.volumes)
-        cond = self.mesh.retreive(lambda mat,x,y,z: mat.cond, self.mesher.volumes)[0,0,:]
+        materials = self.mesh.retreive(self.mesher.volumes)
+        
+        # er = self.mesh.retreive(lambda mat,x,y,z: mat.fer3d_mat(x,y,z), self.mesher.volumes)
+        # ur = self.mesh.retreive(lambda mat,x,y,z: mat.fur3d_mat(x,y,z), self.mesher.volumes)
+        # cond = self.mesh.retreive(lambda mat,x,y,z: mat.cond, self.mesher.volumes)[0,0,:]
 
         ### Does this move
         logger.debug('Initializing frequency domain sweep.')
             
         logger.info(f'Pre-assembling matrices of {len(self.frequencies)} frequency points.')
         
-        job = self.assembler.assemble_eig_matrix(self.basis, er, ur, cond, 
+        job, matset = self.assembler.assemble_eig_matrix(self.basis, materials, 
                                                             self.bc.boundary_conditions, search_frequency)
         
-
+        er, ur, cond = matset
         logger.info('Solving complete')
 
         A, C, solve_ids = job.yield_AC()
@@ -846,7 +858,7 @@ class Microwave3D:
 
         for i in range(nmodes_found):
             
-            Emode = np.zeros((self.basis.n_field,), dtype=np.complex128)
+
             eig_k0 = np.sqrt(eigen_values[i])
             if eig_k0 < k0_limit:
                 logger.debug(f'Ignoring mode due to low k0: {eig_k0} < {k0_limit}')
@@ -856,11 +868,11 @@ class Microwave3D:
             logger.debug(f'Found k0={eig_k0:.2f}, f0={eig_freq/1e9:.2f} GHz')
             Emode = eigen_modes[:,i]
 
-            scalardata = self.data.scalar.new(freq=eig_freq, **self._params)
+            scalardata = self.data.scalar.new(**self._params)
             scalardata.k0 = eig_k0
             scalardata.freq = eig_freq
 
-            fielddata = self.data.field.new(freq=eig_freq, **self._params)
+            fielddata = self.data.field.new(**self._params)
             fielddata.freq = eig_freq
             fielddata._der = np.squeeze(er[0,0,:])
             fielddata._dur = np.squeeze(ur[0,0,:])
@@ -870,7 +882,7 @@ class Microwave3D:
         
         return self.data
 
-    def _post_process(self, results: list[SimJob], er: np.ndarray, ur: np.ndarray, cond: np.ndarray):
+    def _post_process(self, results: list[SimJob], materials: list[tuple[np.ndarray, np.ndarray, np.ndarray]]):
         """Compute the S-parameters after Frequency sweep
 
         Args:
@@ -888,18 +900,19 @@ class Microwave3D:
 
         logger.info('Computing S-parameters')
         
-        ertri = np.zeros((3,3,self.mesh.n_tris), dtype=np.complex128)
-        urtri = np.zeros((3,3,self.mesh.n_tris), dtype=np.complex128)
-        condtri = np.zeros((self.mesh.n_tris,), dtype=np.complex128)
-
-        for itri in range(self.mesh.n_tris):
-            itet = self.mesh.tri_to_tet[0,itri]
-            ertri[:,:,itri] = er[:,:,itet]
-            urtri[:,:,itri] = ur[:,:,itet]
-            condtri[itri] = cond[itet]
-
-        for freq, job in zip(self.frequencies, results):
 
+        for freq, job, mats in zip(self.frequencies, results, materials):
+            er, ur, cond = mats
+            ertri = np.zeros((3,3,self.mesh.n_tris), dtype=np.complex128)
+            urtri = np.zeros((3,3,self.mesh.n_tris), dtype=np.complex128)
+            condtri = np.zeros((self.mesh.n_tris,), dtype=np.complex128)
+
+            for itri in range(self.mesh.n_tris):
+                itet = self.mesh.tri_to_tet[0,itri]
+                ertri[:,:,itri] = er[:,:,itet]
+                urtri[:,:,itri] = ur[:,:,itet]
+                condtri[itri] = cond[0,0,itet]
+                
             k0 = 2*np.pi*freq/299792458
 
             scalardata = self.data.scalar.new(freq=freq, **self._params)

emerge/_emerge/physics/microwave/microwave_bc.py

@@ -73,7 +73,7 @@ class MWBoundaryConditionSet(BoundaryConditionSet):
         """
         bcs = self.oftype(PEC)
         for bc in self.oftype(SurfaceImpedance):
-            if bc.material.cond > 1e3:
+            if bc.sigma > 1e3:
                 bcs.append(bc)
 
         return bcs
@@ -1034,12 +1034,13 @@ class SurfaceImpedance(RobinBC):
         self._material: Material | None = material
         self._mur: float | complex = 1.0
         self._epsr: float | complex = 1.0
-
         self.sigma: float = 0.0
+        
         if material is not None:
             self.sigma = material.cond
             self._mur = material.ur
             self._epsr = material.er
+        
         if surface_conductance is not None:
             self.sigma = surface_conductance
         
@@ -1066,10 +1067,15 @@ class SurfaceImpedance(RobinBC):
         Returns:
             complex: The γ-constant
         """
+        
         w0 = k0*C0
-        sigma = self.sigma
+        f0 = w0/(2*np.pi)
+        sigma = self.sigma.scalar(f0)
+        mur = self._material.ur.scalar(f0)
+        er = self._material.er.scalar(f0)
+        
         rho = 1/sigma
-        d_skin = (2*rho/(w0*MU0*self._mur) * ((1+(w0*EPS0*self._epsr*rho)**2)**0.5 + rho*w0*EPS0*self._epsr))**0.5
+        d_skin = (2*rho/(w0*MU0*mur) * ((1+(w0*EPS0*er*rho)**2)**0.5 + rho*w0*EPS0*er))**0.5
         R = rho/d_skin
         if self._sr_model=='Hammerstad-Jensen' and self._sr > 0.0:
             R = R * (1 + 2/np.pi * np.arctan(1.4*(self._sr/d_skin)**2))

emerge/_emerge/physics/microwave/microwave_data.py

@@ -282,9 +282,9 @@ class FarFieldData:
     
     @property
     def Etheta(self) -> np.ndarray:
-        thx = -np.cos(self.theta)*np.cos(self.phi)
-        thy = -np.cos(self.theta)*np.sin(self.phi)
-        thz = np.sin(self.theta)
+        thx = np.cos(self.theta)*np.cos(self.phi)
+        thy = np.cos(self.theta)*np.sin(self.phi)
+        thz = -np.sin(self.theta)
         return thx*self.E[0,:] + thy*self.E[1,:] + thz*self.E[2,:]
     
     @property
@@ -296,11 +296,11 @@ class FarFieldData:
     
     @property
     def Erhcp(self) -> np.ndarray:
-        return (self.Etheta - 1j*self.Ephi)/np.sqrt(2)
+        return (self.Etheta + 1j*self.Ephi)/np.sqrt(2)
     
     @property
     def Elhcp(self) -> np.ndarray:
-        return (self.Etheta + 1j*self.Ephi)/np.sqrt(2)
+        return (self.Etheta - 1j*self.Ephi)/np.sqrt(2)
     
     @property
     def AR(self) -> np.ndarray:
@@ -702,6 +702,11 @@ class MWField:
     
     def interpolate(self, xs: np.ndarray, ys: np.ndarray, zs: np.ndarray) -> EHField:
         ''' Interpolate the dataset in the provided xs, ys, zs values'''
+        if isinstance(xs, (float, int, complex)):
+            xs = np.array([xs,])
+            ys = np.array([ys,])
+            zs = np.array([zs,])
+            
         shp = xs.shape
         xf = xs.flatten()
         yf = ys.flatten()
@@ -748,6 +753,7 @@ class MWField:
         xs = np.linspace(xb[0], xb[1], int((xb[1]-xb[0])/ds))
         ys = np.linspace(yb[0], yb[1], int((yb[1]-yb[0])/ds))
         zs = np.linspace(zb[0], zb[1], int((zb[1]-zb[0])/ds))
+        
         if x is not None:
             Y,Z = np.meshgrid(ys, zs)
             X = x*np.ones_like(Y)
@@ -759,6 +765,56 @@ class MWField:
             Z = z*np.ones_like(Y)
         return self.interpolate(X,Y,Z)
     
+    def cutplane_normal(self,
+             point=(0,0,0),
+             normal=(0,0,1),
+             npoints: int = 300) -> EHField:
+        """
+        Take a 2D slice of the field along an arbitrary plane.
+        Args:
+            point: (x0,y0,z0), a point on the plane
+            normal: (nx,ny,nz), plane normal vector
+            npoints: number of grid points per axis
+        """
+
+        n = np.array(normal, dtype=float)
+        n /= np.linalg.norm(n)
+        point = np.array(point) 
+
+        tmp = np.array([1,0,0]) if abs(n[0]) < 0.9 else np.array([0,1,0])
+        u = np.cross(n, tmp)
+        u /= np.linalg.norm(u)
+        v = np.cross(n, u)
+        
+        xb, yb, zb = self.basis.bounds
+        nx, ny, nz = 5, 5, 5
+        Xg = np.linspace(xb[0], xb[1], nx)
+        Yg = np.linspace(yb[0], yb[1], ny)
+        Zg = np.linspace(zb[0], zb[1], nz)
+        Xg, Yg, Zg = np.meshgrid(Xg, Yg, Zg, indexing='ij')
+        geometry = np.vstack([Xg.ravel(), Yg.ravel(), Zg.ravel()]).T  # Nx3
+        
+        rel_pts = geometry - point
+        S = rel_pts @ u
+        T = rel_pts @ v 
+        
+        margin = 0.01
+        s_min, s_max = S.min(), S.max()
+        t_min, t_max = T.min(), T.max()
+        s_bounds = (s_min - margin*(s_max-s_min), s_max + margin*(s_max-s_min))
+        t_bounds = (t_min - margin*(t_max-t_min), t_max + margin*(t_max-t_min))
+
+        S_grid = np.linspace(s_bounds[0], s_bounds[1], npoints)
+        T_grid = np.linspace(t_bounds[0], t_bounds[1], npoints)
+        S_mesh, T_mesh = np.meshgrid(S_grid, T_grid)
+
+        X = point[0] + S_mesh*u[0] + T_mesh*v[0]
+        Y = point[1] + S_mesh*u[1] + T_mesh*v[1]
+        Z = point[2] + S_mesh*u[2] + T_mesh*v[2]
+
+        return self.interpolate(X, Y, Z)
+    
+    
     def grid(self, ds: float) -> EHField:
         """Interpolate a uniform grid sampled at ds
 

emerge/_emerge/plot/pyvista/display.py

@@ -315,7 +315,6 @@ class PVDisplay(BaseDisplay):
         """The private callback function that stops the animation.
         """
         self._stop = True
-        print('CLOSE!')
 
     def _animate(self) -> None:
         """Private function that starts the animation loop.
@@ -567,6 +566,7 @@ class PVDisplay(BaseDisplay):
         grid = pv.StructuredGrid(x,y,z)
         field_flat = field.flatten(order='F')
 
+
         if scale=='log':
             T = lambda x: np.log10(np.abs(x))
         elif scale=='symlog':
@@ -582,25 +582,28 @@ class PVDisplay(BaseDisplay):
         self._ctr += 1
         grid[name] = static_field
 
+        grid_no_nan = grid.threshold(scalars=name)
+
+        # Determine color limits
         if clim is None:
-            fmin = np.min(static_field)
-            fmax = np.max(static_field)
+            fmin = np.nanmin(static_field)
+            fmax = np.nanmax(static_field)
             clim = (fmin, fmax)
-        
         if symmetrize:
-            lim = max(abs(clim[0]),abs(clim[1]))
+            lim = max(abs(clim[0]), abs(clim[1]))
             clim = (-lim, lim)
 
         kwargs = setdefault(kwargs, cmap=cmap, clim=clim, opacity=opacity, pickable=False, multi_colors=True)
-        actor = self._plot.add_mesh(grid, scalars=name, **kwargs)
+        actor = self._plot.add_mesh(grid_no_nan, scalars=name, **kwargs)
+
 
         if self._do_animate:
             def on_update(obj: _AnimObject, phi: complex):
-                field = obj.T(np.real(obj.field*phi))
-                obj.grid[name] = field
-            self._objs.append(_AnimObject(field_flat, T, grid, actor, on_update)) # type: ignore
-        
-        
+                field_anim = obj.T(np.real(obj.field * phi))
+                obj.grid[name] = field_anim
+            self._objs.append(_AnimObject(field_flat, T, grid_no_nan, actor, on_update))
+
+
     def add_title(self, title: str) -> None:
         """Adds a title
 
@@ -652,6 +655,11 @@ class PVDisplay(BaseDisplay):
         dx = dx.flatten().real
         dy = dy.flatten().real
         dz = dz.flatten().real
+        
+        ids = np.invert(np.isnan(dx))
+        
+        x, y, z, dx, dy, dz = x[ids], y[ids], z[ids], dx[ids], dy[ids], dz[ids]
+        
         dmin = _min_distance(x,y,z)
 
         dmax = np.max(_norm(dx,dy,dz))
@@ -667,8 +675,10 @@ class PVDisplay(BaseDisplay):
         kwargs = dict()
         if color is not None:
             kwargs['color'] = color
+            
         pl = self._plot.add_arrows(Coo, Vec, scalars=None, clim=None, cmap=None, **kwargs)
 
+        
     def add_contour(self,
                      X: np.ndarray,
                      Y: np.ndarray,

emerge/_emerge/plot/simple_plots.py

@@ -533,7 +533,7 @@ def plot_ff(
     dB: bool = False,
     labels: Optional[List[str]] = None,
     xlabel: str = "Theta (rad)",
-    ylabel: str = "|E|",
+    ylabel: str = "",
     linestyles: Union[str, List[str]] = "-",
     linewidth: float = 2.0,
     markers: Optional[Union[str, List[Optional[str]]]] = None,

emerge/_emerge/simmodel.py

@@ -245,13 +245,20 @@ class Simulation:
         vM, vm, vp = [float(x) for x in version.split('.')]
         cM, cm, cp = [float(x) for x in __version__.split('.')]
         if vM != cM:
-            raise VersionError(f"You are running a script designed for version {version} with a possibly incompatible version of EMerge {__version__}")
+            raise VersionError(f"You are running a script designed for version {version} with a possibly incompatible version of EMerge {__version__}. \n You can upgrade your version of emerge with: pip --upgrade emerge")
         if vm != cm:
-            raise VersionError(f"You are running a script designed for version {version} with a possibly incompatible version of EMerge {__version__}")
+            raise VersionError(f"You are running a script designed for version {version} with a possibly incompatible version of EMerge {__version__}. \n You can upgrade your version of emerge with: pip --upgrade emerge")
         if vp != cp:
-            logger.warning(f"You are running a script designed for version {version} with a possibly incompatible version of EMerge {__version__}")
+            logger.warning("You are running a script designed for a different version of EMerge.")
+            logger.warning(f"The script version: {version}")
+            logger.warning(f"EMerge version:     {__version__}")
+            logger.warning("Usually EMerge works without a problem but Errors may occur.")
+            logger.warning("You can upgrade your version of emerge with: pip --upgrade emerge")
             logger.warning("You may suppress this error by removing the call to .check_version().")
-            input('Press enter to proceed...')
+            logger.warning("Press Ctrl+C to abort.")
+            ans = input('Press enter to proceed or [Q] to quit:')
+            if ans.lower().strip()=='q':
+                quit()
 
     def save(self) -> None:
         """Saves the current model in the provided project directory."""
@@ -458,7 +465,7 @@ class Simulation:
 
             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) # type: ignore
         self.mw.cache_matrices = True

emerge/_emerge/solver.py

@@ -289,10 +289,14 @@ class Solver:
 
     def __init__(self):
         self.own_preconditioner: bool = False
+        self.initialized: bool = False
 
     def __str__(self) -> str:
         return f'{self.__class__.__name__}'
     
+    def initialize(self) -> None:
+        return None
+
     def duplicate(self) -> Solver:
         return self.__class__()
 
@@ -324,6 +328,9 @@ class EigSolver:
     def __init__(self):
         self.own_preconditioner: bool = False
 
+    def initialize(self) -> None:
+        return None
+
     def __str__(self) -> str:
         return f'{self.__class__.__name__}'
     
@@ -513,7 +520,19 @@ class SolverUMFPACK(Solver):
         super().__init__()
         self.A: np.ndarray = None
         self.b: np.ndarray = None
-        self.umfpack: um.UmfpackContext = um.UmfpackContext('zl')
+        
+        self.umfpack: um.UmfpackContext | None = None
+        
+        # SETTINGS
+        self._pivoting_threshold: float = 0.001
+
+        self.fact_symb: bool = False
+        self.initalized: bool = False
+
+    def initialize(self):
+        if self.initalized:
+            return
+        self.umfpack = um.UmfpackContext('zl')
         self.umfpack.control[um.UMFPACK_PRL] = 0 # ty: ignore
         self.umfpack.control[um.UMFPACK_IRSTEP] = 2 # ty: ignore
         self.umfpack.control[um.UMFPACK_STRATEGY] = um.UMFPACK_STRATEGY_SYMMETRIC # ty: ignore
@@ -522,21 +541,16 @@ class SolverUMFPACK(Solver):
         self.umfpack.control[um.UMFPACK_SYM_PIVOT_TOLERANCE] = 0.001 # ty: ignore
         self.umfpack.control[um.UMFPACK_BLOCK_SIZE] = 64 # ty: ignore
         self.umfpack.control[um.UMFPACK_FIXQ] = -1 # ty: ignore
-        
-        # SETTINGS
-        self._pivoting_threshold: float = 0.001
-
-        self.fact_symb: bool = False
-
+        self.initalized = True
     def reset(self) -> None:
         self.fact_symb = False
     
-    def set_options(self,
-                    pivoting_threshold: float | None = None) -> None:
-            if pivoting_threshold is not None:
-                self.umfpack.control[um.UMFPACK_PIVOT_TOLERANCE] = pivoting_threshold # ty: ignore
-                self.umfpack.control[um.UMFPACK_SYM_PIVOT_TOLERANCE] = pivoting_threshold # ty: ignore
-                self._pivoting_threshold = pivoting_threshold
+    def set_options(self, pivoting_threshold: float | None = None) -> None:
+        self.initialize()
+        if pivoting_threshold is not None:
+            self.umfpack.control[um.UMFPACK_PIVOT_TOLERANCE] = pivoting_threshold # ty: ignore
+            self.umfpack.control[um.UMFPACK_SYM_PIVOT_TOLERANCE] = pivoting_threshold # ty: ignore
+            self._pivoting_threshold = pivoting_threshold
 
     def duplicate(self) -> Solver:
         new_solver = self.__class__()
@@ -568,11 +582,17 @@ class SolverPardiso(Solver):
 
     def __init__(self):
         super().__init__()
-        self.solver: PardisoInterface = PardisoInterface()
+        self.solver: PardisoInterface | None = None
         self.fact_symb: bool = False
         self.A: np.ndarray = None
         self.b: np.ndarray = None
 
+    def initialize(self) -> None:
+        if self.initialized:
+            return
+        self.solver = PardisoInterface()
+        self.initialized = True
+        
     def solve(self, A, b, precon, reuse_factorization: bool = False, id: int = -1) -> tuple[np.ndarray, SolveReport]:
         logger.info(f'[ID={id}] Calling Pardiso Solver')
         if self.fact_symb is False:
@@ -594,11 +614,18 @@ class SolverPardiso(Solver):
 class CuDSSSolver(Solver):
     real_only = False
     def __init__(self):
-        self._cudss = CuDSSInterface()
+        super().__init__()
+        self._cudss: CuDSSInterface | None = None
         self.fact_symb: bool = False
         self.fact_numb: bool = False
+        
+    def initialize(self) -> None:
+        if self.initialized:
+            return
+        self._cudss = CuDSSInterface()
         self._cudss._PRES = 2
-
+        self.initialized = True
+        
     def reset(self) -> None:
         self.fact_symb = False
         self.fact_numb = False
@@ -1085,7 +1112,7 @@ class SolveRoutine:
             np.ndarray: The resultant solution.
         """
         solver: Solver = self._get_solver(A, b)
-
+        solver.initialize()
         NF = A.shape[0]
         NS = solve_ids.shape[0]
 
@@ -1178,7 +1205,7 @@ class SolveRoutine:
             SolveReport: The solution report
         """
         solver = self._get_eig_solver_bma(A, B, direct=direct)
-
+        solver.initialize()
         NF = A.shape[0]
         NS = solve_ids.shape[0]
 

{emerge-0.6.7.dist-info → emerge-0.6.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emerge
-Version: 0.6.7
+Version: 0.6.8
 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