phased-array-modeling 1.3.2__tar.gz → 1.4.0__tar.gz

{phased_array_modeling-1.3.2 → phased_array_modeling-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: phased-array-modeling
-Version: 1.3.2
+Version: 1.4.0
 Summary: Comprehensive Python library for phased array antenna modeling and visualization
 Author-email: John Hodge <jah70@vt.edu>
 License: MIT
@@ -15,14 +15,13 @@ Classifier: Intended Audience :: Education
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Scientific/Engineering :: Physics
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy>=1.20.0
@@ -63,6 +62,7 @@ A comprehensive Python library for computing and visualizing phased array antenn
 - **Multiple Geometries**: Rectangular, triangular, circular, cylindrical, spherical, sparse/thinned arrays
 - **Beamforming**: Amplitude tapering (Taylor, Chebyshev, etc.), null steering, multi-beam
 - **Realistic Impairments**: Mutual coupling, phase quantization, element failures, scan blindness
+- **Polarized Patterns**: Vector (E-theta, E-phi) patterns with dipole/patch/CP element models, co/cross-pol cuts, axial ratio and XPD maps, measured element pattern import
 - **Visualization**: 2D matplotlib, interactive 3D Plotly, UV-space representation
 - **Subarray Support**: Subarray-level beamforming with quantized phase shifters
 - **Data Export**: CSV, JSON, and NumPy formats for patterns, weights, and geometry
@@ -239,6 +239,7 @@ phased_array/
 ├── impairments.py   # Coupling, quantization, failures, scan blindness
 ├── wideband.py      # True-time-delay steering, beam squint, bandwidth
 ├── polarization.py  # Jones/Stokes, axial ratio, XPD, Ludwig-3
+├── vector_patterns.py # Polarized elements, vector AF, co/cross patterns
 ├── coordinates.py   # Antenna/radar/cone frames, pattern rotation
 ├── export.py        # CSV/JSON/NPZ export, summary reports
 ├── visualization.py # 2D, 3D Plotly, UV-space plotting

{phased_array_modeling-1.3.2 → phased_array_modeling-1.4.0}/README.md

@@ -17,6 +17,7 @@ A comprehensive Python library for computing and visualizing phased array antenn
 - **Multiple Geometries**: Rectangular, triangular, circular, cylindrical, spherical, sparse/thinned arrays
 - **Beamforming**: Amplitude tapering (Taylor, Chebyshev, etc.), null steering, multi-beam
 - **Realistic Impairments**: Mutual coupling, phase quantization, element failures, scan blindness
+- **Polarized Patterns**: Vector (E-theta, E-phi) patterns with dipole/patch/CP element models, co/cross-pol cuts, axial ratio and XPD maps, measured element pattern import
 - **Visualization**: 2D matplotlib, interactive 3D Plotly, UV-space representation
 - **Subarray Support**: Subarray-level beamforming with quantized phase shifters
 - **Data Export**: CSV, JSON, and NumPy formats for patterns, weights, and geometry
@@ -193,6 +194,7 @@ phased_array/
 ├── impairments.py   # Coupling, quantization, failures, scan blindness
 ├── wideband.py      # True-time-delay steering, beam squint, bandwidth
 ├── polarization.py  # Jones/Stokes, axial ratio, XPD, Ludwig-3
+├── vector_patterns.py # Polarized elements, vector AF, co/cross patterns
 ├── coordinates.py   # Antenna/radar/cone frames, pattern rotation
 ├── export.py        # CSV/JSON/NPZ export, summary reports
 ├── visualization.py # 2D, 3D Plotly, UV-space plotting

{phased_array_modeling-1.3.2 → phased_array_modeling-1.4.0}/phased_array/__init__.py

@@ -9,6 +9,7 @@ antenna radiation patterns, including:
 - Various array geometries (rectangular, circular, conformal, sparse)
 - Beamforming techniques (tapering, null steering, multi-beam)
 - Realistic impairments (mutual coupling, quantization, failures, scan blindness)
+- Vector (polarized) patterns: co/cross-pol, axial ratio, XPD, conformal
 - Interactive 3D visualization with Plotly
 - UV-space pattern representation
 
@@ -32,7 +33,7 @@ Example
 >>> theta, phi, pattern_dB = pa.compute_full_pattern(geom.x, geom.y, weights, k)
 """
 
-__version__ = "1.3.2"
+__version__ = "1.4.0"
 
 # Beamforming functions
 from .beamforming import (  # Amplitude tapers; Null steering; Multiple beams; Beam spoiling; Adaptive
@@ -95,6 +96,16 @@ from .utils import (azel_to_thetaphi, create_theta_phi_grid, create_uv_grid,
                     frequency_to_wavelength, is_visible_region, linear_to_db,
                     normalize_pattern, rad2deg, theta_phi_to_uv,
                     thetaphi_to_azel, uv_to_theta_phi, wavelength_to_k)
+# Vector (polarized) pattern functions
+from .vector_patterns import (GriddedElementPattern, VectorPattern,
+                              compute_co_cross_pattern_cuts,
+                              compute_full_vector_pattern,
+                              cos_q_polarized_element, crossed_dipole_element,
+                              dipole_element, dual_pol_weights,
+                              element_rotation_matrices,
+                              global_to_local_angles, ideal_patch_element,
+                              vector_array_factor_conformal,
+                              vector_total_pattern)
 # Visualization functions
 from .visualization import (  # 2D matplotlib plots; UV-space; 3D Plotly plots; Wideband
     compute_pattern_uv_space, create_pattern_animation_plotly,
@@ -278,4 +289,18 @@ __all__ = [
     "rotation_matrix_pitch",
     "rotation_matrix_yaw",
     "rotate_pattern",
+    # Vector (polarized) patterns
+    "VectorPattern",
+    "GriddedElementPattern",
+    "dipole_element",
+    "ideal_patch_element",
+    "cos_q_polarized_element",
+    "crossed_dipole_element",
+    "vector_total_pattern",
+    "compute_full_vector_pattern",
+    "compute_co_cross_pattern_cuts",
+    "dual_pol_weights",
+    "element_rotation_matrices",
+    "global_to_local_angles",
+    "vector_array_factor_conformal",
 ]

{phased_array_modeling-1.3.2 → phased_array_modeling-1.4.0}/phased_array/geometry.py

@@ -32,6 +32,13 @@ class ArrayGeometry:
         Element normal z-components
     element_indices : ndarray, optional
         Original indices before any thinning (for tracking)
+    tx : ndarray, optional
+        Element tangent x-components (local x-axis / polarization
+        reference for conformal vector patterns)
+    ty : ndarray, optional
+        Element tangent y-components
+    tz : ndarray, optional
+        Element tangent z-components
     """
     x: np.ndarray
     y: np.ndarray
@@ -40,6 +47,9 @@ class ArrayGeometry:
     ny: Optional[np.ndarray] = None
     nz: Optional[np.ndarray] = None
     element_indices: Optional[np.ndarray] = None
+    tx: Optional[np.ndarray] = None
+    ty: Optional[np.ndarray] = None
+    tz: Optional[np.ndarray] = None
 
     @property
     def n_elements(self) -> int:
@@ -74,7 +84,10 @@ class ArrayGeometry:
             nx=self.nx.copy() if self.nx is not None else None,
             ny=self.ny.copy() if self.ny is not None else None,
             nz=self.nz.copy() if self.nz is not None else None,
-            element_indices=self.element_indices.copy() if self.element_indices is not None else None
+            element_indices=self.element_indices.copy() if self.element_indices is not None else None,
+            tx=self.tx.copy() if self.tx is not None else None,
+            ty=self.ty.copy() if self.ty is not None else None,
+            tz=self.tz.copy() if self.tz is not None else None
         )
 
 
