emerge 1.1.0__py3-none-any.whl → 1.1.1__py3-none-any.whl

emerge/_emerge/physics/microwave/assembly/assembler.py

@@ -273,13 +273,17 @@ class Assembler:
 
         logger.debug('Implementing PEC Boundary Conditions.')
         pec_ids: list[int] = []
+        pec_tris: list[int] = []
         
         # Conductivity above al imit, consider it all PEC
         ipec = 0
+        
         for itet in range(field.n_tets):
             if cond[0,0,itet] > self.settings.mw_3d_peclim:
                 ipec+=1
                 pec_ids.extend(field.tet_to_field[:,itet])
+                for tri in field.mesh.tet_to_tri[:,itet]:
+                    pec_tris.append(tri)
         if ipec>0:
             logger.trace(f'Extended PEC with {ipec} tets with a conductivity > {self.settings.mw_3d_peclim}.')
 
@@ -295,9 +299,12 @@ class Assembler:
                 eids = field.edge_to_field[:, ii]
                 pec_ids.extend(list(eids))
 
+            
             for ii in tri_ids:
                 tids = field.tri_to_field[:, ii]
                 pec_ids.extend(list(tids))
+                
+            pec_tris.extend(tri_ids)
 
 
         ############################################################
@@ -412,7 +419,8 @@ class Assembler:
         
         simjob.port_vectors = port_vectors
         simjob.solve_ids = solve_ids
-
+        simjob._pec_tris = pec_tris
+        
         if has_periodic:
             simjob.P = Pmat
             simjob.Pd = Pmat.getH()

emerge/_emerge/physics/microwave/microwave_3d.py

