emerge 0.5.2__py3-none-any.whl → 0.5.3__py3-none-any.whl

emerge/_emerge/bc.py

@@ -64,17 +64,8 @@ class BoundaryCondition:
         return self.dimension.value
     
     def __repr__(self) -> str:
-        if self.dimension is BCDimension.ANY:
-            return f'{type(self).__name__}{self.tags}'
-        elif self.dimension is BCDimension.EDGE:
-            return f'{type(self).__name__}{self.tags}'
-        elif self.dimension is BCDimension.NODE:
-            return f'{type(self).__name__}{self.tags}'
-        elif self.dimension is BCDimension.FACE:
-            return f'{type(self).__name__}{self.tags}'
-        elif self.dimension is BCDimension.DOMAIN:
-            return f'{type(self).__name__}{self.tags}'
-    
+        return f'{type(self).__name__}{self.tags}'
+
     def __str__(self) -> str:
         return self.__repr__()
     
@@ -183,7 +174,7 @@ class BoundaryConditionSet:
         Returns:
             list[BoundaryCondition]: The list of boundary conditions
         """
-        return [item for item in self. boundary_conditions if isinstance(item, bctype)]
+        return [item for item in self.boundary_conditions if isinstance(item, bctype)]
 
     def reset(self) -> None:
         """Resets the boundary conditions that are defined

emerge/_emerge/const.py

@@ -0,0 +1,5 @@
+C0 = 299792458
+Z0 = 376.73031366857
+PI = 3.14159265358979323846
+EPS0 = 8.854187818814e-12
+MU0 = 1/(C0*C0*EPS0)#1.2566370612720e-6

emerge/_emerge/elements/nedleg2.py

@@ -22,7 +22,7 @@ from .femdata import FEMBasis
 from .ned2_interp import ned2_tri_interp_full, ned2_tri_interp_curl
 from ..mth.optimized import matinv
 from ..cs import CoordinateSystem
-
+from ..const import MU0, C0
 
 ## TODO: TEMPORARY SOLUTION FIX THIS
 
@@ -158,7 +158,7 @@ class NedelecLegrange2(FEMBasis):
 
     def interpolate_Hf(self, field: np.ndarray, k0: float, ur: np.ndarray, beta: float) -> FieldFunctionClass:
         '''Generates the Interpolation function as a function object for a given coordiante basis and origin.'''
-        constant = 1j / ((k0*299792458)*(4*np.pi*1e-7))
+        constant = 1j / ((k0*C0)*MU0)
         urinv = np.zeros_like(ur)
         
         for i in range(ur.shape[2]):

emerge/_emerge/geo/pcb.py

@@ -17,9 +17,6 @@
 
 from __future__ import annotations
 
-import numpy as np
-import gmsh
-
 from ..cs import CoordinateSystem, GCS, Axis
 from ..geometry import GeoPolygon, GeoVolume, GeoSurface
 from ..material import Material, AIR, COPPER
@@ -28,11 +25,14 @@ from .polybased import XYPolygon
 from .operations import change_coordinate_system
 from .pcb_tools.macro import parse_macro
 from .pcb_tools.calculator import PCBCalculator
+
+import numpy as np
 from loguru import logger
 from typing import Literal, Callable, overload
 from dataclasses import dataclass
-import math
 
+import math
+import gmsh
 
 ############################################################
 #                        EXCEPTIONS                        #
@@ -63,7 +63,15 @@ def normalize(vector: np.ndarray) -> np.ndarray:
         return vector
     return vector / norm
 
-def _rot_mat(angle):
+def _rot_mat(angle: float) -> np.ndarray:
+    """Returns a 2D rotation matrix given an angle in degrees
+
+    Args:
+        angle (float): The angle in degrees
+
+    Returns:
+        np.ndarray: The rotation matrix
+    """
     ang = -angle * np.pi/180
     return np.array([[np.cos(ang), -np.sin(ang)], [np.sin(ang), np.cos(ang)]])
 
@@ -265,6 +273,66 @@ class StripTurn(RouteElement):
         else:
             raise RouteException(f'Trying to route a StripTurn with an unknown corner type: {self.corner_type}')
  
