emerge 1.0.6__py3-none-any.whl → 1.0.7__py3-none-any.whl

emerge/_emerge/physics/microwave/microwave_3d.py

@@ -19,7 +19,7 @@ from ...mesher import Mesher
 from ...material import Material
 from ...mesh3d import Mesh3D
 from ...coord import Line
-from ...geometry import GeoSurface
+from ...geometry import GeoSurface, _GEOMANAGER
 from ...elements.femdata import FEMBasis
 from ...elements.nedelec2 import Nedelec2
 from ...solver import DEFAULT_ROUTINE, SolveRoutine
@@ -140,11 +140,13 @@ class Microwave3D:
     def reset_data(self):
         self.data = MWData()
 
-    def reset(self):
-        self.bc.reset()
+    def reset(self, _reset_bc: bool = True):
+        if _reset_bc:
+            self.bc.reset()
+            self.bc = MWBoundaryConditionSet(None)
         self.basis: FEMBasis = None
-        self.bc = MWBoundaryConditionSet(None)
         self.solveroutine.reset()
+        self.assembler.cached_matrices = None
 
     def set_order(self, order: int) -> None:
         """Sets the order of the basis functions used. Currently only supports second order.
@@ -401,8 +403,10 @@ class Microwave3D:
             raise ValueError('The field basis is not yet defined.')
 
         logger.debug(' - Finding PEC TEM conductors')
-        pecs: list[PEC] = self.bc.get_conductors() # type: ignore
         mesh = self.mesh
+        
+        # Find all BC conductors
+        pecs: list[PEC] = self.bc.get_conductors() # type: ignore
 
         # Process all PEC Boundary Conditions
         pec_edges = []
@@ -418,19 +422,37 @@ class Microwave3D:
                 edge_ids = list(mesh.tri_to_edge[:,itri].flatten())
                 pec_edges.extend(edge_ids)
 
+        # All PEC edges
         pec_edges = list(set(pec_edges))
         
+        # Port mesh data
         tri_ids = mesh.get_triangles(port.tags)
         edge_ids = list(mesh.tri_to_edge[:,tri_ids].flatten())
         
-        pec_port = np.array([i for i in pec_edges if i in set(edge_ids)])
+        port_pec_edges = np.array([i for i in pec_edges if i in set(edge_ids)])
         
-        pec_islands = mesh.find_edge_groups(pec_port)
+        pec_islands = mesh.find_edge_groups(port_pec_edges)
 
+        
         logger.debug(f' - Found {len(pec_islands)} PEC islands.')
 
         if len(pec_islands) != 2:
-            raise ValueError(f' - Found {len(pec_islands)} PEC islands. Expected 2.')
+            pec_island_tags = {i: self.mesh._get_dimtags(edges=pec_edge_group) for i,pec_edge_group in enumerate(pec_islands)}
+            plus_term = None
+            min_term = None
+            
+            for i, dimtags in pec_island_tags.items():
+                if not set(dimtags).isdisjoint(port.plus_terminal):
+                    plus_term = i
+                
+                if not set(dimtags).isdisjoint(port.minus_terminal):
+                    min_term = i
+            
+            if plus_term is None or min_term is None:
+                raise ValueError(f' - Found {len(pec_islands)} PEC islands without a terminal definition. Please use .set_terminals() to define which conductors are which polarity.')    
+            logger.debug(f'Positive island = {pec_island_tags[plus_term]}')
+            logger.debug(f'Negative island = {pec_island_tags[min_term]}')
+            pec_islands = [pec_islands[plus_term], pec_islands[min_term]]
         
         groups = []
         for island in pec_islands:
@@ -603,6 +625,7 @@ class Microwave3D:
             elif TEM:
                 G1, G2 = self._find_tem_conductors(port, sigtri=cond)
                 cs, dls = self._compute_integration_line(G1,G2)
+                logger.debug(f'Integrating portmode from {cs[:,0]} to {cs[:,-1]}')
                 mode.modetype = 'TEM'
                 Ex, Ey, Ez = portfE(cs[0,:], cs[1,:], cs[2,:])
                 voltage = np.sum(Ex*dls[0,:] + Ey*dls[1,:] + Ez*dls[2,:])
@@ -835,6 +858,100 @@ class Microwave3D:
         self._post_process(results, matset)
         return self.data
     
+    def _run_adaptive_mesh(self,
+                iteration: int, 
+                frequency: float,
+                automatic_modal_analysis: bool = True) -> MWData:
+        """Executes a frequency domain study
+
+        The study is distributed over "n_workers" workers.
+        As optional parameter you may set a harddisc_threshold as integer. This determines the maximum
+        number of degrees of freedom before which the jobs will be cahced to the harddisk. The
+        path that will be used to cache the sparse matrices can be specified.
+        Additionally the term frequency_groups may be specified. This number will define in how
+        many groups the matrices will be pre-computed before they are send to workers. This can minimize
+        the total amound of RAM memory used. For example with 11 frequencies in gruops of 4, the following
+        frequency indices will be precomputed and then solved: [[1,2,3,4],[5,6,7,8],[9,10,11]]
+
+        Args:
+            iteration (int): The iteration number
+            frequency (float): The simulation frequency
+
+        Raises:
+            SimulationError: An error associated witha a problem during the simulation.
+
+        Returns:
+            MWSimData: The dataset.
+        """
+        
+        self._simstart = time.time()
+        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()
+        self._check_physics()
+        
+        if self.basis is None:
+            raise SimulationError('Cannot proceed, the simulation basis class is undefined.')
+
+        materials = self.mesh._get_material_assignment(self.mesher.volumes)
+
+        ### Does this move
+        logger.debug('Initializing single frequency settings.')
+        
+        #### Port settings
+        all_ports = self.bc.oftype(PortBC)
+
+        ##### FOR PORT SWEEP SET ALL ACTIVE TO FALSE. THIS SHOULD BE FIXED LATER
+        ### COMPUTE WHICH TETS ARE CONNECTED TO PORT INDICES
+
+        for port in all_ports:
+            port.active=False
+    
+    
+        def run_job_single(job: SimJob):
+            for A, b, ids, reuse, aux in job.iter_Ab():
+                solution, report = self.solveroutine.solve(A, b, ids, reuse, id=job.id)
+                report.add(**aux)
+                job.submit_solution(solution, report)
+            return job
+        
+        
+        matset: list[tuple[np.ndarray, np.ndarray, np.ndarray]] = []     
+
+        self._compute_modes(frequency)
+
+        logger.debug(f'Simulation frequency = {frequency/1e9:.3f} GHz') 
+        
+        if automatic_modal_analysis:
+            self._compute_modes(frequency)
+            
+        job, mats = self.assembler.assemble_freq_matrix(self.basis, materials, 
+                                                self.bc.boundary_conditions, 
+                                                frequency, 
+                                                cache_matrices=self.cache_matrices)
+
+        job.id = 0
+
+        logger.info('Starting solve')
+        job = run_job_single(job)
+
+    
+        logger.info('Solving complete')
+
+        self.data.setreport(job.reports, freq=frequency, **self._params)
+
+        for variables, data in self.data.sim.iterate():
+            logger.trace(f'Sim variable: {variables}')
+            for item in data['report']:
+                item.logprint(logger.trace)
+
+        self.solveroutine.reset()
+        ### Compute S-parameters and return
+        self._post_process([job,], [mats,])
+        return self.data
+    
     def eigenmode(self, search_frequency: float,
                         nmodes: int = 6,
                         k0_limit: float = 1,
@@ -868,10 +985,6 @@ class Microwave3D:
 
         materials = self.mesh._get_material_assignment(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.')
             

emerge/_emerge/physics/microwave/microwave_bc.py

@@ -73,7 +73,6 @@ class MWBoundaryConditionSet(BoundaryConditionSet):
         for bc in self.oftype(SurfaceImpedance):
             if bc.sigma > 10.0:
                 bcs.append(bc)
-
         return bcs
         
     def get_type(self, bctype: Literal['PEC','ModalPort','LumpedPort','PMC','LumpedElement','RectangularWaveguide','Periodic','FloquetPort','SurfaceImpedance']) -> FaceSelection:
@@ -497,6 +496,8 @@ class ModalPort(PortBC):
         self._first_k0: float | None = None
         self._last_k0: float | None = None
         
+        self.plus_terminal: list[tuple[int, int]] = []
+        self.minus_terminal: list[tuple[int, int]] = []
 
         if cs is None:
             logger.info('Constructing coordinate system from normal port')
@@ -522,6 +523,26 @@ class ModalPort(PortBC):
             *axes (tuple, np.ndarray, Axis): The alignment vectors.
         """ 
         self.alignment_vectors = [_parse_axis(ax) for ax in axes]