@@ -876,7 +876,7 @@ class Microwave3D:
     def _run_adaptive_mesh(self,
                 iteration: int, 
                 frequency: float,
-                automatic_modal_analysis: bool = True) -> MWData:
+                automatic_modal_analysis: bool = True) -> tuple[MWData, list[int]]:
         """Executes a frequency domain study
 
         The study is distributed over "n_workers" workers.
@@ -965,7 +965,7 @@ class Microwave3D:
         self.solveroutine.reset()
         ### Compute S-parameters and return
         self._post_process([job,], [mats,])
-        return self.data
+        return self.data, job._pec_tris
     
     def eigenmode(self, search_frequency: float,
                         nmodes: int = 6,

emerge/_emerge/physics/microwave/microwave_bc.py

@@ -773,6 +773,7 @@ class RectangularWaveguide(PortBC):
             logger.info(' - Constructing coordinate system from normal port')
             self.cs = Axis(self.selection.normal).construct_cs()
             logger.debug(f' - Port CS: {self.cs}')
+    
     def get_basis(self) -> np.ndarray:
         return self.cs._basis
         

emerge/_emerge/physics/microwave/microwave_data.py

@@ -667,13 +667,51 @@ class MWField:
         return sum([self.excitation[mode.port_number]*self._fields[mode.port_number] for mode in self.port_modes]) # type: ignore
     
     def set_field_vector(self) -> None:
-        """Defines the default excitation coefficients for the current dataset"""
+        """Defines the default excitation coefficients for the current dataset as an excitation of only port 1."""
         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:
+    def excite_port(self, number: int, excitation: complex = 1.0 + 0.0j) -> None:
+        """Excite a single port provided by a given port number
+
+        Args:
+            number (int): The port number to excite
+            coefficient (complex): The port excitation. Defaults to 1.0 + 0.0j
+        """
+        self.excitation = {key: 0.0 for key in self._fields.keys()}
+        self.excitation[self.port_modes[number-1].port_number] = excitation
+    
+    def set_excitations(self, *excitations: complex) -> None:
+        """Set bulk port excitations by an ordered array of excitation coefficients.
+
+        Returns:
+            *complex: A sequence of complex numbers
+        """
         self.excitation = {key: 0.0 for key in self._fields.keys()}
-        self.excitation[self.port_modes[number].port_number] = 1.0 + 0j
+        for iport, coeff in enumerate(excitations):
+            self.excitation[self.port_modes[iport].port_number] = coeff
+    
+    def combine_ports(self, p1: int, p2: int) -> MWField:
+        """Combines ports p1 and p2 into a cifferential and common mode port respectively.
+        
+        The p1 index becomes the differential mode port
+        The p2 index becomes the common mode port
+
+        Args:
+            p1 (int): The first port number
+            p2 (int): The second port number
+
+        Returns:
+            MWField: _description_
+        """
+        
+        fp1 = self._fields[p1]
+        fp2 = self._fields[p2]
+        
+        self._fields[p1] = (fp1-fp2)/np.sqrt(2)
+        self._fields[p2] = (fp1+fp2)/np.sqrt(2)
+        
+        return self
         
     @property
     def EH(self) -> tuple[np.ndarray, np.ndarray]:
@@ -720,7 +758,9 @@ class MWField:
         xf = xs.flatten()
         yf = ys.flatten()
         zf = zs.flatten()
+        logger.debug(f'Interpolating {xf.shape[0]} field points')
         Ex, Ey, Ez = self.basis.interpolate(self._field, xf, yf, zf, usenan=usenan)
+        logger.debug('E Interpolation complete')
         self.Ex = Ex.reshape(shp)
         self.Ey = Ey.reshape(shp)
         self.Ez = Ez.reshape(shp)
@@ -728,6 +768,7 @@ class MWField:
         
         constants = 1/ (-1j*2*np.pi*self.freq*(self._dur*MU0) )
         Hx, Hy, Hz = self.basis.interpolate_curl(self._field, xf, yf, zf, constants, usenan=usenan)
+        logger.debug('H Interpolation complete')
         ids = self.basis.interpolate_index(xf, yf, zf)
         
         self.er = self._der[ids].reshape(shp)
@@ -743,10 +784,10 @@ class MWField:
         
         return field
     
-    def _solution_quality(self) -> tuple[np.ndarray, np.ndarray]:
+    def _solution_quality(self, solve_ids: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
         from .adaptive_mesh import compute_error_estimate
         
-        error_tet, max_elem_size = compute_error_estimate(self)
+        error_tet, max_elem_size = compute_error_estimate(self, solve_ids)
         return error_tet, max_elem_size
         
     def boundary(self,
@@ -1146,6 +1187,54 @@ class MWScalarNdim:
     def S(self, i1: int, i2: int) -> np.ndarray:
         return self.Sp[...,self._portmap[i1], self._portmap[i2]]
     
+    def combine_ports(self, p1: int, p2: int) -> MWScalarNdim:
+        """Combine ports p1 and p2 into a differential and common mode port respectively.
+
+        The p1 index becomes the differential mode port
+        The p2 index becomes the common mode port
+
+        Args:
+            p1 (int): The first port number
+            p2 (int): The second port number
+
+        Returns:
+            MWScalarNdim: _description_
+        """
+        if p1==p2:
+            raise ValueError('p1 and p2 must be different port numbers')
+        
+        F, N, _ = self.Sp.shape
+        p1 = p1-1
+        p2 = p2-1
+        
+        if not (0 <= p1 < N and 0 <= p2 < N):
+            raise IndexError(f'Ports {p1+1} or {p2+1} are out of range {N}')
+        
+        Sout = self.Sp.copy()
+        ii, jj = p1, p2
+        idx = np.ones(N, dtype=np.bool)
+        idx[[ii,jj]] = False
+        others = np.nonzero(idx)[0]
+        isqrt2 = 1.0 / np.sqrt(2.0)
+        
+        Sout[:, others, ii] = (self.Sp[:, others, ii] - self.Sp[:, others, jj]) * isqrt2
+        Sout[:, others, jj] = (self.Sp[:, others, ii] + self.Sp[:, others, jj]) * isqrt2
+        Sout[:, ii, others] = (self.Sp[:, ii, others] - self.Sp[:, jj, others]) * isqrt2
+        Sout[:, jj, others] = (self.Sp[:, ii, others] + self.Sp[:, jj, others]) * isqrt2
+        
+        Sii = self.Sp[:, ii, ii]
+        Sij = self.Sp[:, ii, jj]
+        Sji = self.Sp[:, jj, ii]
+        Sjj = self.Sp[:, jj, jj]
+        
+        Sout[:, ii, ii] = 0.5 *(Sii - Sij - Sji + Sjj)
+        Sout[:, ii, jj] = 0.5 *(Sii + Sij - Sji - Sjj)
+        Sout[:, jj, ii] = 0.5 *(Sii - Sij + Sji - Sjj)
+        Sout[:, jj, jj] = 0.5 *(Sii + Sij + Sji + Sjj)
+        
+        self.Sp = Sout
+        
+        return self
     @property
     def Smat(self) -> np.ndarray:
         """Returns the full S-matrix