+class StripCurve(StripTurn):
+    def __init__(self,
+                 x: float,
+                 y: float,
+                 width: float,
+                 direction: tuple[float, float],
+                 angle: float,
+                 radius: float,
+                 dang: float = 10.0):
+        self.xold: float = x
+        self.yold: float = y
+        self.width: float = width
+        self.old_direction: np.ndarray = normalize(np.array(direction))
+        self.direction: np.ndarray = _rot_mat(angle) @ self.old_direction
+        self.angle: float = angle
+        self.radius: float = radius
+        self.dirright: np.ndarray = np.array([self.old_direction[1], -self.old_direction[0]])
+        self.dang: float = dang
+
+        angd = abs(angle*np.pi/180)
+        self.start = np.array([x,y])
+        self.circ_origin = self.start + radius * np.sign(angle) * self.dirright
+
+        self._xhat = -self.dirright * np.sign(angle)
+        self._yhat = self.old_direction
+        
+        self.end = self.circ_origin + radius*(self._xhat*np.cos(angd)+self._yhat*np.sin(angd))
+        self.x, self.y = self.end
+
+    def __str__(self) -> str:
+        return f'StripCurve[{self.x},{self.y},w={self.width},d=({self.direction})]'
+
+    @property
+    def right(self) -> list[tuple[float, float]]:
+        points: list[tuple[float, float]] = []
+        Npts = int(np.ceil(abs(self.angle/self.dang)))
+        R = self.radius-np.sign(self.angle)*self.width/2
+        print(R, self.circ_origin, self._xhat, self._yhat)
+        for i in range(Npts):
+            ang = abs((i+1)/Npts * self.angle * np.pi/180)
+            pnew = self.circ_origin + R*(self._xhat*np.cos(ang)+self._yhat*np.sin(ang))
+            points.append((pnew[0], pnew[1]))
+        
+        return points
+
+    @property
+    def left(self) -> list[tuple[float, float]]:
+        points: list[tuple[float, float]] = []
+
+        Npts = int(np.ceil(abs(self.angle/self.dang)))
+        R = self.radius+np.sign(self.angle)*self.width/2
+        print(R, self.circ_origin, self._xhat, self._yhat)
+        for i in range(Npts):
+            ang = abs((i+1)/Npts * self.angle * np.pi/180)
+            pnew = self.circ_origin + R*(self._xhat*np.cos(ang)+self._yhat*np.sin(ang))
+            points.append((pnew[0], pnew[1]))
+        
+        return points[::-1]
+
+    
 ############################################################
 #                    THE STRIP PATH CLASS                  #
 ############################################################
@@ -405,7 +473,9 @@ class StripPath:
         """
         x, y = self.end.x, self.end.y
         dx, dy = self.end.direction
-        
+        if abs(angle) <= 20:
+            corner_type = 'square'
+            logger.warning('Small turn detected, defaulting to rectangular corners because chamfers would add to much detail.')
         if width is not None:
             if width != self.end.width:
                 self._add_element(StripLine(x, y, width, (dx, dy)))
@@ -413,6 +483,37 @@ class StripPath:
             width=self.end.width
         self._add_element(StripTurn(x, y, width, (dx, dy), angle, corner_type))
         return self
+
+    def curve(self, angle: float, radius: float,
+             width: float | None = None, 
+             corner_type: Literal['champher','square'] = 'champher',
+             dang: float = 10) -> StripPath:
+        """Adds a bend to the strip path.
+
+        The angle is specified in degrees. The width of the turn will be the same as the last segment.
+        optionally, a different width may be provided. 
+        By default, all corners will be cut using the "champher" type. Other options are not yet provided.
+
+        Args:
+            angle (float): The turning angle
+            width (float, optional): The stripline width. Defaults to None.
+            corner_type (str, optional): The corner type. Defaults to 'champher'.
+
+        Returns:
+            StripPath: The current StripPath object
+        """
+        if angle == 0:
+            logger.trace('Zero angle turn, passing action')
+            return self
+        x, y = self.end.x, self.end.y
+        dx, dy = self.end.direction
+        if width is not None:
+            if width != self.end.width:
+                self._add_element(StripLine(x, y, width, (dx, dy)))
+        else:
+            width=self.end.width
+        self._add_element(StripCurve(x, y, width, (dx, dy), angle, radius, dang=dang))
+        return self
     
     def store(self, name: str) -> StripPath:
         """ Store the current x,y coordinate labeled in the PCB object.