+    
+    def set_terminals(self, positive: Selection | GeoObject | None = None,
+                      negative: Selection | GeoObject | None = None,
+                      ground: Selection | GeoObject | None = None) -> None:
+        """Define which objects/faces/selection should be assigned the positive terminal
+        and which one the negative terminal.
+        
+        The terminal assignment will be used to find an integration line for the impedance calculation.
+
+        Note: Ground is currently unused.
+        
+        Args:
+            positive (Selection | GeoObject | None, optional): The postive terminal. Defaults to None.
+            negative (Selection | GeoObject | None, optional): The negative terminal. Defaults to None.
+            ground (Selection | GeoObject | None, optional): _description_. Defaults to None.
+        """
+        if positive is not None:
+            self.plus_terminal = positive.dimtags
+        if negative is not None:
+            self.minus_terminal = negative.dimtags
         
     @property
     def nmodes(self) -> int:
@@ -569,9 +590,10 @@ class ModalPort(PortBC):
         Returns:
             PortMode: The requested PortMode object
         """
+        options = self.modes[min(self.modes.keys(), key=lambda k: abs(k - k0))]
         if i is None:
-            i = self.selected_mode
-        return self.modes[min(self.modes.keys(), key=lambda k: abs(k - k0))][i]
+            i = min(len(options)-1, self.selected_mode)
+        return options[i]
     
     def global_field_function(self, k0: float = 0, which: Literal['E','H'] = 'E') -> Callable:
         ''' The field function used to compute the E-field. 

emerge/_emerge/physics/microwave/microwave_data.py

@@ -18,7 +18,7 @@
 from __future__ import annotations
 from ...simulation_data import BaseDataset, DataContainer
 from ...elements.femdata import FEMBasis
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 import numpy as np
 from typing import Literal
 from loguru import logger
@@ -372,6 +372,7 @@ class EHField:
     freq: float
     er: np.ndarray
     ur: np.ndarray
+    aux: dict[str, np.ndarray] = field(default_factory=dict)
 
     @property
     def k0(self) -> float:
@@ -537,7 +538,7 @@ class EHField:
         
         return self.x, self.y, self.z, Fx, Fy, Fz
     
-    def scalar(self, field: Literal['Ex','Ey','Ez','Hx','Hy','Hz','normE','normH'], metric: Literal['abs','real','imag','complex'] = 'real') -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    def scalar(self, field: Literal['Ex','Ey','Ez','Hx','Hy','Hz','normE','normH'] | str, metric: Literal['abs','real','imag','complex'] = 'real') -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
         """Returns the data X, Y, Z, Field based on the interpolation
 
         For animations, make sure to select the complex metric.
