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

emerge/_emerge/physics/microwave/microwave_3d.py

@@ -26,6 +26,9 @@ from ...solver import DEFAULT_ROUTINE, SolveRoutine
 from ...system import called_from_main_function
 from ...selection import FaceSelection
 from ...settings import Settings
+from ...simstate import SimState
+from ...logsettings import DEBUG_COLLECTOR
+
 from .microwave_bc import MWBoundaryConditionSet, PEC, ModalPort, LumpedPort, PortBC
 from .microwave_data import MWData
 from .assembly.assembler import Assembler
@@ -34,10 +37,10 @@ from .simjob import SimJob
 
 from concurrent.futures import ThreadPoolExecutor
 from loguru import logger
-from typing import Callable, Literal
+from typing import Callable, Literal, Any
 import multiprocessing as mp
 from cmath import sqrt as csqrt
-
+from itertools import product
 import numpy as np
 import threading
 import time
@@ -54,16 +57,14 @@ def run_job_multi(job: SimJob) -> SimJob:
     Returns:
         SimJob: The solved SimJob
     """
-    routine = DEFAULT_ROUTINE._configure_routine('MP')
+    nr = int(mp.current_process().name.split('-')[1])
+    routine = DEFAULT_ROUTINE._configure_routine('MP', proc_nr=nr)
     for A, b, ids, reuse, aux in job.iter_Ab():
         solution, report = routine.solve(A, b, ids, reuse, id=job.id)
         report.add(**aux)
         job.submit_solution(solution, report)
     return job
 
-def _init_worker():
-    nr = int(mp.current_process().name.split('-')[1])
-    DEFAULT_ROUTINE._configure_routine(proc_nr=nr)
 
 def _dimstring(data: list[float] | np.ndarray) -> str:
     """A String formatter for dimensions in millimeters
