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

emerge/_emerge/physics/microwave/microwave_bc.py

@@ -27,10 +27,12 @@ from dataclasses import dataclass
 from collections import defaultdict
 from ...bc import BoundaryCondition, BoundaryConditionSet, Periodic
 from ...periodic import PeriodicCell, HexCell, RectCell
+from ...material import Material
+from ...const import Z0, C0, PI, EPS0, MU0
 
 class MWBoundaryConditionSet(BoundaryConditionSet):
 
-    def __init__(self, periodic_cell: PeriodicCell):
+    def __init__(self, periodic_cell: PeriodicCell | None):
         super().__init__()
 
         self.PEC: type[PEC] = self._construct_bc(PEC)
@@ -39,13 +41,28 @@ class MWBoundaryConditionSet(BoundaryConditionSet):
         self.ModalPort: type[ModalPort] = self._construct_bc(ModalPort)
         self.LumpedPort: type[LumpedPort] = self._construct_bc(LumpedPort)
         self.LumpedElement: type[LumpedElement] = self._construct_bc(LumpedElement)
+        self.SurfaceImpedance: type[SurfaceImpedance] = self._construct_bc(SurfaceImpedance)
         self.RectangularWaveguide: type[RectangularWaveguide] = self._construct_bc(RectangularWaveguide)
         self.Periodic: type[Periodic] = self._construct_bc(Periodic)
         self.FloquetPort: type[FloquetPort] = self._construct_bc(FloquetPort)
 
-        self._cell: PeriodicCell = None
+        self._cell: PeriodicCell | None = None
 
-    def get_type(self, bctype: Literal['PEC','ModalPort','LumpedPort','PMC','LumpedElement','RectangularWaveguide','Periodic','FloquetPort']) -> FaceSelection:
+    def get_conductors(self) -> list[BoundaryCondition]:
+        """Returns a list of all boundary conditions that ought to be considered as a "conductor" 
+        for the purpose of modal analyses.
+
+        Returns:
+            list[BoundaryCondition]: All conductor like boundary conditions
+        """
+        bcs = self.oftype(PEC)
+        for bc in self.oftype(SurfaceImpedance):
+            if bc.material.cond > 1e3:
+                bcs.append(bc)
+
+        return bcs
+
+    def get_type(self, bctype: Literal['PEC','ModalPort','LumpedPort','PMC','LumpedElement','RectangularWaveguide','Periodic','FloquetPort','SurfaceImpedance']) -> FaceSelection:
         tags = []
         for bc in self.boundary_conditions:
             if bctype in str(bc.__class__):
@@ -101,25 +118,25 @@ class RobinBC(BoundaryCondition):
         """
         super().__init__(selection)
         self.v_integration: bool = False
-        self.vintline: Line = None
+        self.vintline: Line | None = None
     
     def get_basis(self) -> np.ndarray:
-        return None
+        raise NotImplementedError('This method is not implemented')
     
-    def get_inv_basis(self) -> np.ndarray:
-        return None
+    def get_inv_basis(self) -> np.ndarray | None :
+        raise NotImplementedError('This method is not implemented')
     
-    def get_beta(self, k0) -> float:
+    def get_beta(self, k0: float) -> float:
         raise NotImplementedError('get_beta not implemented for Port class')
     
-    def get_gamma(self, k0) -> float:
+    def get_gamma(self, k0: float) -> complex:
         raise NotImplementedError('get_gamma not implemented for Port class')
     
-    def get_Uinc(self, k0) -> np.ndarray:
+    def get_Uinc(self, x_local: np.ndarray, y_local: np.ndarray, k0: float) -> np.ndarray:
         raise NotImplementedError('get_Uinc not implemented for Port class')
 
 class PortBC(RobinBC):
-    Zvac: float = 376.730313412
+    Zvac: float = Z0
     def __init__(self, face: FaceSelection | GeoSurface):
         """(DO NOT USE) A generalization of the Port boundary condition.
         
