emerge 0.5.5__py3-none-any.whl → 0.6.0__py3-none-any.whl

emerge/_emerge/plot/simple_plots.py

@@ -242,38 +242,170 @@ def plot(
 
     plt.show()
 
-def smith(f: np.ndarray, S: np.ndarray) -> None:
-    """ Plot the Smith Chart
+def smith(
+    S: np.ndarray | Sequence[np.ndarray],
+    f: Optional[np.ndarray | Sequence[np.ndarray]] = None,
+    colors: Optional[Union[str, Sequence[Optional[str]]]] = None,
+    markers: Optional[Union[str, Sequence[str]]] = None,
+    labels: Optional[Union[str, Sequence[str]]] = None,
+    title: Optional[str] = None,
+    linewidth: Optional[Union[float, Sequence[Optional[float]]]] = None,
+    n_flabels: int = 8,
+    funit: str = 'GHz'
+) -> None:
+    """Plot S-parameter traces on a Smith chart with optional per-trace styling
+and sparse frequency annotations (e.g., labeled by frequency).
 
     Args:
-        f (np.ndarray): Frequency vector (Not used yet)
-        S (np.ndarray): S-parameters to plot
-    """     
-    if not isinstance(S, list):
-        Ss = [S]
+    S (np.ndarray | Sequence[np.ndarray]): One or more 1D complex arrays of
+        reflection coefficients (Γ) to plot (each shaped like (N,)).
+    f (Optional[np.ndarray  |  Sequence[np.ndarray]], optional): Frequency
+        vector(s) aligned with `S` for sparse on-curve labels; provide a
+        single array for all traces or one array per trace. Defaults to None.
+    colors (Optional[Union[str, Sequence[Optional[str]]]], optional): Color
+        for all traces or a sequence of per-trace colors. Defaults to None
+        (uses Matplotlib’s color cycle).
+    markers (Optional[Union[str, Sequence[str]]], optional): Marker style
+        for all traces or per-trace markers. Defaults to None (treated as 'none').
+    labels (Optional[Union[str, Sequence[str]]], optional): Legend label for
+        all traces or a sequence of per-trace labels. If omitted, no legend
+        is shown. Defaults to None.
+    title (Optional[str], optional): Axes title. Defaults to None.
+    linewidth (Optional[Union[float, Sequence[Optional[float]]]], optional):
+        Line width for all traces or per-trace widths. Defaults to None
+        (Matplotlib default).
+    n_flabels (int, optional): Approximate number of frequency labels to
+        place per trace (set 0 to disable, even if `f` is provided).
+        Defaults to 8.
+    funit (str, optional): Frequency unit used to scale/format labels.
+        One of {'Hz','kHz','MHz','GHz','THz'} (case-insensitive).
+        Defaults to 'GHz'.
+
+    Raises:
+    ValueError: If a style argument (`colors`, `markers`, `linewidth`, or
+        `labels`) is a sequence whose length does not match the number of traces.
+    ValueError: If `f` is a sequence whose length does not match the number
+        of traces.
+    ValueError: If `funit` is not one of {'Hz','kHz','MHz','GHz','THz'}.
+
+    Returns:
+    None: Draws the Smith chart on a new figure/axes and displays it with `plt.show()`.
+"""
+    # --- normalize S into a list of 1D complex arrays ---
+    if isinstance(S, (list, tuple)):
+        Ss: List[np.ndarray] = [np.asarray(s).ravel() for s in S]
     else:
-        Ss = S
-    
-    fig, ax = plt.subplots()
+        Ss = [np.asarray(S).ravel()]
+
+    n_traces = len(Ss)
+
+    # --- helper: broadcast a scalar or single value to n_traces, or validate a sequence ---
+    def _broadcast(value, default, name: str) -> List:
+        if value is None:
+            return [default for _ in range(n_traces)]
+        # treat bare strings specially (they’re Sequences but should broadcast)
+        if isinstance(value, str):
+            return [value for _ in range(n_traces)]
+        if not isinstance(value, (list, tuple)):
+            return [value for _ in range(n_traces)]
+        if len(value) != n_traces:
+            raise ValueError(f"`{name}` must have length {n_traces}, got {len(value)}.")
+        return list(value)
+
+    # --- style parameters (broadcast as needed) ---
+    markers_list = _broadcast(markers, 'none', 'markers')
+    colors_list  = _broadcast(colors, None, 'colors')
+    lw_list      = _broadcast(linewidth, None, 'linewidth')
+    labels_list: Optional[List[Optional[str]]]
+    if labels is None:
+        labels_list = None
+    else:
+        labels_list = _broadcast(labels, None, 'labels')
+
+    # --- frequencies (broadcast as needed) ---
+    if f is None:
+        fs_list: List[Optional[np.ndarray]] = [None for _ in range(n_traces)]
+    else:
+        if isinstance(f, (list, tuple)):
+            if len(f) != n_traces:
+                raise ValueError(f"`f` must have length {n_traces}, got {len(f)}.")
+            fs_list = [np.asarray(fi).ravel() for fi in f]
+        else:
+            fi = np.asarray(f).ravel()
+            fs_list = [fi for _ in range(n_traces)]
+
+    # --- unit scaling ---
+    units = {'hz':1.0, 'khz':1e3, 'mhz':1e6, 'ghz':1e9, 'thz':1e12}
+    key = funit.lower()
+    if key not in units:
+        raise ValueError(f"Unknown funit '{funit}'. Choose from {list(units.keys())}.")
+    fdiv = units[key]
+
+    # --- figure/axes ---
+    fig: Figure
+    ax: Axes
+    fig, ax = plt.subplots(figsize=(6, 6))
+
+    # --- smith grid (kept out of legend) ---
     for line in _smith_transform(_generate_grids()):
-        ax.plot(line[0], line[1], color='grey', alpha=0.3, linewidth=0.7)
-    p = np.linspace(0,2*np.pi,101)
-    ax.plot(np.cos(p), np.sin(p), color='black', alpha=0.5)
-    # Add important numbers for the Impedance Axes
-    # X and Y values (0, 0.5, 1, 2, 10, 50)
-    for i in [0, 0.2, 0.5, 1, 2, 10]:
-        z = i + 1j*0
-        G = (z-1)/(z+1)
-        ax.annotate(f"{i}", (G.real, G.imag), color='black', fontsize=8)
-    for i in [0, 0.2, 0.5, 1, 2, 10]:
-        z = 0 + 1j*i
-        G = (z-1)/(z+1)
-        ax.annotate(f"{i}", (G.real, G.imag), color='black', fontsize=8)       
-        ax.annotate(f"{-i}", (G.real, -G.imag), color='black', fontsize=8)  
-    for s in Ss:
-        ax.plot(s.real, s.imag, color='blue')
+        ax.plot(line[0], line[1], color='0.6', alpha=0.3, linewidth=0.7, label='_nolegend_')
+
+    # unit circle
+    p = np.linspace(0, 2*np.pi, 361)
+    ax.plot(np.cos(p), np.sin(p), color='black', alpha=0.5, linewidth=0.8, label='_nolegend_')
+
+    # --- annotate a few impedance reference ticks (kept out of legend) ---
+    ref_vals = [0, 0.2, 0.5, 1, 2, 10]
+    for r in ref_vals:
+        z = r + 1j*0
+        G = (z - 1) / (z + 1)
+        ax.annotate(f"{r}", (G.real, G.imag), color='black', fontsize=8)
+    for x in ref_vals:
+        z = 0 + 1j*x
+        G = (z - 1) / (z + 1)
+        ax.annotate(f"{x}", (G.real, G.imag), color='black', fontsize=8)
+        ax.annotate(f"{-x}", (G.real, -G.imag), color='black', fontsize=8)
+
+    # --- plot traces ---
+    for i, s in enumerate(Ss):
+        lbl = labels_list[i] if labels_list is not None else None
+        line, = ax.plot(
+            s.real, s.imag,
+            color=colors_list[i],
+            marker=markers_list[i],
+            linewidth=lw_list[i],
+            label=lbl
+        )
+
+        # frequency labels (sparse)
+        fi = fs_list[i]
+        if fi[0] is not None and n_flabels > 0 and len(s) > 0 and len(fi) > 0:
+            n = min(len(s), len(fi))
+            step = max(1, int(round(n / n_flabels))) if n_flabels > 0 else n  # avoid step=0
+            idx = np.arange(0, n, step)
+            # small offset so labels don't sit right on the curve
+            dx = 0.03
+            for k in idx:
+                fk = fi[k] / fdiv
+                # choose a compact format (3 significant digits)
+                idigit = 3
+                if np.log10(fk)>3:
+                    idigit = 1
+                ftxt = f"{fk:.{idigit}f}{funit}"
+                ax.annotate(ftxt, (s[k].real + dx, s[k].imag), fontsize=8, color=line.get_color())
+
+    # legend only if labels were given
+    if labels_list is not None:
+        ax.legend(loc='best')
+
+    if title:
+        ax.set_title(title)
+
+    ax.set_aspect('equal', adjustable='box')
+    ax.set_xlim(-1.1, 1.1)
+    ax.set_ylim(-1.1, 1.1)
     ax.grid(False)
-    ax.axis('equal')
+    plt.tight_layout()
     plt.show()
 
 def plot_sp(f: np.ndarray, S: list[np.ndarray] | np.ndarray, 

emerge/_emerge/projects/_gen_base.txt

@@ -13,7 +13,7 @@ wga = 22.86*mm
 wgb = 10.16*mm
 wgl = 50*mm
 
-with em.Simulation3D("myfile", save_file=True) as m:
+with em.Simulation("myfile", save_file=True) as m:
     m['box'] = em.geo.Box(wga,wgl,wgb,(0,0,0))
     
     m.commit_geometry()
@@ -29,4 +29,4 @@ with em.Simulation3D("myfile", save_file=True) as m:
     port2 = m.mw.bc.RectangularWaveguide(m['box'].face('back'), 2)
 
     # Run simulation steps
-    m.mw.frequency_domain()
+    m.mw.run_sweep()

emerge/_emerge/projects/_load_base.txt

@@ -9,7 +9,7 @@ mil = 0.0254
 um = 0.000001
 PI = np.pi
 
-with em.Simulation3D("myfile", load_file=True) as m:
+with em.Simulation("myfile", load_file=True) as m:
     
     data = m.data.mw.scalar.grid
 

emerge/_emerge/simmodel.py

@@ -58,7 +58,7 @@ class SimulationError(Exception):
 #                 BASE 3D SIMULATION MODEL                 #
 ############################################################
 
-class Simulation3D:
+class Simulation:
 
     def __init__(self, 
                  modelname: str, 
@@ -67,7 +67,7 @@ class Simulation3D:
                  save_file: bool = False,
                  logfile: bool = False,
                  path_suffix: str = ".EMResults"):
-        """Generate a Simulation3D class object.
+        """Generate a Simulation class object.
 
         As a minimum a file name should be provided. Additionally you may provide it with any
         class that inherits from BaseDisplay. This will then be used for geometry displaying.
@@ -128,11 +128,11 @@ class Simulation3D:
         """Get the data from the current data container"""
         return self.data.sim[name]
     
-    def __enter__(self) -> Simulation3D:
+    def __enter__(self) -> Simulation:
         """This method is depricated with the new atexit system. It still exists for backwards compatibility.
 
         Returns:
-            Simulation3D: the Simulation3D object
+            Simulation: the Simulation object
         """
         return self
 
@@ -313,7 +313,7 @@ class Simulation3D:
         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.add_object(sel, color='red', opacity=0.3) for sel in selections]
         self.display.show()
 
         return None
@@ -408,7 +408,7 @@ class Simulation3D:
         Example:
          >>> for W, H in model.parameter_sweep(True, width=widths, height=heights):
          >>>    // build simulation
-         >>>    data = model.frequency_domain()
+         >>>    data = model.run_sweep()
          >>> // Extract the data
          >>> widths, heights, frequencies, S21 = data.ax('width','height','freq').S(2,1)
         """
@@ -435,7 +435,21 @@ class Simulation3D:
             else:
                 yield (dim[i_iter] for dim in dims_flat) # type: ignore
         self.mw.cache_matrices = True
+    
+    def export(self, filename: str):
+        """Exports the model or mesh depending on the extension. 
+        
+        Exporting is realized by GMSH.
+        Supported file formats are:
+        
+        3D Model: .opt, .geo_unrolled, .brep, .xao ,.step and .iges
+        Mesh: .msh, .inp, .key, ._0000.rad, .celum, .cgns, .diff, .unv, .ir3, .mes, .mesh 
+              .mail, .m, .bdf, .off, .p3d, .stl, .wrl, .vtk, .dat, .ply2, .su2, .neu, .x3d
 
+        Args:
+            filename (str): The filename
+        """
+        gmsh.write(filename)
     ############################################################
     #                     DEPRICATED FUNCTIONS                #
     ############################################################
@@ -444,4 +458,5 @@ class Simulation3D:
         """DEPRICATED VERSION: Use .commit_geometry()
         """
         logger.warning('define_geometry() will be derpicated. Use commit_geometry() instead.')
-        self.commit_geometry(*args)
+        self.commit_geometry(*args)
+        

emerge/_emerge/solve_interfaces/cudss_interface.py

@@ -21,6 +21,7 @@ from nvmath import CudaDataType # ty: ignore
 
 from scipy.sparse import csr_matrix
 import numpy as np
+from typing import Literal
 
 from loguru import logger
 
@@ -51,6 +52,11 @@ def _c_pointer(arry) -> int:
 ############################################################
 
 class CuDSSInterface:
+    """the CuDSSInterface class implements the nvmath bindings and cupy
+    control for EMerge.
+    """
+    AlgType = cudss.AlgType
+
     def __init__(self):
         self.A_cu = None
         self.b_cu = None
@@ -92,10 +98,31 @@ class CuDSSInterface:
             reorder_alg.nbytes
         )
 
-    def set_algorithm(self, alg_type: cudss.AlgType):
-        self.RALG = alg_type
+    def set_algorithm(self, alg_type: Literal['METIS','COLAMD','COLAM_BT','AMD']):
+        """Define fill-in reduction column permuation algorithm. The options are:
+
+         - "METIS" (Default) = NVidia's own Nested Dissection METIS sorter
+         - "COLAMD" = Column approximate minimum degree
+         - "COLAM_BT" = Column Approximate Minimum Degree Block Triangular
+         - "AMD" = Approximate Minimum Degree
+
+        Args:
+            alg_type (str): The chosen type
+        """
+        if alg_type=='METIS':
+            self.RALG = ALG_NEST_DISS_METIS
+        elif alg_type =='COLAMD':
+            self.RALG = ALG_COLAMD
+        elif alg_type == 'COLAMD_BT':
+            self.RALG = ALG_COLAMD_BLOCK_TRI
+        elif alg_type == 'AMD':
+            self.RALG = ALG_AMD
+        else:
+            logger.warning(f'Algorithm type {alg_type} is not of the chosen set. Ignoring setting.')
     
     def init_type(self):
+        """Initializes the value data type of the solver (float vs complex, single vs double).
+        """
         if self._PRES == 1:
             if self._COMP:
                 self.c_dtype = cp.complex64
@@ -112,6 +139,11 @@ class CuDSSInterface:
                 self.VTYPE = FLOAT64
 
     def submit_matrix(self, A: csr_matrix):
+        """Sets the given csr_matrix as the matrix to be solved.
+
+        Args:
+            A (csr_matrix): The csr_format matrix for the problem Ax=b
+        """
         self.N = A.shape[0]
 
         if np.iscomplexobj(A):
@@ -132,12 +164,21 @@ class CuDSSInterface:
         self._COL_IDS = self.A_cu.indices.astype(cp.int32)
 
     def submit_vector(self, b: np.ndarray):
+        """Submits the dense vector b to be solved.
+
+        Args:
+            b (np.ndarray): The dense vector for the problem Ax=b
+        """
         self.b_cu = cp.array(b).astype(self.c_dtype)
     
     def create_solvec(self):
+        """Initializes a solution vector that the nvmath binding can access.
+        """
         self.x_cu = cp.empty_like(self.b_cu)
 
     def _update_dss_data(self):
+        """Updates the currently defined matrix data into the existing memory.ALG_AMD
+        """
         cudss.matrix_set_values(self.A_cobj, _c_pointer(self._VAL))
 
         
@@ -147,6 +188,7 @@ class CuDSSInterface:
                                     int(self.VTYPE), int(cudss.Layout.COL_MAJOR))
 
     def _create_dss_data(self):
+        """Creates a new memory slot for the CSR matrix of the matrix A"""
         self.A_cobj = cudss.matrix_create_csr(
             self.N,self.N,self._NNZ,
             _c_pointer(self._ROW_START),

emerge/_emerge/solve_interfaces/pardiso_interface.py

@@ -15,6 +15,7 @@
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, see
 # <https://www.gnu.org/licenses/>.
+
 from __future__ import annotations
 import os
 import sys

emerge/_emerge/solver.py

@@ -44,11 +44,8 @@ If so, attempt to import PyPardiso (if its installed)
 ############################################################
 
 if 'arm' not in platform.processor():
-    try:
-        from .solve_interfaces.pardiso_interface import PardisoInterface
-        _PARDISO_AVAILABLE = True
-    except ModuleNotFoundError:
-        logger.info('Pardiso not found, defaulting to SuperLU')
+    from .solve_interfaces.pardiso_interface import PardisoInterface
+    _PARDISO_AVAILABLE = True
 
 
 ############################################################
@@ -62,7 +59,6 @@ try:
 except ModuleNotFoundError:
     logger.debug('UMFPACK not found, defaulting to SuperLU')
 
-
 ############################################################
 #                           CUDSS                          #
 ############################################################
@@ -72,7 +68,10 @@ try:
     _CUDSS_AVAILABLE = True
 except ModuleNotFoundError:
     pass
-
+except ImportError as e:
+    logger.error('Error while importing CuDSS dependencies:')
+    logger.exception(e)
+    
 ############################################################
 #                       SOLVE REPORT                       #
 ############################################################
@@ -177,7 +176,8 @@ def filter_real_modes(eigvals: np.ndarray, eigvecs: np.ndarray,
 #               EIGENMODE ORTHOGONALITY CHECK              #
 ############################################################
 
-def filter_unique_eigenpairs(eigen_values: list[complex], eigen_vectors: list[np.ndarray], tol=-3) -> tuple[list[complex], list[np.ndarray]]:
+def filter_unique_eigenpairs(eigen_values: list[complex], 
+                             eigen_vectors: list[np.ndarray], tol=-3) -> tuple[list[complex], list[np.ndarray]]:
     """
     Filters eigenvectors by orthogonality using dot-product tolerance.
     
@@ -301,7 +301,8 @@ class Solver:
         Options may be ignored depending on the type of solver used."""
         pass
         
-    def solve(self, A: csr_matrix, b: np.ndarray, precon: Preconditioner, reuse_factorization: bool = False, id: int = -1) -> tuple[np.ndarray, SolveReport]:
+    def solve(self, A: csr_matrix, b: np.ndarray, precon: Preconditioner, 
+              reuse_factorization: bool = False, id: int = -1) -> tuple[np.ndarray, SolveReport]:
         raise NotImplementedError("This classes Ax=B solver method is not implemented.")
     
     def reset(self) -> None:
@@ -329,7 +330,8 @@ class EigSolver:
     def duplicate(self) -> Solver:
         return self.__class__()
 
-    def eig(self, A: csr_matrix | csr_matrix, B: csr_matrix | csr_matrix, nmodes: int = 6, target_k0: float = 0.0, which: str = 'LM', sign: float = 1.):
+    def eig(self, A: csr_matrix | csr_matrix, B: csr_matrix | csr_matrix, nmodes: int = 6, 
+            target_k0: float = 0.0, which: str = 'LM', sign: float = 1.):
         raise NotImplementedError("This classes eigenmdoe solver method is not implemented.")
     
     def reset(self) -> None:
@@ -337,7 +339,6 @@ class EigSolver:
         pass
 
 
-
 ############################################################
 #                          SORTERS                         #
 ############################################################
@@ -379,7 +380,9 @@ class ILUPrecon(Preconditioner):
 
     def init(self, A, b):
         logger.info("Generating ILU Preconditioner")
-        self.ilu = sparse.linalg.spilu(A, drop_tol=1e-2, fill_factor=self.fill_factor, permc_spec='MMD_AT_PLUS_A', diag_pivot_thresh=0.001, options=self.options) # ty: ignore
+        self.ilu = sparse.linalg.spilu(A, drop_tol=1e-2, fill_factor=self.fill_factor, # ty: ignore
+                                       permc_spec='MMD_AT_PLUS_A', diag_pivot_thresh=0.001, 
+                                       options=self.options) 
         self.M = sparse.linalg.LinearOperator(A.shape, self.ilu.solve) # ty: ignore
 
 
@@ -601,7 +604,7 @@ class CuDSSSolver(Solver):
         self.fact_numb = False
 
     def solve(self, A, b, precon, reuse_factorization: bool = False, id: int = -1):
-        logger.info(f'[{id}] Calling cuDSS Solver')
+        logger.info(f'[ID={id}] Calling cuDSS Solver')
         
         if self.fact_symb is False:
             logger.debug('Executing symbollic factorization')
@@ -911,7 +914,8 @@ class SolveRoutine:
         return new_routine
     
     def set_solver(self, *solvers: EMSolver | EigSolver | Solver) -> None:
-        """Set a given Solver class instance as the main solver. Solvers will be checked on validity for the given problem.
+        """Set a given Solver class instance as the main solver. 
+        Solvers will be checked on validity for the given problem.
 
         Args:
             solver (EMSolver | Solver): The solver objects
@@ -923,7 +927,8 @@ class SolveRoutine:
                 self.forced_solver.append(solver)
     
     def disable(self, *solvers: EMSolver) -> None:
-        """Disable a given Solver class instance as the main solver. Solvers will be checked on validity for the given problem.
+        """Disable a given Solver class instance as the main solver. 
+        Solvers will be checked on validity for the given problem.
 
         Args:
             solver (EMSolver): The solver objects
@@ -945,7 +950,8 @@ class SolveRoutine:
                     - "SI" = Single threaded
                     - "MT" = Multi threaded
                     - "MP" = Multi-processing,
-            smart_search (bool, optional): Wether to use smart-search solvers for eigenmode problems. Defaults to False.
+            smart_search (bool, optional): Wether to use smart-search solvers 
+            for eigenmode problems. Defaults to False.
 
         Returns:
             SolveRoutine: The same SolveRoutine object.
@@ -998,7 +1004,6 @@ class SolveRoutine:
                 return solver
         return self.pick_solver(A,b)
         
-    
     def pick_solver(self, A: csr_matrix, b: np.ndarray) -> Solver:
         """Returns the relevant Solver object given a certain matrix and source vector
 
@@ -1187,7 +1192,10 @@ class SolveRoutine:
         end = time.time()
 
         simtime = end-start
-        return eigen_values, eigen_modes, SolveReport(ndof=A.shape[0], nnz=A.nnz, ndof_solve=Asel.shape[0], nnz_solve=Asel.nnz, simtime=simtime, solver=str(solver), sorter='None', precon='None')
+        return eigen_values, eigen_modes, SolveReport(ndof=A.shape[0], nnz=A.nnz, 
+                                                      ndof_solve=Asel.shape[0], nnz_solve=Asel.nnz, 
+                                                      simtime=simtime, solver=str(solver), 
+                                                      sorter='None', precon='None')
 
     def eig(self, 
             A: csr_matrix | csr_matrix, 
@@ -1234,7 +1242,6 @@ class SolveRoutine:
 
         return eigen_values, sols, SolveReport(ndof=A.shape[0], nnz=A.nnz, ndof_solve=Asel.shape[0], nnz_solve=Asel.nnz, simtime=simtime, solver=str(solver), sorter='None', precon='None')
 
-
 class AutomaticRoutine(SolveRoutine):
     """ Defines the Automatic Routine for EMerge.
     """

emerge/ext.py

@@ -0,0 +1,4 @@
+
+from ._emerge.solver import Solver, EigSolver, Preconditioner, Sorter
+from ._emerge.geometry import GeoVolume, GeoSurface, GeoEdge, GeoPoint, _FacePointer
+from ._emerge.physics.microwave.microwave_bc import RobinBC, PortBC

emerge/lib.py

@@ -29,7 +29,7 @@ GREY = "#bfbfbf"
 MET_ALUMINUM         = Material(cond=3.77e7,  color=GREY, opacity=0.5)
 MET_CARBON           = Material(cond=3.33e4,  color=GREY, opacity=0.5)
 MET_CHROMIUM         = Material(cond=5.56e6,  color=GREY, opacity=0.5)
-MET_COPPER           = Material(cond=5.8e7,   color="#62290c", opacity=0.5)
+MET_COPPER           = Material(cond=5.8e7,   color="#62290c", opacity=1.0)
 MET_GOLD             = Material(cond=4.10e7,  color=GREY, opacity=0.5)
 MET_INDIUM           = Material(cond=6.44e6,  color=GREY, opacity=0.5)
 MET_IRIDIUM          = Material(cond=2.13e7,  color=GREY, opacity=0.5)

{emerge-0.5.5.dist-info → emerge-0.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emerge
-Version: 0.5.5
+Version: 0.6.0
 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
@@ -42,7 +42,9 @@ pip install emerge
 On MacOS and Linux you can install it with the very fast UMFPACK through scikit-umfpack
 
 ```
-pip install emerge[scikit-umfpack]
+brew install swig suite-sparse #MacOS
+sudo apt-get install libsuitesparse-dev #Linux
+pip install emerge[umfpack]
 ```
 
 ### Experimental
@@ -62,7 +64,7 @@ import emerge as em
 def main():
     # setup simulation
 
-    model.mw.frequency_domain(True, ..., multi_processing=True)
+    model.mw.run_sweep(True, ..., multi_processing=True)
 
 if __name__ == "__main__":
     main()
@@ -93,4 +95,4 @@ First time runs will be very slow because Numba needs to generate local C-compil
 
 ## Third Party License Notice
 
-“This package depends on Intel® Math Kernel Library (MKL), which is licensed separately under the Intel Simplified Software License (October 2022). Installing with pip will fetch the MKL wheel and prompt you to accept that licence.”
+“This package depends on Intel® Math Kernel Library (MKL), which is licensed separately under the Intel Simplified Software License (October 2022). Installing with pip will fetch the MKL wheel and prompt you to accept that licence.”