@@ -495,7 +596,6 @@ class StripPath:
         self.pcb._lumped_element(poly, impedance_function, width, length)
         return self.pcb.new(x+dx*length, y+dy*length, self.end.width, self.end.direction, self.z)
 
-
     def cut(self) -> StripPath:
         """Split the current path in N new paths given by a new departure direction
 
@@ -637,7 +737,7 @@ class StripPath:
     def to(self, dest: tuple[float, float], 
            arrival_dir: tuple[float, float] | None = None,
            arrival_margin: float  | None= None,
-           angle_step: float = 90):
+           angle_step: float = 90) -> StripPath:
         """
         Extend the path from current end point to dest (x, y).
         Optionally ensure arrival in arrival_dir after a straight segment of arrival_margin.
@@ -743,9 +843,8 @@ class StripPath:
         back_ang = math.degrees(math.atan2(cross2, dot2))
         
         backoff = math.tan(abs(back_ang)*np.pi/360)*self.end.width/2
-        self.straight(s - backoff)
-        
 
+        self.straight(s - backoff)
         self.turn(-back_ang)
 
         x0 = self.end.x
@@ -753,7 +852,6 @@ class StripPath:
         D = math.hypot(tx-x0, ty-y0)
         # 4) Final straight into destination by arrival_margin + t
         self.straight(D)
-        
 
         return self
 
@@ -801,7 +899,7 @@ class StripPath:
         return self.path[element_nr]
 
 ############################################################
-#                     PCB DESIGN CLASS                    #
+#                     PCB DESIGN CLASS                     #
 ############################################################
 
 class PCB:
@@ -1270,7 +1368,6 @@ class PCB:
             polys.material = COPPER
         return polys
                 
-
 ############################################################
 #                        DEPRICATED                       #
 ############################################################

emerge/_emerge/geo/pcb_tools/calculator.py

@@ -1,9 +1,9 @@
 import numpy as np
 from ...material import Material
+from ...const import Z0 as n0
 
 PI = np.pi
 TAU = 2*PI
-n0 = 376.73
 
 def microstrip_z0(W: float, th: float, er: float):
     u = W/th
@@ -14,7 +14,7 @@ def microstrip_z0(W: float, th: float, er: float):
 
 class PCBCalculator:
 
-    def __init__(self, thickness: float, layers: np.array, material: Material, unit: float):
+    def __init__(self, thickness: float, layers: np.ndarray, material: Material, unit: float):
         self.th = thickness
         self.layers = layers
         self.mat = material

emerge/_emerge/geometry.py

@@ -299,7 +299,7 @@ class GeoObject:
         for tag in self.tags:
             newtags.extend(tagmap.get(tag, [tag,]))
         self.tags = newtags
-        logger.debug(f'Replaced {self.old_tags} with {self.tags}')
+        logger.debug(f'{self} Replaced {self.old_tags} -> {self.tags}')
     
     def update_tags(self, tag_mapping: dict[int,dict]) -> GeoObject:
         ''' Update the tag definition of a GeoObject after fragementation.'''

emerge/_emerge/logsettings.py

@@ -4,31 +4,32 @@ from typing import Literal
 from enum import Enum
 from pathlib import Path
 import os
-
+import gmsh
 
 ############################################################
 #                          FORMATS                         #
 ############################################################
 
 TRACE_FORMAT = (
-    "{time: YY/MM/DD - (ddd) - HH:mm:ss.SSSS} | <green>{elapsed}</green> [ <level>{level}</level> ] "
-    " <level>{message}</level>"
+    "{time:ddd YY/MM/DD HH:mm:ss.SSSS} {level:<7} {thread.id:<15} {line:>4}: "
+    "{message}"
 )