@@ -130,19 +147,24 @@ class PortBC(RobinBC):
             face (FaceSelection | GeoSurface): The port face
         """
         super().__init__(face)
-        self.port_number: int = None
-        self.cs: CoordinateSystem = None
+        self.port_number: int = -1
+        self.cs: CoordinateSystem = GCS
         self.selected_mode: int = 0
-        self.Z0 = None
-        self.active: bool = False
+        self.Z0: complex | float | None = None
+        self.active: bool | None = False
+        self.power: float = 1.0
 
+    @property
+    def voltage(self) -> complex | None:
+        return None
+        
     def get_basis(self) -> np.ndarray:
         return self.cs._basis
     
     def get_inv_basis(self) -> np.ndarray:
         return self.cs._basis_inv
     
-    def portZ0(self, k0: float = None) -> complex:
+    def portZ0(self, k0: float) -> complex | float | None:
         """Returns the port characteristic impedance given a phase constant
 
         Args:
@@ -160,11 +182,11 @@ class PortBC(RobinBC):
         if self.modetype(k0)=='TEM':
             return self.Zvac
         elif self.modetype(k0)=='TE':
-            return k0*299792458/self.get_beta(k0) * 4*np.pi*1e-7
+            return k0*299792458/self.get_beta(k0) * MU0
         elif self.modetype(k0)=='TM':
-            return self.get_beta(k0)/(k0*299792458*8.854187818814*1e-12)
+            return self.get_beta(k0)/(k0*299792458*EPS0)
         else:
-            return ValueError(f'Port mode type should be TEM, TE or TM but instead is {self.modetype(k0)}')
+            raise ValueError(f'Port mode type should be TEM, TE or TM but instead is {self.modetype(k0)}')
     
     def _qmode(self, k0: float) -> float:
         """Computes a mode amplitude correction factor.
@@ -178,7 +200,7 @@ class PortBC(RobinBC):
         Returns:
             float: The mode amplitude correction factor.
         """
-        return np.sqrt(self.Zmode(k0)/376.73031341259)
+        return np.sqrt(self.Zmode(k0)/Z0)
     
     @property
     def mode_number(self) -> int:
@@ -188,7 +210,7 @@ class PortBC(RobinBC):
         ''' Return the out of plane propagation constant. βz.'''
         return k0
     
-    def get_gamma(self, k0):
+    def get_gamma(self, k0) -> complex:
         """Computes the γ-constant for matrix assembly. This constant is required for the Robin boundary condition.
 
         Args:
@@ -226,7 +248,7 @@ class AbsorbingBoundary(RobinBC):
     def __init__(self,
                  face: FaceSelection | GeoSurface,
                  order: int = 1,
-                 origin: tuple = None):
+                 origin: tuple | None = None):
         """Creates an AbsorbingBoundary condition.
 
         Currently only a first order boundary condition is possible. Second order will be supported later.
@@ -239,19 +261,23 @@ class AbsorbingBoundary(RobinBC):
             origin (tuple, optional): The radiation origin. Defaults to None.
         """
         super().__init__(face)
-    
+        if origin is None:
+            origin = (0., 0., 0.)
         self.order: int = order
         self.origin: tuple = origin
         self.cs: CoordinateSystem = GCS
 
     def get_basis(self) -> np.ndarray:
         return np.eye(3)
+
+    def get_inv_basis(self) -> np.ndarray | None:
+        return None
     
-    def get_beta(self, k0) -> float:
+    def get_beta(self, k0: float) -> float:
         ''' Return the out of plane propagation constant. βz.'''
         return k0
 
-    def get_gamma(self, k0):
+    def get_gamma(self, k0: float) -> complex:
         """Computes the γ-constant for matrix assembly. This constant is required for the Robin boundary condition.
 
         Args:
@@ -262,7 +288,7 @@ class AbsorbingBoundary(RobinBC):
         """
         return 1j*self.get_beta(k0)
     
-    def get_Uinc(self, x_local, y_local, k0) -> np.ndarray:
+    def get_Uinc(self, x_local: np.ndarray, y_local: np.ndarray, k0: float) -> np.ndarray:
         return np.zeros((3, len(x_local)), dtype=np.complex128)
 
 @dataclass
@@ -273,13 +299,13 @@ class PortMode:
     k0: float
     beta: float
     residual: float
-    energy: float = None
+    energy: float = 0
     norm_factor: float = 1
-    freq: float = None
-    neff: float = None
-    TEM: bool = None
-    Z0: float = None
-    polarity: float = 1
+    freq: float = 0
+    neff: float = 1
+    TEM: bool = True
+    Z0: float = 50.0
+    polarity: float = 1.0
     modetype: Literal['TEM','TE','TM'] = 'TEM'
 
     def __post_init__(self):
@@ -291,7 +317,7 @@ class PortMode:
     
     def set_power(self, power: complex) -> None:
         self.norm_factor = np.sqrt(1/np.abs(power))
-        logger.info(f'Setting port mode amplitude to: {self.norm_factor} ')
+        logger.info(f'Setting port mode amplitude to: {self.norm_factor:.2f} ')
 
 class FloquetPort(PortBC):
     _include_stiff: bool = True
@@ -301,28 +327,31 @@ class FloquetPort(PortBC):
     def __init__(self,
                  face: FaceSelection | GeoSurface,
                  port_number: int,
-                 cs: CoordinateSystem = None,
+                 cs: CoordinateSystem |  None = None,
                  power: float = 1.0,
                  er: float = 1.0):
         super().__init__(face)
+        if cs is None:
+            cs = GCS
         self.port_number: int= port_number
         self.active: bool = True
         self.power: float = power
         self.type: str = 'TEM'
-        self._field_amplitude: np.ndarray = None
         self.mode: tuple[int,int] = (1,0)
         self.cs: CoordinateSystem = cs
         self.scan_theta: float = 0
         self.scan_phi: float = 0
-        self.pol_s: complex = 1.0
-        self.pol_p: complex = 0.0
-        self.Zdir: Axis = -1
+        self.pol_s: complex = 1.0 + 0j
+        self.pol_p: complex = 0j
         self.area: float = 1
+        self.width: float | None = None
+        self.height: float | None = None
+
         if self.cs is None:
             self.cs = GCS
 
-    def portZ0(self, k0: float = None) -> complex:
-        return 376.73031341259
+    def portZ0(self, k0: float | None = None) -> complex | float | None:
+        return Z0
 
     def get_amplitude(self, k0: float) -> float:
         return 1.0
@@ -331,7 +360,7 @@ class FloquetPort(PortBC):
         ''' Return the out of plane propagation constant. βz.'''
         return k0*np.cos(self.scan_theta)
     
-    def get_gamma(self, k0: float):
+    def get_gamma(self, k0: float) -> complex:
         """Computes the γ-constant for matrix assembly. This constant is required for the Robin boundary condition.
 
         Args:
@@ -360,7 +389,7 @@ class FloquetPort(PortBC):
         P = self.pol_p
         S = self.pol_s
 
-        E0 = self.get_amplitude(k0)*np.sqrt(2*376.73031341259/(self.area))
+        E0 = self.get_amplitude(k0)*np.sqrt(2*Z0/(self.area))
         Ex = E0*(-S*np.sin(self.scan_phi) - P*np.cos(self.scan_theta)*np.cos(self.scan_phi))*phi
         Ey = E0*(S*np.cos(self.scan_phi) - P*np.cos(self.scan_theta)*np.sin(self.scan_phi))*phi
         Ez = E0*(-P*E0*np.sin(self.scan_theta))*phi