@@ -111,14 +112,17 @@ class Microwave3D:
     formulation.
 
     """
-    def __init__(self, mesher: Mesher, settings: Settings, mwdata: MWData, order: int = 2):
+    def __init__(self, state: SimState, mesher: Mesher, settings: Settings, order: int = 2):
+        
+        self._settings: Settings = settings
+        
         self.frequencies: list[float] = []
         self.current_frequency = 0
         self.order: int = order
-        self.resolution: float = 1
-        self._settings: Settings = settings
+        self.resolution: float = 0.33
+        
         self.mesher: Mesher = mesher
-        self.mesh: Mesh3D = Mesh3D(self.mesher)
+        self._state: SimState = state
 
         self.assembler: Assembler = Assembler(self._settings)
         self.bc: MWBoundaryConditionSet = MWBoundaryConditionSet(None)
@@ -128,38 +132,33 @@ class Microwave3D:
 
         ## States
         self._bc_initialized: bool = False
-        self.data: MWData = mwdata
-
-        ## Data
-        self._params: dict[str, float] = dict()
         self._simstart: float = 0.0
         self._simend: float = 0.0
+        
+        self._container: dict[str, Any] = dict()
 
-        self.set_order(order)
-
-    def reset_data(self):
-        self.data = MWData()
-
-    def reset(self):
-        self.bc.reset()
+    @property
+    def _params(self) -> dict[str, float]:
+        return self._state.params
+    
+    @property
+    def mesh(self) -> Mesh3D:
+        return self._state.mesh
+    
+    @property
+    def data(self) -> MWData:
+        return self._state.data.mw
+    
+    def reset(self, _reset_bc: bool = True):
+        if _reset_bc:
+            self.bc = MWBoundaryConditionSet(None)
+        else:
+            for bc in self.bc.oftype(ModalPort):
+                bc.reset()
+            
         self.basis: FEMBasis = None
-        self.bc = MWBoundaryConditionSet(None)
         self.solveroutine.reset()
-
-    def set_order(self, order: int) -> None:
-        """Sets the order of the basis functions used. Currently only supports second order.
-
-        Args:
-            order (int): The order to use.
-
-        Raises:
-            ValueError: An error if a wrong order is used.
-        """
-        if order not in (2,):
-            raise ValueError(f'Order {order} not supported. Only order-2 allowed.')
-        
-        self.order = order
-        self.resolution = {1: 0.15, 2: 0.3}[order]
+        self.assembler.cached_matrices = None
 
     @property
     def nports(self) -> int:
@@ -217,7 +216,15 @@ class Microwave3D:
             self.frequencies = list(frequency)
         else:
             self.frequencies = [frequency]
-
+            
+        # Safety tests
+        if len(self.frequencies) > 200:
+            DEBUG_COLLECTOR.add_report(f'More than 200 frequency points are detected ({len(frequency)}). This may cause slow simulations. Consider using Vector Fitting to subsample S-parameters.')
+        if min(self.frequencies) < 1e6:
+            DEBUG_COLLECTOR.add_report(f'A frequency smaller than 1MHz has been detected ({min(frequency)} Hz). Perhaps you forgot to include usints like 1e6 for MHz etc.')
+        if max(self.frequencies) > 1e12:
+            DEBUG_COLLECTOR.add_report(f'A frequency greater than THz has been detected ({min(frequency)} Hz). Perhaps you double counted frequency units like twice 1e6 for MHz etc.')
+        
         self.mesher.max_size = self.resolution * 299792458 / max(self.frequencies)
         self.mesher.min_size = 0.1 * self.mesher.max_size
 
@@ -359,29 +366,6 @@ class Microwave3D:
             logger.trace(f' - Port[{port.port_number}] integration line {start} -> {end}.')
         
         port.v_integration = True
-    
-    def _compute_integration_line(self, group1: list[int], group2: list[int]) -> tuple[np.ndarray, np.ndarray]:
-        """Computes an integration line for two node island groups by finding the closest two nodes.
-        
-        This method is used for the modal TEM analysis to find an appropriate voltage integration path
-        by looking for the two closest points for the two conductor islands that where discovered.
-
-        Currently it defaults to 11 integration line points.
-
-        Args:
-            group1 (list[int]): The first island node group
-            group2 (list[int]): The second island node group
-
-        Returns:
-            centers (np.ndarray): The center points of the line segments
-            dls (np.ndarray): The delta-path vectors for each line segment.
-        """
-        nodes1 = self.mesh.nodes[:,group1]
-        nodes2 = self.mesh.nodes[:,group2]
-        path = shortest_path(nodes1, nodes2, 21)
-        centres = (path[:,1:] + path[:,:-1])/2
-        dls = path[:,1:] - path[:,:-1]
-        return centres, dls
 
     def _find_tem_conductors(self, port: ModalPort, sigtri: np.ndarray) -> tuple[list[int], list[int]]:
         ''' Returns two lists of global node indices corresponding to the TEM port conductors.
@@ -401,8 +385,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 +404,38 @@ 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:
+                logger.error(f' - Found {len(pec_islands)} PEC islands without a terminal definition. Please use .set_terminals() to define which conductors are which polarity, or define the integration line manually.') 
+                return None, None  
+            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:
@@ -457,7 +462,11 @@ class Microwave3D:
             if not bc.mixed_materials and bc.initialized:
                 continue
             
-            self.modal_analysis(bc, 1, False, bc.TEM, freq=freq)
+            if bc.forced_modetype=='TEM':
+                TEM = True
+            else:
+                TEM = False
+            self.modal_analysis(bc, 1, direct=False, freq=freq, TEM=TEM)
 
     def modal_analysis(self, 
                        port: ModalPort, 
@@ -551,7 +560,7 @@ class Microwave3D:
             target_kz = k0*target_neff
         
         if target_kz is None:
-            if TEM:
+            if TEM or port.forced_modetype=='TEM':
                 target_kz = ermean*urmean*1.1*k0
             else:
                 
@@ -573,19 +582,28 @@ class Microwave3D:
             Emode = np.zeros((nlf.n_field,), dtype=np.complex128)
             eigenmode = eigen_modes[:,i]
             Emode[solve_ids] = np.squeeze(eigenmode)
-            Emode = Emode * np.exp(-1j*np.angle(np.max(Emode)))
+            Emode = Emode * np.exp(-1j*np.angle(Emode[np.argmax(np.abs(Emode))]))
 
             beta_base = np.emath.sqrt(-eigen_values[i])
             beta = min(k0*np.sqrt(ermax*urmax), beta_base)
 
             residuals = -1
 
+            if port._get_alignment_vector(i) is not None:
+                vec = port._get_alignment_vector(i)
+                xyz_centers = self.mesh.tri_centers[:,self.mesh.get_triangles(port.tags)]
+                E_centers = np.mean(nlf.interpolate_Ef(Emode)(xyz_centers[0,:], xyz_centers[1,:], xyz_centers[2,:]), axis=1)
+                EdotVec = vec[0]*E_centers[0] + vec[1]*E_centers[1] + vec[2]*E_centers[2]
+                if EdotVec.real < 0:
+                    logger.debug(f'Mode polarization along alignment axis {vec} = {EdotVec.real:.3f}, inverting.')
+                    Emode = -Emode
+                  
             portfE = nlf.interpolate_Ef(Emode)
             portfH = nlf.interpolate_Hf(Emode, k0, ur, beta)
-
             P = compute_avg_power_flux(nlf, Emode, k0, ur, beta)
 
-            mode = port.add_mode(Emode, portfE, portfH, beta, k0, residuals, TEM=TEM, freq=freq)
+            mode = port.add_mode(Emode, portfE, portfH, beta, k0, residuals, number=i, freq=freq)
+            
             if mode is None:
                 continue
             
@@ -594,20 +612,40 @@ class Microwave3D:
             Ez = np.max(np.abs(Efz))
             Exy = np.max(np.abs(Efxy))
             
-            if Ez/Exy < 1e-1 and not TEM:
+            if port.forced_modetype == 'TEM' or TEM:
+                mode.modetype = 'TEM'
+                
+                if len(port.vintline)>0:
+                    line = port.vintline[0]
+                else:  
+                    G1, G2 = self._find_tem_conductors(port, sigtri=cond)
+                    if G1 is None or G2 is None:
+                        logger.warning('Skipping characteristic impedance calculation.')
+                        continue
+                    
+                    nodes1 = self.mesh.nodes[:,G1]
+                    nodes2 = self.mesh.nodes[:,G2]
+                    path = shortest_path(nodes1, nodes2, 2)
+                    line = Line.from_points(path[:,0], path[:,1], 21)
+                    port.vintline.append(line)
+                
+                cs = np.array(line.cmid)
+
+                logger.debug(f'Integrating portmode from {cs[:,0]} to {cs[:,-1]}')
+                voltage = line.line_integral(portfE)
+                # Align mode polarity to positive voltage
+                if voltage < 0:
+                    mode.polarity = mode.polarity * -1
+                    
+                mode.Z0 = abs(voltage**2/(2*P))
+                logger.debug(f'Port Z0 = {mode.Z0}')
+            elif Ez/Exy < 1e-1 or port.forced_modetype=='TE':
                 logger.debug('Low Ez/Et ratio detected, assuming TE mode')
                 mode.modetype = 'TE'
-            elif Ez/Exy > 1e-1 and not TEM:
+            elif Ez/Exy > 1e-1 or port.forced_modetype=='TM':
                 logger.debug('High Ez/Et ratio detected, assuming TM mode')
                 mode.modetype = 'TM'
-            elif TEM:
-                G1, G2 = self._find_tem_conductors(port, sigtri=cond)
-                cs, dls = self._compute_integration_line(G1,G2)
-                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,:])
-                mode.Z0 = abs(voltage**2/(2*P))
-                logger.debug(f'Port Z0 = {mode.Z0}')
+            
 
             mode.set_power(P*port._qmode(k0)**2)
         
@@ -787,7 +825,7 @@ class Microwave3D:
                     "if __name__ == '__main__' guard in the top-level script."
                 )
             # Start parallel pool
-            with mp.Pool(processes=n_workers, initializer=_init_worker) as pool:
+            with mp.Pool(processes=n_workers) as pool:
                 for i_group, fgroup in enumerate(freq_groups):
                     logger.debug(f'Precomputing group {i_group}.')
                     jobs = []
@@ -835,6 +873,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 +1000,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.')
             
@@ -932,14 +1060,21 @@ class Microwave3D:
         """
         if self.basis is None:
             raise SimulationError('Cannot post-process. Simulation basis function is undefined.')