emerge/_emerge/plot/pyvista/display.py

@@ -242,6 +242,7 @@ class PVDisplay(BaseDisplay):
         self._stop: bool = False
         self._objs: list[_AnimObject] = []
         self._do_animate: bool = False
+        self._animate_next: bool = False
         self._closed_via_x: bool = False
         self._Nsteps: int  = 0
         self._fps: int = 25
@@ -334,6 +335,7 @@ class PVDisplay(BaseDisplay):
         self._plot = pv.Plotter()
         self._stop = False
         self._objs = []
+        self._animate_next = False
         C_CYCLE = _gen_c_cycle()
 
     def _close_callback(self, arg):
@@ -403,6 +405,7 @@ class PVDisplay(BaseDisplay):
         print('If you closed the animation without using (Q) press Ctrl+C to kill the process.')
         self._Nsteps = Nsteps
         self._fps = fps
+        self._animate_next = True
         self._do_animate = True
         return self
     
@@ -518,7 +521,7 @@ class PVDisplay(BaseDisplay):
         
         self._plot.add_mesh(self._volume_edges(_select(obj)), color='#000000', line_width=2, show_edges=True)
         
-        if isinstance(obj, GeoObject) and label:
+        if label:
             points = []
             labels = []
             for dt in obj.dimtags:
@@ -691,14 +694,14 @@ class PVDisplay(BaseDisplay):
         actor = self._plot.add_mesh(grid_no_nan, scalars=name, scalar_bar_args=self._cbar_args, **kwargs)
 
 
-        if self._do_animate:
+        if self._animate_next:
             def on_update(obj: _AnimObject, phi: complex):
                 field_anim = obj.T(np.real(obj.field * phi))
                 obj.grid[name] = field_anim
                 obj.fgrid[name] = obj.grid.threshold(scalars=name)[name]
                 #obj.fgrid replace with thresholded scalar data.
             self._objs.append(_AnimObject(field_flat, T, grid, grid_no_nan, actor, on_update))