@@ -374,6 +403,8 @@ class FloquetPort(PortBC):
                             k0: float,
                             which: Literal['E','H'] = 'E') -> np.ndarray:
         '''Compute the port mode field for global xyz coordinates.'''
+        if self.cs is None:
+            raise ValueError('No coordinate system is defined for this FloquetPort')
         xl, yl, _ = self.cs.in_local_cs(x_global, y_global, z_global)
         Ex, Ey, Ez = self.port_mode_3d(xl, yl, k0)
         Exg, Eyg, Ezg = self.cs.in_global_basis(Ex, Ey, Ez)
@@ -389,7 +420,7 @@ class ModalPort(PortBC):
                  face: FaceSelection | GeoSurface,
                  port_number: int, 
                  active: bool = False,
-                 cs: CoordinateSystem = None,
+                 cs: CoordinateSystem | None = None,
                  power: float = 1,
                  TEM: bool = False,
                  mixed_materials: bool = False):
@@ -418,7 +449,7 @@ class ModalPort(PortBC):
         self.port_number: int= port_number
         self.active: bool = active
         self.power: float = power
-        self.cs: CoordinateSystem = cs
+        
 
         self.selected_mode: int = 0
         self.modes: dict[float, list[PortMode]] = defaultdict(list)
@@ -426,17 +457,18 @@ class ModalPort(PortBC):
         self.TEM: bool = TEM
         self.mixed_materials: bool = mixed_materials
         self.initialized: bool = False
-        self._first_k0: float = None
-        self._last_k0: float = None
+        self._first_k0: float | None = None
+        self._last_k0: float | None = None
 
-        if self.cs is None:
+        if cs is None:
             logger.info('Constructing coordinate system from normal port')
-            self.cs = Axis(self.selection.normal).construct_cs()
-
-        self._er: np.ndarray = None
-        self._ur: np.ndarray = None
+            self.cs = Axis(self.selection.normal).construct_cs() # type: ignore
+        else:
+            raise ValueError('No Coordinate System could be derived.')
+        self._er: np.ndarray | None = None
+        self._ur: np.ndarray | None = None
     
-    def portZ0(self, k0: float) -> complex:
+    def portZ0(self, k0: float) -> complex | float | None:
         return self.get_mode(k0).Z0
     
     def modetype(self, k0: float) -> Literal['TEM','TE','TM']:
@@ -444,8 +476,15 @@ class ModalPort(PortBC):
     
     @property
     def nmodes(self) -> int:
+        if self._last_k0 is None:
+            raise ValueError('ModalPort is not properly configured. No modes are defined.')
         return len(self.modes[self._last_k0])
     
+    @property
+    def voltage(self) -> complex:
+        mode = self.get_mode(0)
+        return np.sqrt(mode.Z0)
+        
     def sort_modes(self) -> None:
         """Sorts the port modes based on total energy
         """
@@ -476,7 +515,7 @@ class ModalPort(PortBC):
     
     def clear_modes(self) -> None:
         """Clear all port mode data"""
-        self.modes: dict[float, list[PortMode]] = defaultdict(list)
+        self.modes = defaultdict(list)
         self.initialized = False
 
     def add_mode(self, 
@@ -487,7 +526,7 @@ class ModalPort(PortBC):
                  k0: float,
                  residual: float,
                  TEM: bool,
-                 freq: float) -> PortMode:
+                 freq: float) -> PortMode | None:
         """Add a mode function to the ModalPort
 
         Args:
@@ -523,6 +562,9 @@ class ModalPort(PortBC):
 
     def get_basis(self) -> np.ndarray:
         return self.cs._basis
+
+    def get_inv_basis(self) -> np.ndarray:
+        return self.cs._basis_inv
     
     def get_beta(self, k0: float) -> float:
         mode = self.get_mode(k0)
@@ -533,7 +575,7 @@ class ModalPort(PortBC):
             beta = np.sqrt(mode.beta**2 + k0**2 * (1-((mode.freq/freq)**2)))
         return beta
 
-    def get_gamma(self, k0: float):
+    def get_gamma(self, k0: float) -> complex:
         return 1j*self.get_beta(k0)
     
     def get_Uinc(self, x_local, y_local, k0) -> np.ndarray:
@@ -573,8 +615,8 @@ class RectangularWaveguide(PortBC):
                  face: FaceSelection | GeoSurface,
                  port_number: int, 
                  active: bool = False,
-                 cs: CoordinateSystem = None,
-                 dims: tuple[float, float] = None,
+                 cs: CoordinateSystem | None = None,
+                 dims: tuple[float, float] | None = None,
                  power: float = 1):
         """Creates a rectangular waveguide as a port boundary condition.
         