@@ -549,7 +550,11 @@ class EHField:
         Returns:
             (X,Y,Z,Field): The coordinates plus field scalar
         """
-        field_arry = getattr(self, field)
+        if field in self.aux:
+            field_arry = self.aux[field]
+        else:
+            field_arry = getattr(self, field)
+        
         if metric=='abs':
             field = np.abs(field_arry)
         elif metric=='real':
@@ -666,6 +671,10 @@ class MWField:
         self.excitation = {key: 0.0 for key in self._fields.keys()}
         self.excitation[self.port_modes[0].port_number] = 1.0 + 0j
 
+    def excite_port(self, number: int) -> None:
+        self.excitation = {key: 0.0 for key in self._fields.keys()}
+        self.excitation[self.port_modes[number].port_number] = 1.0 + 0j
+        
     @property
     def EH(self) -> tuple[np.ndarray, np.ndarray]:
         ''' Return the electric and magnetic field as a tuple of numpy arrays '''
@@ -726,12 +735,20 @@ class MWField:
         self.Hx = Hx.reshape(shp)
         self.Hy = Hy.reshape(shp)
         self.Hz = Hz.reshape(shp)
-
+        
         self._x = xs
         self._y = ys
         self._z = zs
-        return EHField(xs, ys, zs, self.Ex, self.Ey, self.Ez, self.Hx, self.Hy, self.Hz, self.freq, self.er, self.ur)
-
+        field = EHField(xs, ys, zs, self.Ex, self.Ey, self.Ez, self.Hx, self.Hy, self.Hz, self.freq, self.er, self.ur)
+        
+        return field
+    
+    def _solution_quality(self) -> tuple[np.ndarray, np.ndarray]:
+        from .adaptive_mesh import compute_error_estimate
+        
+        error_tet, max_elem_size = compute_error_estimate(self)
+        return error_tet, max_elem_size
+        
     def boundary(self,
                  selection: FaceSelection) -> EHField:
         nodes = self.mesh.nodes

emerge/_emerge/plot/pyvista/display.py

@@ -539,7 +539,7 @@ class PVDisplay(BaseDisplay):
                      XYZ=None,
                      field: Literal['E','H'] = 'E', 
                      k0: float | None = None,
-                     mode_number: int = 0) -> None:
+                     mode_number: int | None = None) -> None:
         
         if XYZ:
             X,Y,Z = XYZ
@@ -584,7 +584,10 @@ class PVDisplay(BaseDisplay):
                 k0 = port.get_mode(0).k0
             else:
                 k0 = 1
-        port.selected_mode = mode_number
+        
+        if isinstance(mode_number, int):
+            port.selected_mode = mode_number
+        
         F = port.port_mode_3d_global(xf,yf,zf,k0, which=field)
 
         Fx = F[0,:].reshape(X.shape).T

emerge/_emerge/simmodel.py

@@ -547,7 +547,7 @@ class Simulation:
         self._set_mesh(dataset['mesh'])
         return self
         
-    def generate_mesh(self) -> None:
+    def generate_mesh(self, regenerate: bool = False) -> None:
         """Generate the mesh. 
         This can only be done after commit_geometry(...) is called and if frequencies are defined.
 
