emerge 0.5.6__py3-none-any.whl → 0.6.1__py3-none-any.whl

emerge/__init__.py

@@ -18,7 +18,7 @@ along with this program; if not, see
 """
 import os
 
-__version__ = "0.5.6"
+__version__ = "0.6.1"
 
 ############################################################
 #               HANDLE ENVIRONMENT VARIABLES              #
@@ -44,7 +44,7 @@ from loguru import logger
 LOG_CONTROLLER.set_default()
 logger.debug('Importing modules')
 
-from ._emerge.simmodel import Simulation3D
+from ._emerge.simmodel import Simulation
 from ._emerge.material import Material
 from ._emerge import bc
 from ._emerge.solver import SolverBicgstab, SolverGMRES, SolveRoutine, ReverseCuthillMckee, Sorter, SolverPardiso, SolverUMFPACK, SolverSuperLU, EMSolver

emerge/_emerge/elements/nedleg2.py

@@ -28,13 +28,13 @@ from ..const import MU0, C0
 
 class FieldFunctionClass:
     """ This Class serves as a picklable class so that ModalPort boundary conditions
-    can actually be stored with the Simulation3D class. Functions aren't picklable in 
+    can actually be stored with the Simulation class. Functions aren't picklable in 
     Python. 
     
     I am not happy with the existence of this class, it feels too ad-hoc but for now it
     is the simplest way. It stores all actually required information needed to do a
     surface field interpolation without needing to store the Mesh3D and SurfaceMesh class
-    objects plus the NedelecLegrange2 classes with the Simulation3D. 
+    objects plus the NedelecLegrange2 classes with the Simulation. 
 
     As it stands currently, only the GMSH mesh is stored plus the geometry objects. The
     mesh is reconstructed as it is deterministic.

emerge/_emerge/geo/__init__.py

@@ -18,7 +18,7 @@
 from .pcb import PCB
 from .pmlbox import pmlbox
 from .horn import Horn
-from .shapes import Cyllinder, CoaxCyllinder, Box, XYPlate, HalfSphere, Sphere, Plate, OldBox, Alignment
+from .shapes import Cylinder, CoaxCylinder, Box, XYPlate, HalfSphere, Sphere, Plate, OldBox, Alignment
 from .operations import subtract, add, embed, remove, rotate, mirror, change_coordinate_system, translate, intersect
 from .polybased import XYPolygon, GeoPrism
 from .step import STEPItems

emerge/_emerge/geo/modeler.py

@@ -18,7 +18,7 @@
 from __future__ import annotations
 import numpy as np
 from typing import Callable, Iterable
-from .shapes import Box, Cyllinder, Alignment
+from .shapes import Box, Cylinder, Alignment
 from ..geometry import GeoVolume, GeoObject
 from .operations import rotate, mirror, translate, add, subtract, embed
 from numbers import Number
@@ -400,7 +400,7 @@ class Modeler:
                 if NPoly:
                     cyl = XYPolygon.circle(r, Nsections=NPoly).extrude(h, cs2)
                 else:
-                    cyl  = Cyllinder(r,h, cs2)
+                    cyl  = Cylinder(r,h, cs2)
                 cyls.append(cyl)
 
         self.ndimcont.set_copies(N)

emerge/_emerge/geo/pcb.py

@@ -20,7 +20,7 @@ from __future__ import annotations
 from ..cs import CoordinateSystem, GCS, Axis
 from ..geometry import GeoPolygon, GeoVolume, GeoSurface
 from ..material import Material, AIR, COPPER
-from .shapes import Box, Plate, Cyllinder
+from .shapes import Box, Plate, Cylinder
 from .polybased import XYPolygon
 from .operations import change_coordinate_system
 from .pcb_tools.macro import parse_macro
@@ -1079,7 +1079,7 @@ class PCB:
         plane = change_coordinate_system(plane, self.cs) # type: ignore
         return plane # type: ignore
     