@@ -593,19 +635,17 @@ class RectangularWaveguide(PortBC):
             power (float): The port power. Default to 1.
         """
         super().__init__(face)
-        
+
         self.port_number: int= port_number
         self.active: bool = active
         self.power: float = power
         self.type: str = 'TE'
-        self._field_amplitude: np.ndarray = None
         self.mode: tuple[int,int] = (1,0)
-        self.cs: CoordinateSystem = cs
 
         if dims is None:
             logger.info("Determining port face based on selection")
-            cs, (width, height) = face.rect_basis()
-            self.cs = cs
+            cs, (width, height) = self.selection.rect_basis() # type: ignore
+            self.cs = cs # type: ignore
             self.dims = (width, height)
             logger.debug(f'Port CS: {self.cs}')
             logger.debug(f'Detected port {self.port_number} size = {width*1000:.1f} mm x {height*1000:.1f} mm')
@@ -614,32 +654,25 @@ class RectangularWaveguide(PortBC):
             logger.info('Constructing coordinate system from normal port')
             self.cs = Axis(self.selection.normal).construct_cs()
         else:
-            self.cs: CoordinateSystem = cs
+            self.cs: CoordinateSystem = cs # type: ignore
 
-    def portZ0(self, k0: float = None) -> complex:
-        return k0*299792458 * 4*np.pi*1e-7/self.get_beta(k0)
+    def get_basis(self) -> np.ndarray:
+        return self.cs._basis
+        
+    def get_inv_basis(self) -> np.ndarray:
+        return self.cs._basis_inv
+    
+    def portZ0(self, k0: float) -> complex:
+        return k0*299792458 * MU0/self.get_beta(k0)
 
     def modetype(self, k0):
         return self.type
     
     def get_amplitude(self, k0: float) -> float:
-        Zte = 376.73031341259
+        Zte = Z0
         amplitude= np.sqrt(self.power*4*Zte/(self.dims[0]*self.dims[1]))
         return amplitude
-    
-    def port_mode_2d(self, xs: np.ndarray, ys: np.ndarray, k0: float) -> tuple[np.ndarray, float]:
-        x0 = xs[0]
-        y0 = ys[0]
-        x1 = xs[-1]
-        y1 = ys[-1]
-        xc = 0.5*(x0+x1)
-        yc = 0.5*(y0+y1)
-        a = np.sqrt((x1-x0)**2 + (y1-y0)**2)
-        
-        logger.debug(f'Detected port {self.port_number} width = {a*1000:.1f} mm')
-        ds = np.sqrt((xs-xc)**2 + (ys-yc)**2)
-        return self.amplitude*np.cos(ds*np.pi/a), np.sqrt(k0**2 - (np.pi/a)**2)
-    
+
     def get_beta(self, k0: float) -> float:
         ''' Return the out of plane propagation constant. βz.'''
         width=self.dims[0]
@@ -647,7 +680,7 @@ class RectangularWaveguide(PortBC):
         beta = np.sqrt(k0**2 - (np.pi*self.mode[0]/width)**2 - (np.pi*self.mode[1]/height)**2)
         return beta
     
-    def get_gamma(self, k0: float):
+    def get_gamma(self, k0: float) -> complex:
         """Computes the γ-constant for matrix assembly. This constant is required for the Robin boundary condition.
 
         Args:
@@ -699,10 +732,10 @@ class LumpedPort(PortBC):
     def __init__(self, 
                  face: FaceSelection | GeoSurface,
                  port_number: int, 
-                 width: float = None,
-                 height: float = None,
-                 direction: Axis = None,
-                 Idirection: Axis = None,
+                 width: float | None = None,
+                 height: float | None = None,
+                 direction: Axis | None = None,
+                 Idirection: Axis | None = None,
                  active: bool = False,
                  power: float = 1,
                  Z0: float = 50):
@@ -733,26 +766,25 @@ class LumpedPort(PortBC):
             if width is None or height is None or direction is None:
                 raise ValueError(f'The width, height and direction could not be extracted from {face}')
         
-        logger.debug(f'Lumped port: width={1000*width:.1f}mm, height={1000*height:.1f}mm, direction={direction}')
+        logger.debug(f'Lumped port: width={1000*width:.1f}mm, height={1000*height:.1f}mm, direction={direction}') # type: ignore
         self.port_number: int= port_number
         self.active: bool = active
 
         self.power: float = power
         self.Z0: float = Z0
         
-        self._field_amplitude: np.ndarray = None
         self.width: float = width
-        self.height: float = height
-        self.Vdirection: Axis = direction
-        self.Idirection: Axis = Idirection
+        self.height: float = height # type: ignore
+        self.Vdirection: Axis = direction # type: ignore
+        self.Idirection: Axis = Idirection # type: ignore
         self.type = 'TEM'
         
         logger.info('Constructing coordinate system from normal port')
-        self.cs = Axis(self.selection.normal).construct_cs()
+        self.cs = Axis(self.selection.normal).construct_cs()  # type: ignore
 
-        self.vintline: Line = None
+        self.vintline: Line | None = None
         self.v_integration = True
-        self.iintline: Line = None
+        self.iintline: Line | None = None
 
     @property
     def surfZ(self) -> float:
@@ -774,6 +806,9 @@ class LumpedPort(PortBC):
     
     def get_basis(self) -> np.ndarray:
         return self.cs._basis
+        
+    def get_inv_basis(self) -> np.ndarray:
+        return self.cs._basis_inv
     
     def get_beta(self, k0: float) -> float:
         ''' Return the out of plane propagation constant. βz.'''
@@ -789,10 +824,10 @@ class LumpedPort(PortBC):
         Returns:
             complex: The γ-constant
         """
-        return 1j*k0*376.730313412/self.surfZ
+        return 1j*k0*Z0/self.surfZ
     
     def get_Uinc(self, x_local, y_local, k0) -> np.ndarray:
-        Emag = -1j*2*k0 * self.voltage/self.height * (376.730313412/self.surfZ)
+        Emag = -1j*2*k0 * self.voltage/self.height * (Z0/self.surfZ)
         return Emag*self.port_mode_3d(x_local, y_local, k0)
     
     def port_mode_3d(self, 
@@ -845,9 +880,9 @@ class LumpedElement(RobinBC):
 
     def __init__(self, 
                  face: FaceSelection | GeoSurface,
-                 impedance_function: Callable = None,
-                 width: float = None,
-                 height: float = None,
+                 impedance_function: Callable | None = None,
+                 width: float | None = None,
+                 height: float | None = None,
                  ):
         """Generates a lumped power boundary condition.
         
@@ -876,23 +911,14 @@ class LumpedElement(RobinBC):
             if width is None or height is None or impedance_function is None:
                 raise ValueError(f'The width, height and impedance function could not be extracted from {face}')
         