@@ -557,26 +557,27 @@ class Simulation:
         Raises:
             ValueError: ValueError if no frequencies are defined.
         """
-        logger.trace('Starting mesh generation phase.')
-        if not self._defined_geometries:
-            self.commit_geometry()
-        
-        logger.trace(' (1) Installing periodic boundaries in mesher.')
-        # Set the cell periodicity in GMSH
-        if self._cell is not None:
-            self.mesher.set_periodic_cell(self._cell)
-        
-        self.mw._initialize_bcs(_GEOMANAGER.get_surfaces())
+        if not regenerate:
+            logger.trace('Starting mesh generation phase.')
+            if not self._defined_geometries:
+                self.commit_geometry()
+            
+            logger.trace(' (1) Installing periodic boundaries in mesher.')
+            # Set the cell periodicity in GMSH
+            if self._cell is not None:
+                self.mesher.set_periodic_cell(self._cell)
+            
+            self.mw._initialize_bcs(_GEOMANAGER.get_surfaces())
 
-        # Check if frequencies are defined: TODO: Replace with a more generic check
-        if self.mw.frequencies is None:
-            raise ValueError('No frequencies defined for the simulation. Please set frequencies before generating the mesh.')
+            # Check if frequencies are defined: TODO: Replace with a more generic check
+            if self.mw.frequencies is None:
+                raise ValueError('No frequencies defined for the simulation. Please set frequencies before generating the mesh.')
 
         gmsh.model.occ.synchronize()
 
         # Set the mesh size
         self.mesher._configure_mesh_size(self.mw.get_discretizer(), self.mw.resolution)
-        
+            
         logger.trace(' (2) Calling GMSH mesher')
         try:
             gmsh.logger.start()
@@ -589,6 +590,7 @@ class Simulation:
             logger.error('GMSH Mesh error detected.')
             print(_GMSH_ERROR_TEXT)
             raise
+        
         logger.info('GMSH Meshing complete!')
         self.mesh._pre_update(self.mesher._get_periodic_bcs())
         self.mesh.exterior_face_tags = self.mesher.domain_boundary_face_tags
@@ -596,6 +598,14 @@ class Simulation:
         self._set_mesh(self.mesh)
         logger.trace(' (3) Mesh routine complete')
 
+    def _reset_mesh(self):
+        #gmsh.clear()
+        gmsh.model.mesh.clear()
+        mesh = Mesh3D(self.mesher)
+        
+        self.mw.reset(False)
+        self._set_mesh(mesh)
+        
     def parameter_sweep(self, clear_mesh: bool = True, **parameters: np.ndarray) -> Generator[tuple[float,...], None, None]:
         """Executes a parameteric sweep iteration.
 