-        
+            self._animate_next = False
         self._reset_cbar()
     
     def add_boundary_field(self, 
@@ -773,13 +776,13 @@ class PVDisplay(BaseDisplay):
         kwargs = setdefault(kwargs, cmap=cmap, clim=clim, opacity=opacity, pickable=False, multi_colors=True)
         actor = self._plot.add_mesh(grid, scalars=name, scalar_bar_args=self._cbar_args, **kwargs)
 
-        if self._do_animate:
+        if self._animate_next:
             def on_update(obj: _AnimObject, phi: complex):
                 field_anim = obj.T(np.real(obj.field * phi))
                 obj.grid[name] = field_anim
                 #obj.fgrid replace with thresholded scalar data.
             self._objs.append(_AnimObject(field_flat, T, grid, grid, actor, on_update))
-        
+            self._animate_next = False
         self._reset_cbar()
         
     def add_title(self, title: str) -> None:
@@ -921,7 +924,7 @@ class PVDisplay(BaseDisplay):
         
         actor = self._plot.add_mesh(contour, opacity=opacity, cmap=cmap, clim=clim, pickable=False, scalar_bar_args=self._cbar_args)
         
-        if self._do_animate:
+        if self._animate_next:
             def on_update(obj: _AnimObject, phi: complex):
                 new_vals = obj.T(np.real(obj.field * phi))
                 obj.grid['anim'] = new_vals
@@ -929,7 +932,7 @@ class PVDisplay(BaseDisplay):
                 obj.actor.GetMapper().SetInputData(new_contour) # type: ignore
                 
             self._objs.append(_AnimObject(field, T, grid, None, actor, on_update)) # type: ignore
-            
+            self._animate_next = False
         self._reset_cbar()
         
     def _add_aux_items(self) -> None:

emerge/_emerge/selection.py

@@ -21,6 +21,9 @@ import numpy as np
 from .cs import Axis, CoordinateSystem, _parse_vector, Plane
 from typing import Callable, TypeVar, Iterable, Any
 
+class SelectionError(Exception):
+    pass
+
 def align_rectangle_frame(pts3d: np.ndarray, normal: np.ndarray) -> dict[str, Any]:
     """Tries to find a rectangle as convex-hull of a set of points with a given normal vector.
 
@@ -174,7 +177,7 @@ class Selection:
     """
     dim: int = -1
     def __init__(self, tags: list[int] | set[int] | tuple[int] | None = None):
-
+        self.name: str = 'Selection'
         self._tags: set[int] = set()
 
         if tags is not None:
@@ -252,7 +255,19 @@ class Selection:
                 maxy = max(maxy, y1)
                 maxz = max(maxz, z1)
             return (minx, miny, minz), (maxx, maxy, maxz)
-        
+    
+    def _named(self, name: str) -> Selection:
+        """Sets the name of the selection and returns it
+
+        Args:
+            name (str): The name of the selection
+
+        Returns:
+            Selection: The same selection object
+        """
+        self.name = name
+        return self
+    
     def exclude(self, xyz_excl_function: Callable = lambda x,y,z: True, plane: Plane | None = None, axis: Axis | None = None) -> Selection:
         """Exclude points by evaluating a function(x,y,z)-> bool
 

emerge/_emerge/simmodel.py

@@ -458,7 +458,8 @@ class Simulation:
              plot_mesh: bool = False,
              volume_mesh: bool = True,
              opacity: float | None = None,
-             labels: bool = False) -> None:
+             labels: bool = False,
+             face_labels: bool = False) -> None:
         """View the current geometry in either the BaseDisplay object (PVDisplay only) or
         the GMSH viewer.
 
@@ -476,8 +477,13 @@ class Simulation:
             return
         for geo in self.state.current_geo_state:
             self.display.add_object(geo, mesh=plot_mesh, opacity=opacity, volume_mesh=volume_mesh, label=labels)
+            
+            if face_labels and geo.dim==3:
+                for face_name in geo._face_pointers.keys():
+                    self.display.add_object(geo.face(face_name), color='yellow', opacity=0.1, label=face_name)
         if selections:
-            [self.display.add_object(sel, color='red', opacity=0.6, label=labels) for sel in selections]
+            [self.display.add_object(sel, color='red', opacity=0.6, label=sel.name) for sel in selections]
+        
         self.display.show()
 
         return None
@@ -688,9 +694,9 @@ class SimulationBeta(Simulation):
     
     
     def __post_init__(self):
-        
-        self.mesher.set_algorithm(Algorithm3D.HXT)
-        logger.debug('Setting mesh algorithm to HXT')
+        pass
+        #self.mesher.set_algorithm(Algorithm3D.HXT)
+        #logger.debug('Setting mesh algorithm to HXT')
         
         
     def _reset_mesh(self):
@@ -706,10 +712,10 @@ class SimulationBeta(Simulation):
                                  convergence: float = 0.02,
                                  magnitude_convergence: float = 2.0,
                                  phase_convergence: float = 180,
-                                 refinement_ratio: float = 0.9,
-                                 growth_rate: float = 3,
+                                 refinement_ratio: float = 0.6,
+                                 growth_rate: float = 2,
                                  minimum_refinement_percentage: float = 20.0, 
-                                 error_field_inclusion_percentage: float = 5.0,
+                                 error_field_inclusion_percentage: float = 60.0,
                                  frequency: float = None,
                                  show_mesh: bool = False) -> SimulationDataset:
         """ A beta-version of adaptive mesh refinement.
@@ -736,7 +742,7 @@ class SimulationBeta(Simulation):
             SimulationDataset: _description_
         """
         from .physics.microwave.adaptive_mesh import select_refinement_indices, reduce_point_set, compute_convergence