+        
         mesh = self.mesh
         all_ports = self.bc.oftype(PortBC)
         port_numbers = [port.port_number for port in all_ports]
         
         logger.info('Computing S-parameters')
         
-
-        for freq, job, mats in zip(self.frequencies, results, materials):
+        not_conserved = False
+        
+        single_corr = self._settings.mw_cap_sp_single
+        col_corr = self._settings.mw_cap_sp_col
+        recip_corr = self._settings.mw_recip_sp
+        
+        for job, mats in zip(results, materials):
+            freq = job.freq
             er, ur, cond = mats
             ertri = np.zeros((3,3,self.mesh.n_tris), dtype=np.complex128)
             urtri = np.zeros((3,3,self.mesh.n_tris), dtype=np.complex128)
@@ -965,6 +1100,7 @@ class Microwave3D:
 
             logger.info(f'Post Processing simulation frequency = {freq/1e9:.3f} GHz') 
 
+            
             # Recording port information
             for active_port in all_ports:
                 port_tets = self.mesh.get_face_tets(active_port.tags)
@@ -1010,10 +1146,36 @@ class Microwave3D:
                     pfield, pmode = self._compute_s_data(bc, fieldf,tri_vertices, k0, ertri[:,:,tris], urtri[:,:,tris])
                     logger.debug(f'[{bc.port_number}] Passive amplitude = {np.abs(pfield):.3f}')
                     scalardata.write_S(bc.port_number, active_port.port_number, pfield/Pout)