@@ -997,6 +1010,13 @@ def array_factor_conformal(
     obs_y = np.sin(theta_flat) * np.sin(phi_flat)
     obs_z = np.cos(theta_flat)
 
+    has_normals = (geometry.nx is not None and geometry.ny is not None
+                   and geometry.nz is not None)
+    if has_normals and element_pattern_func is not None:
+        from .vector_patterns import (element_rotation_matrices,
+                                      global_to_local_angles)
+        R = element_rotation_matrices(geometry)
+
     AF = np.zeros(n_angles, dtype=complex)
 
     for i in range(geometry.n_elements):
@@ -1006,7 +1026,7 @@ def array_factor_conformal(
             phase += k * geometry.z[i] * obs_z
 
         # Element pattern correction for orientation
-        if geometry.nx is not None and geometry.ny is not None and geometry.nz is not None:
+        if has_normals:
             # Cosine of angle between observation direction and element normal
             cos_angle = (geometry.nx[i] * obs_x +
                         geometry.ny[i] * obs_y +
@@ -1014,9 +1034,11 @@ def array_factor_conformal(
             cos_angle = np.maximum(cos_angle, 0)  # Only forward hemisphere
 
             if element_pattern_func is not None:
-                # Local theta for this element (angle from its normal)
-                local_theta = np.arccos(np.clip(cos_angle, -1, 1))
-                element_gain = element_pattern_func(local_theta, phi_flat, **element_kwargs)
+                # Observation angles in the element's local frame
+                local_theta, local_phi = global_to_local_angles(
+                    R[i], theta_flat, phi_flat
+                )
+                element_gain = element_pattern_func(local_theta, local_phi, **element_kwargs)
             else:
                 element_gain = cos_angle  # Simple cosine pattern
         else:

{phased_array_modeling-1.3.2 → phased_array_modeling-1.4.0}/phased_array/polarization.py

@@ -81,13 +81,13 @@ def stokes_parameters(jones: np.ndarray) -> Tuple[float, float, float, float]:
     Returns
     -------
     S0 : float or ndarray
-        Total intensity: |Ex|^2 + |Ey|^2
+        Total intensity: ``|Ex|^2 + |Ey|^2``
     S1 : float or ndarray
-        Linear horizontal-vertical: |Ex|^2 - |Ey|^2
+        Linear horizontal-vertical: ``|Ex|^2 - |Ey|^2``
     S2 : float or ndarray
-        Linear +45/-45: 2*Re(Ex*Ey*)
+        Linear +45/-45: ``2*Re(Ex*conj(Ey))``
     S3 : float or ndarray
-        Circular right-left: 2*Im(Ex*Ey*)
+        Circular right-left: ``2*Im(Ex*conj(Ey))``
 
     Examples
     --------