-        
+        from collections import defaultdict
         
         max_freq = np.max(self.mw.frequencies)
         
@@ -752,11 +758,18 @@ class SimulationBeta(Simulation):
         
         self.state.stash()
         
+        a0 = 0.26
+        c0 = 0.75
+        x0 = 12
+        q0 = (1-a0)*2/np.pi
+        b0 = np.tan((c0-a0)/q0)/x0
+        q0 = (0.8-a0)*2/np.pi
+        
         for step in range(1,max_steps+1):
             
             self.data.sim.new(iter_step=step)
             
-            data = self.mw._run_adaptive_mesh(step, max_freq)
+            data, solve_ids = self.mw._run_adaptive_mesh(step, max_freq)
             
             field = data.field[-1]
             
@@ -775,51 +788,89 @@ class SimulationBeta(Simulation):
                     passed = 0
             
             if passed >= min_refined_passes:
-                logger.info('Adaptive mesh refinement successfull')
+                logger.info(f'Adaptive mesh refinement successfull with {self.mesh.n_tets} tetrahedra.')
                 break
             
-            error, lengths = field._solution_quality()
+            error, lengths = field._solution_quality(solve_ids)
                 
             idx = select_refinement_indices(error, error_field_inclusion_percentage/100)
             idx = idx[::-1]
             
-            self.mesher.add_refinement_points(self.mw.mesh.centers[:,idx], lengths[idx])
+            npts = idx.shape[0]
+            np_percentage = npts/self.mesh.n_tets * 100
+            
+            refinement_ratio = (a0 + np.arctan(b0*np_percentage)*q0)
+            #calc_refinement_ratio(refinement_throttle, point_percentage)
+            logger.info(f'Adding {npts} refinement points with a ratio: {refinement_ratio}')
+            
+            # tet_nodes = defaultdict(lambda: 1000.)
+            # for itet in idx:
+            #     for inode in self.mesh.tets[:,itet]:
+            #         tet_nodes[inode] = min(tet_nodes[inode], lengths[itet])
+            
+            # N = len(tet_nodes)
+            # coords = np.zeros((3,N), dtype=np.float64)
+            # sizes = np.zeros((N,), dtype=np.float64)
+            # for i, (index, size) in enumerate(tet_nodes.items()):
+            #     coords[:,i] = self.mesh.nodes[:,index]
+            #     sizes[i] = size
+            
+            # self.mesher.add_refinement_points(coords, sizes, refinement_ratio*np.ones((N,)))
+            
+            self.mesher.add_refinement_points(self.mw.mesh.centers[:,idx], lengths[idx], refinement_ratio*np.ones_like(lengths[idx]))
             
             logger.debug(f'Pass {step}: Adding {len(idx)} new refinement points.')
                 
             new_ids = reduce_point_set(self.mesher._amr_coords, growth_rate, self.mesher._amr_sizes, refinement_ratio, 0.20)
             
-            logger.debug(f'Pass {step}: Removing {self.mesher._amr_coords.shape[1] - len(new_ids)} points from {self.mesher._amr_coords.shape[1]} to {len(new_ids)}')
+            nremoved = self.mesher._amr_coords.shape[1] - len(new_ids)
+            if nremoved > 0:
+                logger.info(f'Cleanup of step {step}: Removing {nremoved} points.')
             
             self.mesher._amr_coords = self.mesher._amr_coords[:,new_ids]
             self.mesher._amr_sizes = self.mesher._amr_sizes[new_ids]