+                    if abs(pfield/Pout) > 1.0:
+                        logger.warning(f'S-parameter > 1.0 detected: {np.abs(pfield/Pout)}')
+                        not_conserved = True
                 active_port.active=False
             
+            
             fielddata.set_field_vector()
+            
+            N = scalardata.Sp.shape[1]
+            
+            # Enforce reciprocity
+            if recip_corr:
+                scalardata.Sp = (scalardata.Sp + scalardata.Sp.T)/2
+            
+            # Enforce energy conservation
+            if col_corr:
+                for j in range(N):
+                    scalardata.Sp[:,j] = scalardata.Sp[:,j] / max(1.0, np.sum(np.abs(scalardata.Sp[:,j])**2))
+            
+            # Enforce S-parameter limit to 1.0
+            if single_corr:
+                for i,j in product(range(N), range(N)):
+                    scalardata.Sp[i,j] = scalardata.Sp[i,j] / max(1.0, np.abs(scalardata.Sp[i,j]))
+                    
+                    
 
+        if not_conserved:
+            DEBUG_COLLECTOR.add_report('S-parameters with an amplitude greater than 1.0 detected. This could be due to a ModalPort with the wrong mode type.\n' +
+                                       'Specify the type of mode (TE/TM/TEM) in the constructor using ModalPort(..., modetype=\'TE\') for example.\n' +
+                                       f'Values slightly greater than 1 are possible due to numerical accuracy. Automatic normalization = {single_corr or col_corr}')
         logger.info('Simulation Complete!')
         self._simend = time.time()    
         logger.info(f'Elapsed time = {(self._simend-self._simstart):.2f} seconds.')
@@ -1039,6 +1201,7 @@ class Microwave3D:
             tuple[complex, complex]: _description_
         """
         from .sparam import sparam_field_power, sparam_mode_power
+        
         if bc.v_integration:
             if bc.vintline is None:
                 raise SimulationError('Trying to compute characteristic impedance but no integration line is defined.')
@@ -1064,7 +1227,7 @@ class Microwave3D:
         else:
             if bc.modetype(k0) == 'TEM':
                 const = 1/(np.sqrt((urp[0,0,:] + urp[1,1,:] + urp[2,2,:])/(erp[0,0,:] + erp[1,1,:] + erp[2,2,:])))
-            if bc.modetype(k0) == 'TE':
+            elif bc.modetype(k0) == 'TE':
                 const = 1/((urp[0,0,:] + urp[1,1,:] + urp[2,2,:])/3)
             elif bc.modetype(k0) == 'TM':
                 const = 1/((erp[0,0,:] + erp[1,1,:] + erp[2,2,:])/3)