-        logger.debug(f'Lumped port: width={1000*width:.1f}mm, height={1000*height:.1f}mm')
-
-        self.Z0: Callable = impedance_function
-        
-        self._field_amplitude: np.ndarray = None
-        self.width: float = width
-        self.height: float = height
-        
-        logger.info('Constructing coordinate system from normal port')
-        self.cs = Axis(self.selection.normal).construct_cs()
+        logger.debug(f'Lumped port: width={1000*width:.1f}mm, height={1000*height:.1f}mm') # type: ignore
 
-        self.vintline: Line = None
-        self.v_integration = True
-        self.iintline: Line = None
+        self.Z0: Callable = impedance_function # type: ignore
+        self.width: float = width # type: ignore
+        self.height: float = height # type: ignore
 
     def surfZ(self, k0: float) -> float:
-        """The surface sheet impedance for the lumped port
+        """The surface sheet impedance for the lumped Element
 
         Returns:
             float: The surface sheet impedance
@@ -900,15 +926,17 @@ class LumpedElement(RobinBC):
         Z0 = self.Z0(k0*299792458/(2*np.pi))*self.width/self.height
         return Z0
     
-    
-    def get_basis(self) -> np.ndarray:
-        return self.cs._basis
+    def get_basis(self) -> np.ndarray | None:
+        return None
+
+    def get_inv_basis(self) -> np.ndarray | None:
+        return None
     
     def get_beta(self, k0: float) -> float:
         ''' Return the out of plane propagation constant. βz.'''
 
         return k0
-    
+
     def get_gamma(self, k0: float) -> complex:
         """Computes the γ-constant for matrix assembly. This constant is required for the Robin boundary condition.
 
@@ -918,6 +946,67 @@ class LumpedElement(RobinBC):
         Returns:
             complex: The γ-constant
         """
-        return 1j*k0*376.730313412/self.surfZ(k0)
+        return 1j*k0*Z0/self.surfZ(k0)
+    
+
+
+class SurfaceImpedance(RobinBC):
+    
+    _include_stiff: bool = True
+    _include_mass: bool = False
+    _include_force: bool = False
+
+    def __init__(self, 
+                 face: FaceSelection | GeoSurface,
+                 material: Material | None = None,
+                 ):
+        """Generates a lumped power boundary condition.
+        
+        The lumped port boundary condition assumes a uniform E-field along the "direction" axis.
+        The port with and height must be provided manually in meters. The height is the size
+        in the "direction" axis along which the potential is imposed. The width dimension
+        is orthogonal to that. For a rectangular face its the width and for a cyllindrical face
+        its the circumpherance.
+
+        Args:
+            face (FaceSelection, GeoSurface): The port surface
+            port_number (int): The port number
+            width (float): The port width (meters).
+            height (float): The port height (meters).
+            direction (Axis): The port direction as an Axis object (em.Axis(..) or em.ZAX)
+            active (bool, optional): Whether the port is active. Defaults to False.
+            power (float, optional): The port output power. Defaults to 1.
+            Z0 (float, optional): The port impedance. Defaults to 50.
+        """
+        super().__init__(face)
 
+        self.material: Material = material 
+    
+    
+    def get_basis(self) -> np.ndarray | None:
+        return None
 
+    def get_inv_basis(self) -> np.ndarray | None:
+        return None
+    
+    def get_beta(self, k0: float) -> float:
+        ''' Return the out of plane propagation constant. βz.'''
+
+        return k0
+
+    def get_gamma(self, k0: float) -> complex:
+        """Computes the γ-constant for matrix assembly. This constant is required for the Robin boundary condition.
+
+        Args:
+            k0 (float): The free space propagation constant.
+
+        Returns:
+            complex: The γ-constant
+        """
+        w0 = k0*C0
+        sigma = self.material.cond
+        rho = 1/sigma
+        d_skin = (2*rho/(w0*MU0) * ((1+(w0*EPS0*rho)**2)**0.5 + rho*w0*EPS0))**0.5
+        d_skin = (2*rho/(w0*MU0))**0.5
+        R = rho/d_skin
+        return 1j*k0*Z0/R