+
 DEBUG_FORMAT = (
-    "<green>{elapsed}</green> [<level>{level}</level>] "
-    " <level>{message}</level>"
+    "<green>{elapsed}</green>  <level>{level:<7}</level>: "
+    "<level>{message}</level>"
 )
 INFO_FORMAT = (
-    "<green>{elapsed}</green> [<level>{level}</level>] "
-    " <level>{message}</level>"
+    "<green>{elapsed}</green>  <level>{level:<7}</level>: "
+    "<level>{message}</level>"
 )
 WARNING_FORMAT = (
-    "<green>{elapsed}</green> [<level>{level}</level>] "
-    " <level>{message}</level>"
+    "<green>{elapsed}</green>  <level>{level:<7}</level>: "
+    "<level>{message}</level>"
 )
 ERROR_FORMAT = (
-    "<green>{elapsed}</green> [<level>{level}</level>] "
-    " <level>{message}</level>"
+    "<green>{elapsed}</green>  <level>{level:<7}</level>: "
+    "<level>{message}</level>"
 )
 FORMAT_DICT = {
     'TRACE': TRACE_FORMAT,
@@ -71,10 +72,8 @@ class LogController:
         logger.configure(handlers=[handler]) # type: ignore
         self.level = loglevel
         os.environ["EMERGE_STD_LOGLEVEL"] = loglevel
-        
 
     def set_write_file(self, path: Path, loglevel: str = 'TRACE'):
-
         handler_id = logger.add(str(path / 'logging.log'), mode='w', level=loglevel, format=FORMAT_DICT.get(loglevel, INFO_FORMAT), colorize=False, backtrace=True, diagnose=True)
         self.file_handlers.append(handler_id)
         self.file_level = loglevel

emerge/_emerge/material.py

@@ -45,6 +45,10 @@ class Material:
         hex_str = self.color.lstrip('#')
         self._color_rgb = tuple(int(hex_str[i:i+2], 16)/255.0 for i in (0, 2, 4))
 
+    @property
+    def sigma(self) -> float:
+        return self.cond
+        
     @property
     def color_rgb(self) -> tuple[float,float,float]:
         return self._color_rgb

emerge/_emerge/mth/integrals.py

@@ -60,7 +60,7 @@ def _fast_integral_f(nodes, triangles, constants, DPTs, field_values):
 def surface_integral(nodes: np.ndarray, 
                      triangles: np.ndarray, 
                      function: Callable, 
-                     constants: np.ndarray = None,
+                     constants: np.ndarray | None = None,
                      gq_order: int = 4) -> complex:
     """Computes the surface integral of a scalar-field
 

emerge/_emerge/physics/microwave/adaptive_freq.py

@@ -108,10 +108,6 @@ def vectfit_step(f: np.ndarray, s: np.ndarray, poles: np.ndarray) -> np.ndarray:
     b = np.concatenate((b.real, b.imag))
     x, residuals, rnk, s = np.linalg.lstsq(A, b, rcond=-1)
 
-    residues = x[:N]
-    d = x[N]
-    h = x[N+1]
-
     # We only want the "tilde" part in (A.4)
     x = x[-N:]
 
@@ -197,7 +193,7 @@ def vectfit_auto(f: np.ndarray,
     w = s.imag
     pole_locs = np.linspace(w[0], w[-1], n_poles+2)[1:-1]
     lr = loss_ratio
-    init_poles = poles = np.concatenate([[p*(-lr + 1j), p*(-lr - 1j)] for p in pole_locs])
+    poles = np.concatenate([[p*(-lr + 1j), p*(-lr - 1j)] for p in pole_locs])
 
     if inc_real:
         poles = np.concatenate((poles, [1]))

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

@@ -16,7 +16,7 @@
 # <https://www.gnu.org/licenses/>.
 
 import numpy as np
-from ..microwave_bc import PEC, BoundaryCondition, RectangularWaveguide, RobinBC, PortBC, Periodic
+from ..microwave_bc import PEC, BoundaryCondition, RectangularWaveguide, RobinBC, PortBC, Periodic, MWBoundaryConditionSet
 from ....elements.nedelec2 import Nedelec2
 from ....elements.nedleg2 import NedelecLegrange2
 from ....mth.optimized import gaus_quad_tri
@@ -26,14 +26,7 @@ from scipy.sparse import csr_matrix
 from loguru import logger
 from ..simjob import SimJob
 from .periodicbc import gen_periodic_matrix
-
-
-############################################################
-#                         CONSTANTS                        #
-############################################################
-
-C0 = 299792458
-EPS0 = 8.854187818814e-12
+from ....const import MU0, EPS0, C0
 
 
 ############################################################
@@ -124,7 +117,7 @@ class Assembler:
                         sig: np.ndarray,
                         k0: float,
                         port: PortBC,
-                        bcs: list[BoundaryCondition]) -> tuple[csr_matrix, csr_matrix, np.ndarray, NedelecLegrange2]:
+                        bc_set: MWBoundaryConditionSet) -> tuple[csr_matrix, csr_matrix, np.ndarray, NedelecLegrange2]:
         """Computes the boundary mode analysis matrices
 
         Args:
@@ -134,32 +127,37 @@ class Assembler:
             sig (np.ndarray): The conductivity scalar of shape (N,)
             k0 (float): The simulation phase constant
             port (PortBC): The port boundary condition object
-            bcs (list[BoundaryCondition]): The other boundary conditions
+            bcs (MWBoundaryConditionSet): The other boundary conditions
 
         Returns:
             tuple[np.ndarray, np.ndarray, np.ndarray, NedelecLegrange2]: The E, B, solve ids and Mixed order field object.
         """
         from .generalized_eigen import generelized_eigenvalue_matrix
-        
+        logger.debug('Assembling Boundary Mode Matrices')
+
+        bcs = bc_set.boundary_conditions
         mesh = field.mesh
         tri_ids = mesh.get_triangles(port.tags)
+        logger.trace(f'.boundary face has {len(tri_ids)} triangles.')
 
         origin = tuple([c-n for c,n in zip(port.cs.origin, port.cs.gzhat)])
-        
+        logger.trace(f'.boundary origin {origin}')
+
         boundary_surface = mesh.boundary_surface(port.tags, origin)
         nedlegfield = NedelecLegrange2(boundary_surface, port.cs)
 
         ermesh = er[:,:,tri_ids]
         urmesh = ur[:,:,tri_ids]
         sigmesh = sig[tri_ids]
-
         ermesh = ermesh - 1j * sigmesh/(k0*C0*EPS0)
 
+        logger.trace(f'.assembling matrices for {nedlegfield} at k0={k0:.2f}')
         E, B = generelized_eigenvalue_matrix(nedlegfield, ermesh, urmesh, port.cs._basis, k0)
 
-        pecs: list[PEC] = [bc for bc in bcs if isinstance(bc,PEC)]
+        # TODO: Simplified to all "conductors" loosely defined. Must change to implementing line robin boundary conditions.
+        pecs: list[BoundaryCondition] = bc_set.get_conductors()#[bc for bc in bcs if isinstance(bc,PEC)]
         if len(pecs) > 0:
-            logger.debug('Implementing PEC BCs')
+            logger.debug(f'.total of equiv. {len(pecs)} PEC BCs implemented')
 
         pec_ids = []
 
@@ -172,8 +170,8 @@ class Assembler:
         pec_edges = []
         pec_vertices = []
         for pec in pecs:
+            logger.trace(f'.implementing {pec}')
             face_tags = pec.tags
-
             tri_ids = mesh.get_triangles(face_tags)
             edge_ids = list(mesh.tri_to_edge[:,tri_ids].flatten())
             for ii in edge_ids:
@@ -186,7 +184,6 @@ class Assembler:
                 pec_vertices.append(eids[3]-nedlegfield.n_xy)
                 pec_vertices.append(eids[4]-nedlegfield.n_xy)
             
-
             for ii in tri_ids:
                 i2 = nedlegfield.mesh.from_source_tri(ii)
                 if i2 is None:
@@ -196,6 +193,8 @@ class Assembler:
 
         # Process all port boundary Conditions
         pec_ids_set: set[int] = set(pec_ids)
+
+        logger.trace(f'.total of {len(pec_ids_set)} pec DoF to remove.')
         solve_ids = [i for i in range(nedlegfield.n_field) if i not in pec_ids_set]
 
         return E, B, np.array(solve_ids), nedlegfield
@@ -236,11 +235,11 @@ class Assembler:
 
         if cache_matrices and not is_frequency_dependent and self.cached_matrices is not None:
             # IF CACHED AND AVAILABLE PULL E AND B FROM CACHE
-            logger.debug('    Retreiving cached matricies')
+            logger.debug('Using cached matricies.')
             E, B = self.cached_matrices
         else:
             # OTHERWISE, COMPUTE
-            logger.debug('    Assembling matrices')
+            logger.debug('Assembling matrices')
             E, B = tet_mass_stiffness_matrices(field, er, ur)
             self.cached_matrices = (E, B)
 
@@ -259,15 +258,24 @@ class Assembler:
         b = np.zeros((E.shape[0],)).astype(np.complex128)
         port_vectors = {port.port_number: np.zeros((E.shape[0],)).astype(np.complex128) for port in port_bcs}
         
-        # Process all PEC Boundary Conditions
-        logger.debug('    Implementing PEC Boundary Conditions.')
+
+        ############################################################
+        #                      PEC BOUNDARY CONDITIONS             #
+        ############################################################
+
+        logger.debug('Implementing PEC Boundary Conditions.')
         pec_ids: list[int] = []
         # Conductivity above al imit, consider it all PEC
+        ipec = 0
         for itet in range(field.n_tets):
             if sig[itet] > self.conductivity_limit:
+                ipec+=1
                 pec_ids.extend(field.tet_to_field[:,itet])
-        
+        if ipec>0:
+            logger.trace(f'Extended PEC with {ipec} tets with a conductivity > {self.conductivity_limit}.')
+
         for pec in pec_bcs:
+            logger.trace(f'Implementing: {pec}')
             if len(pec.tags)==0:
                 continue
             face_tags = pec.tags
@@ -282,14 +290,18 @@ class Assembler:
                 tids = field.tri_to_field[:, ii]
                 pec_ids.extend(list(tids))
 
-        # Robin BCs
+
+        ############################################################
+        #                     ROBIN BOUNDARY CONDITIONS            #
+        ############################################################
+
         if len(robin_bcs) > 0:
-            logger.debug('    Implementing Robin Boundary Conditions.')
+            logger.debug('Implementing Robin Boundary Conditions.')
         
             gauss_points = gaus_quad_tri(4)
             Bempty = field.empty_tri_matrix()
             for bc in robin_bcs:
-
+                logger.trace(f'.Implementing {bc}')
                 for tag in bc.tags:
                     face_tags = [tag,]
 
@@ -298,6 +310,7 @@ class Assembler:
                     edge_ids = list(mesh.tri_to_edge[:,tri_ids].flatten())
 
                     gamma = bc.get_gamma(K0)
+                    logger.trace(f'..robin bc γ={gamma:.3f}')
 
                     def Ufunc(x,y): 
                         return bc.get_Uinc(x,y,K0)
@@ -306,38 +319,42 @@ class Assembler:
                     if ibasis is None:
                         basis = plane_basis_from_points(mesh.nodes[:,nodes]) + 1e-16
                         ibasis = np.linalg.pinv(basis)
+                        logger.trace(f'..Using computed basis: {ibasis.flatten()}')
                     if bc._include_force:
-                        
                         Bempty, b_p = assemble_robin_bc_excited(field, Bempty, tri_ids, Ufunc, gamma, ibasis, bc.cs.origin, gauss_points) # type: ignore
-                        
                         port_vectors[bc.port_number] += b_p # type: ignore
-                    
+                        logger.trace(f'..included force vector term with norm {np.linalg.norm(b_p):.3f}')
                     else:
                         Bempty = assemble_robin_bc(field, Bempty, tri_ids, gamma) # type: ignore
             B_p = field.generate_csr(Bempty)
             K = K + B_p
         
         if len(periodic_bcs) > 0:
-            logger.debug('    Implementing Periodic Boundary Conditions.')
+            logger.debug('Implementing Periodic Boundary Conditions.')
+
+
+        ############################################################
+        #                   PERIODIC BOUNDARY CONDITIONS          #
+        ############################################################
 
-        
-        # Periodic BCs
         Pmats = []
         remove: set[int] = set()
         has_periodic = False
 
         for pbc in periodic_bcs:
+            logger.trace(f'.Implementing {pbc}')
             has_periodic = True
             tri_ids_1 = mesh.get_triangles(pbc.face1.tags)
             edge_ids_1 = mesh.get_edges(pbc.face1.tags)
             tri_ids_2 = mesh.get_triangles(pbc.face2.tags)
             edge_ids_2 = mesh.get_edges(pbc.face2.tags)
             dv = np.array(pbc.dv)
+            logger.trace(f'..displacement vector {dv}')
             linked_tris = pair_coordinates(mesh.tri_centers, tri_ids_1, tri_ids_2, dv, 1e-9)
             linked_edges = pair_coordinates(mesh.edge_centers, edge_ids_1, edge_ids_2, dv, 1e-9)
             dv = np.array(pbc.dv)
             phi = pbc.phi(K0)
-            
+            logger.trace(f'..ϕ={phi} rad/m')
             Pmat, rows = gen_periodic_matrix(tri_ids_1,
                                        edge_ids_1,
                                        field.tri_to_field,
@@ -348,8 +365,9 @@ class Assembler:
                                        phi)
             remove.update(rows)
             Pmats.append(Pmat)
-        
+
         if Pmats:
+            logger.trace(f'.periodic bc removes {len(remove)} boundary DoF')
             Pmat = Pmats[0]
             for P2 in Pmats[1:]:
                 Pmat = Pmat @ P2
@@ -360,6 +378,11 @@ class Assembler:
         else:
             Pmat = None
         
+
+        ############################################################
+        #                             FINALIZE                     #
+        ############################################################
+
         pec_ids_set = set(pec_ids)
         solve_ids = np.array([i for i in range(E.shape[0]) if i not in pec_ids_set])
         
@@ -416,7 +439,7 @@ class Assembler:
 
         er = er - 1j*sig/(w0*EPS0)*np.repeat(np.eye(3)[:, :, np.newaxis], er.shape[2], axis=2)
         
-        logger.debug('    Assembling matrices')
+        logger.debug('Assembling matrices')
         E, B = tet_mass_stiffness_matrices(field, er, ur)
         self.cached_matrices = (E, B)
 
@@ -429,7 +452,7 @@ class Assembler:
         # Process all PEC Boundary Conditions
         pec_ids: list = []
         
-        logger.debug('    Implementing PEC Boundary Conditions.')
+        logger.debug('Implementing PEC Boundary Conditions.')
         
         # Conductivity above a limit, consider it all PEC
         for itet in range(field.n_tets):
@@ -454,10 +477,10 @@ class Assembler:
 
         # Robin BCs
         if len(robin_bcs) > 0:
-            logger.debug('    Implementing Robin Boundary Conditions.')
+            logger.debug('Implementing Robin Boundary Conditions.')
         
         if len(robin_bcs) > 0:
-            logger.debug('    Implementing Robin Boundary Conditions.')
+            logger.debug('Implementing Robin Boundary Conditions.')
         
             gauss_points = gaus_quad_tri(4)
             Bempty = field.empty_tri_matrix()
@@ -482,7 +505,7 @@ class Assembler:
             B = B + B_p
         
         if len(periodic) > 0:
-            logger.debug('    Implementing Periodic Boundary Conditions.')
+            logger.debug('Implementing Periodic Boundary Conditions.')
 
         # Periodic BCs
         Pmats = []