-    def gen_pcb(self, 
+    def generate_pcb(self, 
                 split_z: bool = True,
                 layer_tolerance: float = 1e-6,
                 merge: bool = True) -> GeoVolume:
@@ -1119,7 +1119,7 @@ class PCB:
         box = change_coordinate_system(box, self.cs)
         return box # type: ignore
 
-    def gen_air(self, height: float) -> GeoVolume:
+    def generate_air(self, height: float) -> GeoVolume:
         """Generate the Air Block object
 
         This requires that the width, depth and origin are deterimed. This 
@@ -1247,14 +1247,14 @@ class PCB:
         plate = change_coordinate_system(plate, self.cs)
         return plate # type: ignore
 
-    def generate_vias(self, merge=False) -> list[Cyllinder] | Cyllinder:
+    def generate_vias(self, merge=False) -> list[Cylinder] | Cylinder:
         """Generates the via objects.
 
         Args:
             merge (bool, optional): Whether to merge the result into a final object. Defaults to False.
 
         Returns:
-            list[Cyllinder] | Cyllinder: Either al ist of cylllinders or a single one (merge=True)
+            list[Cylinder] | Cylinder: Either al ist of cylllinders or a single one (merge=True)
         """
         vias = []
         for via in self.vias:
@@ -1263,7 +1263,7 @@ class PCB:
             z0 = via.z1*self.unit
             xg, yg, zg = self.cs.in_global_cs(x0, y0, z0)
             cs = CoordinateSystem(self.cs.xax, self.cs.yax, self.cs.zax, np.array([xg, yg, zg]))
-            cyl = Cyllinder(via.radius*self.unit, (via.z2-via.z1)*self.unit, cs, via.segments)
+            cyl = Cylinder(via.radius*self.unit, (via.z2-via.z1)*self.unit, cs, via.segments)
             cyl.material = COPPER
             vias.append(cyl)
         if merge:

emerge/_emerge/geo/shapes.py

@@ -172,26 +172,26 @@ class Plate(GeoSurface):
         tags: list[int] = [gmsh.model.occ.addPlaneSurface([tag_wire,]),]
         super().__init__(tags)
 
-class Cyllinder(GeoVolume):
+class Cylinder(GeoVolume):
 
     def __init__(self, 
                  radius: float,
                  height: float,
                  cs: CoordinateSystem = None,
                  Nsections: int = None):
-        """Generates a Cyllinder object in 3D space.
+        """Generates a Cylinder object in 3D space.
         The cyllinder will always be placed in the origin of the provided CoordinateSystem.
         The bottom cyllinder plane is always placed in the XY-plane. The lenth of the cyllinder is
         oriented along the Z-axis.
 
         By default the cyllinder uses the Open Cascade modeling for a cyllinder. In this representation
         the surface of the cyllinder is approximated with a tolerance thay may be irregular.
-        As an alternative, the argument Nsections may be provided in which case the Cyllinder is replaced
+        As an alternative, the argument Nsections may be provided in which case the Cylinder is replaced
         by an extrusion of a regular N-sided polygon.
 
         Args:
-            radius (float): The radius of the Cyllinder
-            height (float): The height of the Cyllinder
+            radius (float): The radius of the Cylinder
+            height (float): The height of the Cylinder
             cs (CoordinateSystem, optional): The coordinate system. Defaults to None.
             Nsections (int, optional): The number of sections. Defaults to None.
         """
@@ -233,7 +233,7 @@ class Cyllinder(GeoVolume):
         xo, yo, zo = self.cs.in_global_cs(x.flatten(), y.flatten(), z.flatten())
         return xo, yo, zo
 
-class CoaxCyllinder(GeoVolume):
+class CoaxCylinder(GeoVolume):
     """A coaxial cylinder with an inner and outer radius."""
     
     def __init__(self, 
@@ -249,12 +249,12 @@ class CoaxCyllinder(GeoVolume):
 
         By default the coax uses the Open Cascade modeling for a cyllinder. In this representation
         the surface of the cyllinder is approximated with a tolerance thay may be irregular.
-        As an alternative, the argument Nsections may be provided in which case the Cyllinder is replaced
+        As an alternative, the argument Nsections may be provided in which case the Cylinder is replaced
         by an extrusion of a regular N-sided polygon.
 
         Args:
-            radius (float): The radius of the Cyllinder
-            height (float): The height of the Cyllinder
+            radius (float): The radius of the Cylinder
+            height (float): The height of the Cylinder
             cs (CoordinateSystem, optional): The coordinate system. Defaults to None.
             Nsections (int, optional): The number of sections. Defaults to None.
         """
@@ -267,8 +267,8 @@ class CoaxCyllinder(GeoVolume):
         self.rin = rin
         self.height = height
 
-        self.cyl_out = Cyllinder(rout, height, cs, Nsections=Nsections)
-        self.cyl_in = Cyllinder(rin, height, cs, Nsections=Nsections)
+        self.cyl_out = Cylinder(rout, height, cs, Nsections=Nsections)
+        self.cyl_in = Cylinder(rin, height, cs, Nsections=Nsections)
         self.cyl_in._exists = False
         self.cyl_out._exists = False
         cyltags, _ = gmsh.model.occ.cut(self.cyl_out.dimtags, self.cyl_in.dimtags)

emerge/_emerge/howto.py

@@ -27,11 +27,11 @@ class _HowtoClass:
         """
         To start a simulation simply create a model object through:
 
-        >>> model = emerge.Simulation3D('MyProjectName')
+        >>> model = emerge.Simulation('MyProjectName')
 
         Optionally, you can use a context manager for a more explicit handling of exiting the GMSH api and storing data after simulations.
 
-        >>> with emerge.Simulation3D('MyProjectName') as model:
+        >>> with emerge.Simulation('MyProjectName') as model:
 
         """
         pass
@@ -45,7 +45,7 @@ class _HowtoClass:
         >>> sphere = emerge.geo.Sphere(...)
         >>> pcb_layouter = emerge.geo.PCBLayout(...)
         >>> plate = emerge.geo.Plate(...)
-        >>> cyl = emerge.geo.Cyllinder(...)
+        >>> cyl = emerge.geo.Cylinder(...)
 
         After making geometries, you should pass all of them to
         the simulation object
@@ -77,7 +77,7 @@ class _HowtoClass:
         >>> face = cutout.face('front', tool=box)
         
         Exclusions or specific isolations can be added with optional arguments.
-        There is also a select object in your Simulation3D class that has various convenient selection options
+        There is also a select object in your Simulation class that has various convenient selection options
         >>> faces = model.select.face.inlayer()
         >>> faces = model.select.inplane()
         >>> faces = model.select.face.near(x,y,z)
@@ -99,15 +99,15 @@ class _HowtoClass:
 
         """
 
-    def run_frequency_domain(self):
+    def run_sweep(self):
         """
         You can run a frequency domain study by simply calling:\
         
-        >>> results = model.mw.frequency_domain(...)
+        >>> results = model.mw.run_sweep(...)
 
         You can distribute your frequency sweep across multiple threads using
         
-        >>> results = model.mw.frequency_domain(parallel=True, njobs=3)
+        >>> results = model.mw.run_sweep(parallel=True, njobs=3)
 
         The frequency domain study will return an MWSimData object that contains all data.
         """
@@ -154,7 +154,7 @@ class _HowtoClass:
     def save_and_load(self):
         """
         You can save your project data by setting save_file to True:
-        >>> model = emerge.Simulation3D(..., save_file=True)
+        >>> model = emerge.Simulation(..., save_file=True)
 
         Whenever you want, you can save all data by calling the .save() method
 
@@ -166,7 +166,7 @@ class _HowtoClass:
         
         You can load the data from a simulation using:
 
-        >>> model = emerge.Simulation3D(..., load_file=True)
+        >>> model = emerge.Simulation(..., load_file=True)
 
         The data from a simulation can be found in:
 

emerge/_emerge/physics/microwave/microwave_3d.py

@@ -577,14 +577,14 @@ class Microwave3D:
         logger.info(f'Elapsed time = {(T2-T0):.2f} seconds.')
         return None
     
-    def frequency_domain(self, 
-                         parallel: bool = False,
-                         njobs: int = 2, 
-                         harddisc_threshold: int | None = None,
-                         harddisc_path: str = 'EMergeSparse',
-                         frequency_groups: int = -1,
-                         multi_processing: bool = False,
-                         automatic_modal_analysis: bool = True) -> MWData:
+    def run_sweep(self, 
+                parallel: bool = False,
+                njobs: int = 2, 
+                harddisc_threshold: int | None = None,
+                harddisc_path: str = 'EMergeSparse',
+                frequency_groups: int = -1,
+                multi_processing: bool = False,
+                automatic_modal_analysis: bool = True) -> MWData:
         """Executes a frequency domain study
 
         The study is distributed over "njobs" workers.
@@ -1017,179 +1017,13 @@ class Microwave3D:
             mode_p = sparam_mode_power(self.mesh.nodes, tri_vertices, bc, k0, const, 5)
             return field_p, mode_p
 
-    # def frequency_domain_single(self, automatic_modal_analysis: bool = False) -> MWData:
-    #     """Execute a frequency domain study without distributed frequency sweep.
 
-    #     Args:
-    #         automatic_modal_analysis (bool, optional): Automatically compute port modes. Defaults to False.
+    ############################################################
+    #                     DEPRICATED FUNCTIONS                #
+    ############################################################
 
-    #     Raises:
-    #         SimulationError: _description_
-
-    #     Returns:
-    #         MWSimData: The Simulation data.
-    #     """
-    #     T0 = time.time()
-    #     mesh = self.mesh
-    #     if self.bc._initialized is False:
-    #         raise SimulationError('Cannot run a modal analysis because no boundary conditions have been assigned.')
-        
-    #     self._initialize_field()
-    #     self._initialize_bc_data()
-        
-    #     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,:]
-
-    #     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]
-        
-    #     #### Port settings
-
-    #     all_ports = self.bc.oftype(PortBC)
-    #     port_numbers = [port.port_number for port in all_ports]
-
-    #     ##### FOR PORT SWEEP SET ALL ACTIVE TO FALSE. THIS SHOULD BE FIXED LATER
-    #     ### COMPUTE WHICH TETS ARE CONNECTED TO PORT INDICES
-
-    #     all_port_tets = []
-    #     for port in all_ports:
-    #         port.active=False
-            
-    #     all_port_tets = mesh.get_face_tets(*[port.tags for port in all_ports])
-        
-
-    #     logger.debug(f'Starting the simulation of {len(self.frequencies)} frequency points.')
-
-    #     # ITERATE OVER FREQUENCIES
-    #     for freq in self.frequencies:
-    #         logger.info(f'Simulation frequency = {freq/1e9:.3f} GHz') 
-            
-    #         # Assembling matrix problem
-    #         if automatic_modal_analysis:
-    #             self._compute_modes(freq)
-            
-    #         job = self.assembler.assemble_freq_matrix(self.basis, er, ur, cond, self.bc.boundary_conditions, freq, cache_matrices=self.cache_matrices)
-
-    #         logger.debug(f'Routine: {self.solveroutine}')
-
-    #         for A, b, ids, reuse in job.iter_Ab():
-    #             solution, report = self.solveroutine.solve(A, b, ids, reuse)
-    #             job.submit_solution(solution, report)
-
-    #         self.data.setreport(job.reports, freq=freq, **self._params)
-
-    #         k0 = 2*np.pi*freq/299792458
-
-    #         scalardata = self.data.scalar.new(freq=freq, **self._params)
-    #         scalardata.init_sp(port_numbers)
-    #         scalardata.freq = freq
-    #         scalardata.k0 = k0
-
-    #         fielddata = self.data.field.new(freq=freq, **self._params)
-    #         fielddata.freq = freq
-    #         fielddata.er = np.squeeze(er[0,0,:])
-    #         fielddata.ur = np.squeeze(ur[0,0,:])
-
-    #         # Recording port information
-    #         for i, port in enumerate(all_ports):
-    #             fielddata.add_port_properties(port.port_number,
-    #                                      mode_number=port.mode_number,
-    #                                      k0 = k0,
-    #                                      beta = port.get_beta(k0),
-    #                                      Z0 = port.portZ0(k0),
-    #                                      Pout= port.power)
-            
-    #         for active_port in all_ports:
-                
-    #             active_port.active = True
-    #             solution = job._fields[active_port.port_number]
-
-    #             fielddata._fields[active_port.port_number] = solution # TODO: THIS IS VERY FRAIL
-    #             fielddata.basis = self.basis
-
-    #             # Compute the S-parameters
-    #             # Define the field interpolation function
-    #             fieldf = self.basis.interpolate_Ef(solution, tetids=all_port_tets)
-
-    #             # Active port power
-    #             logger.debug('Active ports:')
-    #             tris = mesh.get_triangles(active_port.tags)
-    #             tri_vertices = mesh.tris[:,tris]
-    #             pfield, pmode = self._compute_s_data(active_port, fieldf, tri_vertices, k0, ertri[:,:,tris], urtri[:,:,tris])
-    #             logger.debug(f'Field Amplitude = {np.abs(pfield):.3f}, Excitation = {np.abs(pmode):.2f}')
-    #             Pout = pmode
-                
-    #             #Passive ports
-    #             logger.debug('Passive ports:')
-    #             for bc in all_ports:
-    #                 tris = mesh.get_triangles(bc.tags)
-    #                 tri_vertices = mesh.tris[:,tris]
-    #                 pfield, pmode = self._compute_s_data(bc, fieldf, tri_vertices, k0, ertri[:,:,tris], urtri[:,:,tris])
-    #                 logger.debug(f'Field amplitude = {np.abs(pfield):.3f}, Excitation= {np.abs(pmode):.2f}')
-    #                 scalardata.write_S(bc.port_number, active_port.port_number, pfield/Pout)
-
-    #             active_port.active=False
-            
-    #         fielddata.set_field_vector()
-
-    #     logger.info('Simulation Complete!')
-    #     T2 = time.time()    
-    #     logger.info(f'Elapsed time = {(T2-T0):.2f} seconds.')
-    #     return self.data
-## DEPRICATED
-
-
-
-    # 
-    # def eigenmode(self, mesh: Mesh3D, solver = None, num_sols: int = 6):
-    #     if solver is None:
-    #         logger.info('Defaulting to BiCGStab.')
-    #         solver = sparse.linalg.eigs
-
-    #     if self.order == 1:
-    #         logger.info('Detected 1st order elements.')
-    #         from ...elements.nedelec1.assembly import assemble_eig_matrix
-    #         ft = FieldType.VEC_LIN
-
-    #     elif self.order == 2:
-    #         logger.info('Detected 2nd order elements.')
-    #         from ...elements.nedelec2.assembly import assemble_eig_matrix_E
-    #         ft = FieldType.VEC_QUAD
-        
-    #     er = self.mesh.retreive(mesh.centers, lambda mat,x,y,z: mat.fer3d(x,y,z))
-    #     ur = self.mesh.retreive(mesh.centers, lambda mat,x,y,z: mat.fur3d(x,y,z))
-        
-    #     dataset = Dataset3D(mesh, self.frequencies, 0, ft)
-    #     dataset.er = er
-    #     dataset.ur = ur
-    #     logger.info('Solving eigenmodes.')
-        
-    #     f_target = self.frequencies[0]
-    #     sigma = (2 * np.pi * f_target / 299792458)**2
-
-    #     A, B, solvenodes = assemble_eig_matrix(mesh, er, ur, self.boundary_conditions)
-        
-    #     A = A[np.ix_(solvenodes, solvenodes)]
-    #     B = B[np.ix_(solvenodes, solvenodes)]
-    #     #A = sparse.csc_matrix(A)
-    #     #B = sparse.csc_matrix(B)
-        
-    #     w, v = sparse.linalg.eigs(A, k=num_sols, M=B, sigma=sigma, which='LM')
-        
-    #     logger.info(f'Eigenvalues: {np.sqrt(w)*299792458/(2*np.pi) * 1e-9} GHz')
-
-    #     Esol = np.zeros((num_sols, mesh.nfield), dtype=np.complex128)
-
-    #     Esol[:, solvenodes] = v.T
-        
-    #     dataset.set_efield(Esol)
-
-    #     self.basis = dataset
+    def frequency_domain(self, *args, **kwargs):
+        """DEPRICATED VERSION: Use run_sweep() instead.
+        """
+        logger.warning('This function is depricated. Please use run_sweep() instead')
+        self.run_sweep(*args, **kwargs)

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
 
@@ -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)
         """
@@ -458,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/lib.py

@@ -30,10 +30,10 @@ 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=1.0)
-MET_GOLD             = Material(cond=4.10e7,  color=GREY, opacity=0.5)
+MET_GOLD             = Material(cond=4.10e7,  color="#d4af37", 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)
-MET_IRON             = Material(cond=1.04e7,  color=GREY, opacity=0.5)
+MET_IRON             = Material(cond=1.04e7,  color="#aaaaaa", opacity=0.5)
 MET_LEAD             = Material(cond=4.84e6,  color=GREY, opacity=0.5)
 MET_MAGNESIUM        = Material(cond=2.38e7,  color=GREY, opacity=0.5)
 MET_NICKEL           = Material(cond=1.14e7,  color=GREY, opacity=0.5)
@@ -274,6 +274,7 @@ DIEL_ULTRALAM_3850 = Material(er=2.9, tand=0.0025, color="#21912b", opacity=0.3)
 DIEL_XT_Duroid_80000_002IN_Thick = Material(er=3.23, tand=0.0035, color="#21912b", opacity=0.3)
 DIEL_XT_Duroid_8100 = Material(er=3.54, tand=0.0049, color="#21912b", opacity=0.3)
 DIEL_XT_Duroid_81000_004IN_Thick = Material(er=3.32, tand=0.0038, color="#21912b", opacity=0.3)
+DIEL_TEFLON = Material(er=2.1, tand=0.0003, color='#eeeeee', opacity=0.3)
 
 # Legacy FR Materials
 DIEL_FR1 = Material(er=4.8,  tand=0.025, color="#3c9747", opacity=0.3) # Paper + phenolic resin

{emerge-0.5.6.dist-info → emerge-0.6.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emerge
-Version: 0.5.6
+Version: 0.6.1
 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
@@ -64,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()

{emerge-0.5.6.dist-info → emerge-0.6.1.dist-info}/RECORD

@@ -1,8 +1,8 @@
-emerge/__init__.py,sha256=fTLCl-XBjUuatkqGewgn3IJX3kG3nrinr3C7Ioc3ghE,2607
+emerge/__init__.py,sha256=3x0JR1LLC_oNbxA1oBKyGPUPf0oH82MxfwMYvIre5uo,2605
 emerge/__main__.py,sha256=WVf16sfrOI910QWohrQDaChZdRifMNoS6VKzCT6f3ZA,92
 emerge/cli.py,sha256=NU1uhwuZ6i50680v3_I4kDZPTHqz74gOYK71UBhb8oE,666
 emerge/ext.py,sha256=IBoHH5PQFj5pYMfp6r-uMpNNgbSe8c0g9x8qjBzzVmU,223
-emerge/lib.py,sha256=pq8YtX9G-hkUm-CyQl1RvRUyEqOaWJXi9-IadHCqhJg,22316
+emerge/lib.py,sha256=rvUuawdX7-qiKH2p1RwrenN1KBdDeU-MHsAgH7_bYA8,22400
 emerge/plot.py,sha256=AH2D9rKeWUXlSOlh-pUUfLt0oxVLcqF_piki-BmPEg0,83
 emerge/pyvista.py,sha256=-Ht2YcZYsh8-dici5ZPNAWwsis6uz5wNj8n8mxv5fog,42
 emerge/_emerge/__init__.py,sha256=aidfiILy33dt3VyiZ2mgtA87mq-WQ5pXItZUE5wR5ws,703
@@ -14,7 +14,7 @@ emerge/_emerge/cs.py,sha256=efabOj7hK-eG2IYVzhGG08vyvJm2bB9PT04qt5B-BY8,17960
 emerge/_emerge/dataset.py,sha256=UcSAJ_siLrOjNBBWRWsS3GUZUpayp63EM6pP6ClwKDI,1534
 emerge/_emerge/geo2d.py,sha256=e_HkX1GQ2iYrdO0zeEgzVOzfGyU1WGJyjeGBAobOttE,3323
 emerge/_emerge/geometry.py,sha256=xZqgtqWoQpHBd5gSThhWAO24jaFL28aQ1_44NZyPNmQ,18072
-emerge/_emerge/howto.py,sha256=qY3v6DynB9ZBVeYa3sPFq1cDuvf2zyjnLShknqYyvKQ,8208
+emerge/_emerge/howto.py,sha256=vrymIkMcrZsf8UB8rQEvAsHv2rC4nLUgup9nW-BfkcA,8172
 emerge/_emerge/logsettings.py,sha256=DcUWIUUhdLe9ev5XC1bd5ZUrJz00MjABkY8rnekFrPY,3373
 emerge/_emerge/material.py,sha256=HTjQ8wDzkBwYA1sLPRuqR8lPeoXsW-4m5K3yXoKqjXQ,4022
 emerge/_emerge/mesh3d.py,sha256=_MJa_kCZNKCq196UcshA4_GdYIs2FCF76zzXFTSLw3I,34333
@@ -22,7 +22,7 @@ emerge/_emerge/mesher.py,sha256=fKgPb6oZe_bqp0XYfZ6UNgBfRaAS3-tjUtZX8NalJe8,1319
 emerge/_emerge/periodic.py,sha256=xfdKKq3qX7iBBestnRizOzJNfXlpr9lCPkiYhfrRIR8,12013
 emerge/_emerge/plot.py,sha256=cf1I9mj7EIUJcq8vmANlUkqoV6QqVaJaP-zlC-T9E18,8041
 emerge/_emerge/selection.py,sha256=6UizuWC01sUGjFodrGTy8N1J1832vfOWA4u5paNupw4,21297
-emerge/_emerge/simmodel.py,sha256=8EqIavO4GUoJapOChUCXlapsQ4C9ofhRkoFSzDCVlD0,18206
+emerge/_emerge/simmodel.py,sha256=3tCfxaE2tl1PoiNqjB7p69s15wtUD32xRdSQML3IQks,18198
 emerge/_emerge/simulation_data.py,sha256=r9-9lpLeA1Z5HU3jDVOXV1H80GVawnXL5K81_dvmlE4,14506
 emerge/_emerge/solver.py,sha256=PGPI2LuF4XhfyS8KfC-49X9M1mtYUadgHyqopYfPj58,48542
 emerge/_emerge/system.py,sha256=p4HNz7d_LMRNE9Gk75vVdFecDH2iN_groAM9u-yQTpk,1618
@@ -31,15 +31,15 @@ emerge/_emerge/elements/femdata.py,sha256=3rFVz1-PLtqxnDFvTH1Q9dA98lO5VyjcFKecCJ
 emerge/_emerge/elements/index_interp.py,sha256=DlDy2KrhM5QsF6jYQIl4BJndr9F9wnjFMXxlX3ewb4s,2070
 emerge/_emerge/elements/ned2_interp.py,sha256=kMhbjS1fACa1fmhSkQTU35jS3iF63dJcFe5DHl4Xo78,32541
 emerge/_emerge/elements/nedelec2.py,sha256=chU3Ewz7grKZtpyglj2qFJYHvBzCXFQZa1skzjfHoPo,6138
-emerge/_emerge/elements/nedleg2.py,sha256=CehidddpNpeQLSoafvkODm1qotdfb3cu3ENWGivQ7pg,8472
-emerge/_emerge/geo/__init__.py,sha256=ERmbdr8NUnDQWK-E-Bbc4Kl8AQczjpIP5BnwtZmcurE,1102
+emerge/_emerge/elements/nedleg2.py,sha256=qVPKtJpT7UCA5dcI_mXNX7Co4tzVCvlxQv5VtsLuKN8,8468
+emerge/_emerge/geo/__init__.py,sha256=9zITlCRbdzYZ65mA0i-gxEEMV24vWOG9Crb9WGyQOYE,1100
 emerge/_emerge/geo/horn.py,sha256=h4GzGzEkXgWaQgoBMvhFgGsqOrNRB3CJg3RBKXigCz0,4186
-emerge/_emerge/geo/modeler.py,sha256=N8yRtkK0nb3_jjDexpszmSdeElz8g0kuJpqm3vKl1mI,15575
+emerge/_emerge/geo/modeler.py,sha256=gbxmwXAdR7kKW_EFbkd1QPVqJWKJpnTufI7lxaqPyjU,15573
 emerge/_emerge/geo/operations.py,sha256=LKA7_BU4iw6-i6KOUyuL6l10QjXSwnXsixOaTw-M6Vk,9697
-emerge/_emerge/geo/pcb.py,sha256=yhPsU_BgAi1w3FGFtoY8BjXklu2CcKvcbcLMi582x8Q,52209
+emerge/_emerge/geo/pcb.py,sha256=b4FZAwZaO8X2NMnRkYYDUTa8w9ZdN2XfZdmyHhZZaGY,52213
 emerge/_emerge/geo/pmlbox.py,sha256=TNjuyPtuqrAU5Yl8GrLlievuwYf3hUKJaCEz0cXKSzo,7922
 emerge/_emerge/geo/polybased.py,sha256=4J5ExvL-yw4NtA1ZZfIYdj3J5g0vpzq_nlCsIjFQFBU,19473
-emerge/_emerge/geo/shapes.py,sha256=CSXzJPVlTHqtbXeGoZNRm7AjQIShBNU6gCWKDy6mY9Q,18389
+emerge/_emerge/geo/shapes.py,sha256=tPWEzit4sJ-aFWc_FP0mHodx9ohPDbB7IUprFmf1S3k,18378
 emerge/_emerge/geo/step.py,sha256=XcAiEN8W4umNmZdYmrGHX_aJUuiMgc6vgT-UIk8Gbqc,2689
 emerge/_emerge/geo/pcb_tools/calculator.py,sha256=eGYUXdXmHUJCPlfJyY96S87wjeAVFG-e4sPOwbYj0eA,832
 emerge/_emerge/geo/pcb_tools/macro.py,sha256=0g-0anOFyxrEkFobiSu0cwWFRQ32xB8Az24mmwo0z6M,2992
@@ -50,7 +50,7 @@ emerge/_emerge/mth/pairing.py,sha256=i8bBvTeMmzgF0JdiDNJiTXxx913x4f10777pzD6FJo0
 emerge/_emerge/physics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 emerge/_emerge/physics/microwave/__init__.py,sha256=QHeILGYWmvbfLl1o9wrTiWLm0evfXDgS0JiikUoMTts,28
 emerge/_emerge/physics/microwave/adaptive_freq.py,sha256=aWhijhCVAbnuwkru-I1AaRdY20uyozf6OWRIh9r2ijg,9786
-emerge/_emerge/physics/microwave/microwave_3d.py,sha256=VrEvBFoXZctuq1sxO-BV5xlLlakbVG81SpIupR8KPQ8,48969
+emerge/_emerge/physics/microwave/microwave_3d.py,sha256=zKIvFa9WDfDSP6XkYQ-kc_0umZnOIfe0mpBku0piI-4,42000
 emerge/_emerge/physics/microwave/microwave_bc.py,sha256=-fxeZREL42snL4XvXuUqo4QJh24o8lHJ_IcWxkt5yAU,42484
 emerge/_emerge/physics/microwave/microwave_data.py,sha256=6xQL-XaFr1j1OZfCNltODXxXlXAZ9ghEaNKW7nHKCis,43889
 emerge/_emerge/physics/microwave/periodic.py,sha256=wYSUgLFVtCLqSG3EDKoCDRU93iPUzBdXzVRdHTRmbpI,3000
@@ -67,19 +67,19 @@ emerge/_emerge/physics/microwave/assembly/periodicbc.py,sha256=Zg1kgQMccDQA2oVEr
 emerge/_emerge/physics/microwave/assembly/robinbc.py,sha256=syJ-NuHHA0WDQECuaPdeW-OfzIGHmxxqalKiokSyJFI,17742
 emerge/_emerge/plot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 emerge/_emerge/plot/display.py,sha256=TQLlKb-LkaG5ZOSLfxp9KXPlZPRFTxNj1LhVQ-Lp1-s,18476
-emerge/_emerge/plot/simple_plots.py,sha256=95wkxkK1x-fL7Cb8ioeMe3QAUAnTy9wNIkZCVOhSrwY,18751
+emerge/_emerge/plot/simple_plots.py,sha256=qopwJviG36JC48Flioq2whS_ktvPtG_8h3X9noUbo9I,24462
 emerge/_emerge/plot/matplotlib/mpldisplay.py,sha256=szKafDrgdAW5Nyc5UOHuJC87n0WGkXYackOVv182TDQ,8671
 emerge/_emerge/plot/pyvista/__init__.py,sha256=CPclatEu6mFnJZzCQk09g6T6Fh20WTbiLAJGSwAnPXU,30
 emerge/_emerge/plot/pyvista/display.py,sha256=L7_cy7C6EnIIj_-V5E_-j5ORJtIXscvYCmBE03-eCK4,34692
 emerge/_emerge/plot/pyvista/display_settings.py,sha256=K2OhzKqeFzMXlEfZ5F4CQ9sN3l7nOgVjLplZBuMPjvE,899
 emerge/_emerge/projects/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-emerge/_emerge/projects/_gen_base.txt,sha256=_4McYD9Sb1KWRsrGV51mNNAJNYkjm_IemMnCdAsGuLo,607
-emerge/_emerge/projects/_load_base.txt,sha256=JTAhWvHXJQYKe-aDD4HDdmE7f3VXxeurhDzwFCegrEg,511
+emerge/_emerge/projects/_gen_base.txt,sha256=DqQz36PZg6v1ovQjHvPjd0t4AIbmikZdb9dmrNYsK3w,598
+emerge/_emerge/projects/_load_base.txt,sha256=94o0eSWoDKlNR336EmhpG_S5syQHIUPHQxna-bVRhXo,509
 emerge/_emerge/projects/generate_project.py,sha256=TNw-0SpLc82MBq0bd9hB_yqvBZCgmuPonCBsHTp91uk,1450
 emerge/_emerge/solve_interfaces/cudss_interface.py,sha256=-SjiTNIyE7iJ8Bm14Cva5e2lpJDgfiS2Mvz1Bgy-UL4,9688
 emerge/_emerge/solve_interfaces/pardiso_interface.py,sha256=iVFxToMmIzhj3hcAP-O_MDHKz82ePFIHY1us11kzUBU,15305
-emerge-0.5.6.dist-info/METADATA,sha256=diytWp8I8KQK9QPRZHJBLkINkULanPmXoHJfQX_bl3Y,3340
-emerge-0.5.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-emerge-0.5.6.dist-info/entry_points.txt,sha256=8rFvAXticpKg4OTC8JEvAksnduW72KIEskCGG9XnFf8,43
-emerge-0.5.6.dist-info/licenses/LICENSE,sha256=SuHm9Fw32RI6tylP2YCyTPITMwpueazVUZwUMFRE_zk,17856
-emerge-0.5.6.dist-info/RECORD,,
+emerge-0.6.1.dist-info/METADATA,sha256=VbKhuz6FjO80hwmfdU6zFPpOu5_V3fikDkYyfgi0AXE,3333
+emerge-0.6.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+emerge-0.6.1.dist-info/entry_points.txt,sha256=8rFvAXticpKg4OTC8JEvAksnduW72KIEskCGG9XnFf8,43
+emerge-0.6.1.dist-info/licenses/LICENSE,sha256=SuHm9Fw32RI6tylP2YCyTPITMwpueazVUZwUMFRE_zk,17856
+emerge-0.6.1.dist-info/RECORD,,