@@ -654,6 +664,67 @@ class Simulation:
         
         self.mw.cache_matrices = True
     
+    
+    def _beta_adaptive_mesh_refinement(self, 
+                                 max_steps: int = 6,
+                                 convergence: float = 0.02,
+                                 refinement_percentage: float = 0.1,
+                                 refinement_ratio: float = 0.3,
+                                 growth_rate: float = 3) -> None:
+        """Beta implementation of Adaptive Mesh Refinement
+
+        Args:
+            max_steps (int, optional): _description_. Defaults to 6.
+            convergence (float, optional): _description_. Defaults to 0.02.
+            refinement_percentage (float, optional): _description_. Defaults to 0.1.
+            refinement_ratio (float, optional): _description_. Defaults to 0.3.
+            growth_rate (float, optional): _description_. Defaults to 3.
+        """
+        from .physics.microwave.adaptive_mesh import select_refinement_indices, reduce_point_set, compute_convergence
+   
+        max_freq = np.max(self.mw.frequencies)
+        
+        regenerate = False
+        
+        Smats = []
+
+        for step in range(max_steps):
+            amr_params = dict(iter_step=step)
+            self.mw._params = amr_params
+            self.data.sim.new(**amr_params)
+            
+            
+            data = self.mw._run_adaptive_mesh(step, max_freq)
+            
+            field = data.field[-1]
+            
+            Smat_new = data.scalar[-1].Sp
+            Smats.append(Smat_new)
+            if step > 0:
+                S0 = Smats[-2]
+                S1 = Smats[-1]
+                conv = compute_convergence(S0, S1)
+                logger.info(f'Convergence = {conv}')
+                if conv < convergence:
+                    logger.info('Mesh refinement passed!')
+                    break
+            error, lengths = field._solution_quality()
+                
+            idx = select_refinement_indices(error, refinement_percentage)
+            
+            idx = idx[reduce_point_set(self.mw.mesh.centers[:,idx], growth_rate, lengths[idx], refinement_ratio)]
+            centers = self.mw.mesh.centers
+            
+            self.mesher._reset_amr_points()
+            self._reset_mesh()
+            logger.debug(f'Adding {len(idx)} refinement points.')
+            for i in idx:
+                coord = centers[:,i]
+                size = lengths[i]
+                self.mesher.add_refinement_point(coord, refinement_ratio, size, growth_rate)
+            
+            self.generate_mesh(True)            
+            self.view(plot_mesh=True)
     def export(self, filename: str):
         """Exports the model or mesh depending on the extension. 
         

emerge/_emerge/solver.py

@@ -343,7 +343,7 @@ class Solver:
         return None
 
     def duplicate(self) -> Solver:
-        return self.__class__()
+        return self.__class__(self.pre)
 
     def set_options(self, pivoting_threshold: float | None = None) -> None:
         """Write generic simulation options to the solver object. 