+            self.mesher._amr_ratios = self.mesher._amr_ratios[new_ids]
+            self.mesher._amr_new = self.mesher._amr_new[new_ids]
             
+            def clip(value: float):
+                return max(1.3, value)
+            
+            logger.debug(f'Initial refinement ratio: {refinement_ratio}')
+            
+            over = False
+            under = False
+            throttle = 1.0
             
             while True:
                 
-                self._reset_mesh()
-                
-                logger.debug(f'Pass {step}: Adding {len(idx)} refinement points.')
-                
-                self.mesher.set_refinement_function(refinement_ratio, growth_rate, 1.0)
+                if over and under:
+                    throttle *= 2
                 
+                self._reset_mesh()
+                logger.debug(f'Pass {step}')
+                self.mesher.set_refinement_function(growth_rate, 2.0)
                 self.generate_mesh(True)
-                
                 percentage = (self.mesh.n_tets/last_n_tets - 1) * 100
                 logger.info(f'Pass {step}: New mesh has {self.mesh.n_tets} (+{percentage:.1f}%) tetrahedra.')  
                 
                 if percentage < minimum_refinement_percentage:
+                    F = (2*minimum_refinement_percentage-percentage)/(throttle*minimum_refinement_percentage)
                     logger.debug('Not enough mesh refinement, decreasing mesh size constraint.')
-                    refinement_ratio = refinement_ratio * 0.9
+                    refinement_ratio = self.mesher.refine_finer(F)
                     logger.debug(f'New refinement ratio: {refinement_ratio}')
+                    under=True
                     continue
-                
-                if percentage > 2*minimum_refinement_percentage and refinement_ratio < 0.99:
+                if percentage > (minimum_refinement_percentage*2):
+                    F = (percentage - minimum_refinement_percentage)/(throttle*minimum_refinement_percentage)
                     logger.debug('Too much mesh refinement, decreasing mesh size constraint.')
-                    refinement_ratio = refinement_ratio ** (1-np.log(percentage/minimum_refinement_percentage)/4)
+                    refinement_ratio = self.mesher.refine_coarser(F)
                     logger.debug(f'New refinement ratio: {refinement_ratio}')
+                    over=True
+                    continue
                     
-
+                over = False
+                under = False
+                throttle = 1.0
                 last_n_tets = self.mesh.n_tets
                 break
             

emerge/_emerge/solver.py

@@ -209,7 +209,7 @@ def filter_real_modes(eigvals: np.ndarray, eigvecs: np.ndarray,
     filtered_vals = eigvals[mask]
     filtered_vecs = eigvecs[:, mask]
     k0vals = np.sqrt(sign*filtered_vals)
-    order = np.argsort(np.abs(k0vals))# ascending distance
+    order = np.argsort(np.abs(k0vals)) # ascending distance
     filtered_vals = filtered_vals[order]             # reorder eigenvalues
     filtered_vecs = filtered_vecs[:, order] 
     return filtered_vals, filtered_vecs
@@ -1282,7 +1282,7 @@ class SolveRoutine:
         NF = A.shape[0]
         NS = solve_ids.shape[0]
 
-        logger.debug(self.pre + f'Removing {NF-NS} prescribed DOFs ({NS} left)')
+        logger.debug(self.pre + f' Removing {NF-NS} prescribed DOFs ({NS} left)')
 
         Asel = A[np.ix_(solve_ids, solve_ids)]
         Bsel = B[np.ix_(solve_ids, solve_ids)]
@@ -1325,7 +1325,7 @@ class SolveRoutine:
         NF = A.shape[0]
         NS = solve_ids.shape[0]
 
-        logger.debug(self.pre + f'Removing {NF-NS} prescribed DOFs ({NS} left)')
+        logger.debug(self.pre + f' Removing {NF-NS} prescribed DOFs ({NS} left)')
 
         Asel = A[np.ix_(solve_ids, solve_ids)]
         Bsel = B[np.ix_(solve_ids, solve_ids)]

{emerge-1.1.0.dist-info → emerge-1.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emerge
-Version: 1.1.0
+Version: 1.1.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