{emerge-1.0.6.dist-info → emerge-1.0.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emerge
-Version: 1.0.6
+Version: 1.0.7
 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
@@ -11,7 +11,8 @@ Requires-Dist: joblib>=1.5.1
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: matplotlib>=3.8.0
 Requires-Dist: mkl!=2024.0; platform_machine == 'x86_64' or platform_machine == 'AMD64'
-Requires-Dist: numba>=0.57.0
+Requires-Dist: numba<=0.60.0,>=0.57.0; platform_system == 'Linux'
+Requires-Dist: numba>=0.57.0; platform_system != 'Linux'
 Requires-Dist: numpy<2.3,>=1.24
 Requires-Dist: pyvista>=0.45.2
 Requires-Dist: scipy>=1.14.0

{emerge-1.0.6.dist-info → emerge-1.0.7.dist-info}/RECORD

@@ -1,4 +1,4 @@
-emerge/__init__.py,sha256=m1aBdjv_Ae2k7RzIgtl-5CMEH5FQmWw28SOk0V_ro0Y,3162
+emerge/__init__.py,sha256=xexiF7GihNOUHqPZ2KViJFFaNNfRyc6l3Qz1PzWO_5w,3162
 emerge/__main__.py,sha256=WVf16sfrOI910QWohrQDaChZdRifMNoS6VKzCT6f3ZA,92
 emerge/cli.py,sha256=NU1uhwuZ6i50680v3_I4kDZPTHqz74gOYK71UBhb8oE,666
 emerge/ext.py,sha256=IBoHH5PQFj5pYMfp6r-uMpNNgbSe8c0g9x8qjBzzVmU,223
@@ -17,20 +17,20 @@ emerge/_emerge/geo2d.py,sha256=e_HkX1GQ2iYrdO0zeEgzVOzfGyU1WGJyjeGBAobOttE,3323
 emerge/_emerge/geometry.py,sha256=9WnZt2xtF4HEJfdPyT41i_q8gRMZRrG0C9PILaz1PvA,25523
 emerge/_emerge/howto.py,sha256=c4UxUNpA1tygr3OoR-LH-h0UZv-Tf9K8tpCiAU18BKE,8173
 emerge/_emerge/logsettings.py,sha256=OpsH_1dQAdZry_as8y0OQt4yKP_AMFfQG2d5Nz5yywg,4789
-emerge/_emerge/material.py,sha256=zXmKEZctqz4T574KSfRMdhiT2F_6l-QwiqlxNx6zkI0,17451
-emerge/_emerge/mesh3d.py,sha256=6NWTqJVwyaOhFKQgNghkH3zgrYFWbI0qAEBpvq-JOwI,35790
-emerge/_emerge/mesher.py,sha256=AUrMhXHHf1O5QtEyKlB172kV0B17jq9nzjq4JADZTV4,16079
+emerge/_emerge/material.py,sha256=furDHD4rwkYCOjnh0GLz-Utjl5Z_NxDv0zWrk23Pygc,17459
+emerge/_emerge/mesh3d.py,sha256=zPKOo1whf6yBpJxfEt89p3LXO4k1j7LSSMAGCDSK318,36946
+emerge/_emerge/mesher.py,sha256=Ozks6t0LbdWEfDuh_06Hmm9nZz8vQLJl2FsYA7wzMMo,16854
 emerge/_emerge/periodic.py,sha256=dUuWqjlDR8mHtQR3ecINP2FFjJJ0cKg0blOVZ0PCcAo,12087
 emerge/_emerge/plot.py,sha256=cf1I9mj7EIUJcq8vmANlUkqoV6QqVaJaP-zlC-T9E18,8041
 emerge/_emerge/selection.py,sha256=ltT8ubMFG3-sFrAh7K7iAgSoBt3r25B02ShzMlOGSXQ,21527
 emerge/_emerge/settings.py,sha256=wZFMzQSnMEEJptatu--67El1L0I_YEv9S8QjqI69bfs,265
-emerge/_emerge/simmodel.py,sha256=yw21pUhO2_BB3vTN4UY7fhZxXuWNvcTaA5xRCcUg7vs,26525
+emerge/_emerge/simmodel.py,sha256=Iu971xxJ5ggeB-KkrtxmGyV_-zHQN76z8_w1nSwpWJY,29371
 emerge/_emerge/simulation_data.py,sha256=23o-xbm6Q6s9sYisyK9u1GTmuaXRl0WDGQwzPO7lkr0,15115
-emerge/_emerge/solver.py,sha256=imgvQkVE9B3QEA1WmsBhhOLzHO44-Oh-onMXmLnfCFY,52980
+emerge/_emerge/solver.py,sha256=3P-pcDWEpCEVnT2iFRRzC1hdYGUaz-xRzE68G3xvF1Q,52988
 emerge/_emerge/system.py,sha256=p4HNz7d_LMRNE9Gk75vVdFecDH2iN_groAM9u-yQTpk,1618
 emerge/_emerge/elements/__init__.py,sha256=I3n9aic6lJW-oGeqTEZ-Fpxvyl2i-WqsHdnrM3v1oB8,799
 emerge/_emerge/elements/femdata.py,sha256=ZSB7dICyU3GOWbxpuowBc-Khh2mpXa02ZfMkHwdDol4,8377
-emerge/_emerge/elements/index_interp.py,sha256=02CTHaokaAepBRvt7cHVwh3EpOA3sVE3qvEAkDjmwro,2072
+emerge/_emerge/elements/index_interp.py,sha256=X7WcXKC9Qg7UABvLbAktda7InRkOhm7qOU-Wnefflp4,3381
 emerge/_emerge/elements/ned2_interp.py,sha256=BGRdJGXCcDdqMBf3pOvc_-m-vngRI1VvE5MUsqqf9Cw,27981
 emerge/_emerge/elements/nedelec2.py,sha256=OssFCnPp7wkMBcUISGvTgT94jayfGOmX0x-RctIYSuI,6645
 emerge/_emerge/elements/nedleg2.py,sha256=1SA6AvnbChhU2iodS1PVMUdbSn9wF2XKam12WTBDtsw,9049
@@ -54,16 +54,17 @@ emerge/_emerge/mth/pairing.py,sha256=i8bBvTeMmzgF0JdiDNJiTXxx913x4f10777pzD6FJo0
 emerge/_emerge/physics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 emerge/_emerge/physics/microwave/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 emerge/_emerge/physics/microwave/adaptive_freq.py,sha256=aWhijhCVAbnuwkru-I1AaRdY20uyozf6OWRIh9r2ijg,9786
-emerge/_emerge/physics/microwave/microwave_3d.py,sha256=mnfD6QPNVqtMMayu73yRdvErqL2-mPSqiKbOte9a3GQ,44632
-emerge/_emerge/physics/microwave/microwave_bc.py,sha256=bMV3SrIE5BNTdBbTncwy0N67TERsYWzzFypzFgDBW54,43697
-emerge/_emerge/physics/microwave/microwave_data.py,sha256=yAjWGzpTa14JfYKJVMMwx3ETONK_mjYRz98iDKEdDk8,49893
+emerge/_emerge/physics/microwave/adaptive_mesh.py,sha256=bcPPbWoTaMsLK1QCIL6an5WaIIeKddCPPs2u7vKfAEs,22089
+emerge/_emerge/physics/microwave/microwave_3d.py,sha256=OxZ3uJI1hhyGuUPV6ofWXCQfCu23URkyK2UJnpa9CLI,49141
+emerge/_emerge/physics/microwave/microwave_bc.py,sha256=70zrxTZG_i9n2vBQAU1FOtK2Ia_KMi3qQeC9MU5aDHo,44872
+emerge/_emerge/physics/microwave/microwave_data.py,sha256=eSWBrFmdYnOmCchf31jORwCriq2Ix1piGoGYHsvcF38,50551
 emerge/_emerge/physics/microwave/periodic.py,sha256=wYSUgLFVtCLqSG3EDKoCDRU93iPUzBdXzVRdHTRmbpI,3000
 emerge/_emerge/physics/microwave/port_functions.py,sha256=d-W1D-7P05MfXdOs7WlhPi_RqlSpC0HkYU6yl3GrxgE,2173
 emerge/_emerge/physics/microwave/sc.py,sha256=WZvoPhmHkfEv619RhmN09sXDBV0ryTqybwErA8Rc7lU,4735
 emerge/_emerge/physics/microwave/simjob.py,sha256=aCWCs7IXBfVBWWYhwyHvXSRHY3FOd3CK5ABcaFEsNnM,4927
 emerge/_emerge/physics/microwave/sparam.py,sha256=1SXGyr1UsrPnCIi4ffwobM4pzgkj50y4LrWCr_J5IRY,4946
 emerge/_emerge/physics/microwave/touchstone.py,sha256=pMcCOLWVqIKctcShcJxyaV-0rhRWXMSS1Jz14dVQEyY,5799
-emerge/_emerge/physics/microwave/assembly/assembler.py,sha256=sNsAa2bTSe9-tYMRePTOE2EKrqZhsJChD_anr4GC4Vo,23936
+emerge/_emerge/physics/microwave/assembly/assembler.py,sha256=ZRaf_5zSZ2U0D5DmuYKCiyyxjonJLQV5pYsUm6aChj0,23982
 emerge/_emerge/physics/microwave/assembly/curlcurl.py,sha256=4CwMSUua8pvbp39gq2e3AxwVHOIVuPdr53qQM2BigQo,19688
 emerge/_emerge/physics/microwave/assembly/generalized_eigen.py,sha256=7jNU_hWd7q-ni53wmlhB5kmyJxp2xsx_WyBXZ6hPwo0,16907
 emerge/_emerge/physics/microwave/assembly/generalized_eigen_hb.py,sha256=tGf9EOzmp-dqtTodwYzcswuT_eLeZRtgdAZvgPz9QJo,17340
@@ -76,7 +77,7 @@ emerge/_emerge/plot/simple_plots.py,sha256=szIpmQmO8o6ubzB_E3zTJfEx16mJ3-OXrMYdD
 emerge/_emerge/plot/matplotlib/mpldisplay.py,sha256=e8V6EhGdCW7nRkSFvjHCcRO5uR-FcD0yHQ1nxPQCbp4,8674
 emerge/_emerge/plot/pyvista/__init__.py,sha256=CPclatEu6mFnJZzCQk09g6T6Fh20WTbiLAJGSwAnPXU,30
 emerge/_emerge/plot/pyvista/cmap_maker.py,sha256=_GVXYdtXpJwAO9O-Iekjzn6YcR0MVT8LNh12nqvF2IA,2498
-emerge/_emerge/plot/pyvista/display.py,sha256=k5hkIGZCyzYXw1zdDtWCDRwm2dwO0Xz8Sw9YTGGPo5k,45356
+emerge/_emerge/plot/pyvista/display.py,sha256=nsiElERHYZPWX0uHwNoaocvfGtVTMsBdaO3hjTVDPvk,45429
 emerge/_emerge/plot/pyvista/display_settings.py,sha256=gV5hjRGEAl3oQeBPobas6b6JzYfMFrXIGtVSaeml4N0,1074
 emerge/_emerge/projects/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 emerge/_emerge/projects/_gen_base.txt,sha256=DqQz36PZg6v1ovQjHvPjd0t4AIbmikZdb9dmrNYsK3w,598
@@ -88,8 +89,8 @@ emerge/beta/dxf.py,sha256=Bw4lVk0TquOgCxTZV23BZN7PrgqxBrMZxbHV1waC5U0,50
 emerge/materials/__init__.py,sha256=Z9tu3m_nqj6F9I-FwoVoN0vCTYUlFesH3KxJ38wkZck,19
 emerge/materials/isola.py,sha256=kSDxHJZVn2CcanoUjlwRVKIPvadRbBybURTdIHWx728,18660
 emerge/materials/rogers.py,sha256=4u6ma_XQdXGKWE3WsFkaMTamCQNo9kTYSTU8S1gCAYU,3388
-emerge-1.0.6.dist-info/METADATA,sha256=wJysFFkQJJgPoC2pdAtzEvWLsMPB-usHAQweDuNwPqk,3306
-emerge-1.0.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-emerge-1.0.6.dist-info/entry_points.txt,sha256=8rFvAXticpKg4OTC8JEvAksnduW72KIEskCGG9XnFf8,43
-emerge-1.0.6.dist-info/licenses/LICENSE,sha256=VOCXWddrjMN5j7TvnSAOh1Dx7jkugdwq9Lqhycf5inc,17852
-emerge-1.0.6.dist-info/RECORD,,
+emerge-1.0.7.dist-info/METADATA,sha256=tv3bFqll_HiWD6MDGr2K5tUC4Vy97vCO84EKQ2iGkQU,3400
+emerge-1.0.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+emerge-1.0.7.dist-info/entry_points.txt,sha256=8rFvAXticpKg4OTC8JEvAksnduW72KIEskCGG9XnFf8,43
+emerge-1.0.7.dist-info/licenses/LICENSE,sha256=VOCXWddrjMN5j7TvnSAOh1Dx7jkugdwq9Lqhycf5inc,17852
+emerge-1.0.7.dist-info/RECORD,,