phased-array-systems 0.1.0__py3-none-any.whl

phased_array_systems/types.py

@@ -0,0 +1,54 @@
+"""Type aliases and protocols for the phased-array-systems package."""
+
+from typing import Any, Literal, Protocol, runtime_checkable
+
+# Type aliases for metric dictionaries
+MetricsDict = dict[str, float | str | None]
+
+# Comparison operators for requirements
+ComparisonOp = Literal[">=", "<=", "==", ">", "<"]
+
+# Severity levels for requirements
+Severity = Literal["must", "should", "nice"]
+
+# Geometry types supported by phased-array-modeling
+GeometryType = Literal["rectangular", "circular", "triangular"]
+
+# Path loss model types
+PathLossModel = Literal["fspl"]
+
+# DOE sampling methods
+SamplingMethod = Literal["grid", "random", "lhs"]
+
+# Optimization directions
+OptimizeDirection = Literal["minimize", "maximize"]
+
+
+@runtime_checkable
+class Scenario(Protocol):
+    """Protocol for scenario objects (comms, radar, etc.)."""
+
+    freq_hz: float
+
+
+@runtime_checkable
+class ModelBlock(Protocol):
+    """Protocol for model blocks that evaluate architecture/scenario combinations.
+
+    All model blocks must implement evaluate() and return a flat metrics dictionary.
+    """
+
+    name: str
+
+    def evaluate(self, arch: Any, scenario: Scenario, context: dict[str, Any]) -> MetricsDict:
+        """Evaluate the model and return metrics.
+
+        Args:
+            arch: Architecture configuration object
+            scenario: Scenario configuration object
+            context: Additional context (e.g., results from other models)
+
+        Returns:
+            Dictionary of metric_name -> value pairs
+        """
+        ...

phased_array_systems/utils/__init__.py

@@ -0,0 +1,8 @@
+"""Utility functions for phased-array-systems."""
+
+from phased_array_systems.utils.hashing import compute_case_id, compute_config_hash
+
+__all__ = [
+    "compute_case_id",
+    "compute_config_hash",
+]

phased_array_systems/utils/hashing.py

@@ -0,0 +1,70 @@
+"""Hashing utilities for stable case identification."""
+
+import hashlib
+import json
+from typing import Any
+
+
+def compute_config_hash(config: dict[str, Any], length: int = 8) -> str:
+    """Compute a stable hash for a configuration dictionary.
+
+    Uses JSON serialization with sorted keys to ensure consistent
+    ordering, then SHA-256 hashing.
+
+    Args:
+        config: Configuration dictionary
+        length: Number of hex characters to return
+
+    Returns:
+        Hexadecimal hash string
+    """
+    # Serialize with sorted keys for consistency
+    json_str = json.dumps(config, sort_keys=True, default=str)
+    hash_bytes = hashlib.sha256(json_str.encode()).hexdigest()
+    return hash_bytes[:length]
+
+
+def compute_case_id(
+    case_index: int,
+    config: dict[str, Any] | None = None,
+    prefix: str = "case",
+) -> str:
+    """Compute a unique case identifier.
+
+    Args:
+        case_index: Sequential case number
+        config: Optional configuration to include in hash
+        prefix: Prefix for the case ID
+
+    Returns:
+        Case ID string like "case_00001" or "case_00001_a1b2c3d4"
+    """
+    base_id = f"{prefix}_{case_index:05d}"
+
+    if config is not None:
+        config_hash = compute_config_hash(config)
+        return f"{base_id}_{config_hash}"
+
+    return base_id
+
+
+def dict_to_hashable(d: dict[str, Any]) -> tuple:
+    """Convert a dictionary to a hashable tuple representation.
+
+    Useful for using dictionaries as dictionary keys or in sets.
+
+    Args:
+        d: Dictionary to convert
+
+    Returns:
+        Tuple of (key, value) pairs, sorted by key
+    """
+    items = []
+    for k in sorted(d.keys()):
+        v = d[k]
+        if isinstance(v, dict):
+            v = dict_to_hashable(v)
+        elif isinstance(v, list):
+            v = tuple(v)
+        items.append((k, v))
+    return tuple(items)

phased_array_systems/viz/__init__.py

@@ -0,0 +1,9 @@
+"""Visualization utilities for trade study results."""
+
+from phased_array_systems.viz.plots import pareto_plot, scatter_matrix, trade_space_plot
+
+__all__ = [
+    "pareto_plot",
+    "scatter_matrix",
+    "trade_space_plot",
+]

phased_array_systems/viz/plots.py

@@ -0,0 +1,324 @@
+"""Plotting functions for trade study visualization."""
+
+from typing import Literal
+
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+
+
+def pareto_plot(
+    results: pd.DataFrame,
+    x: str,
+    y: str,
+    pareto_front: pd.DataFrame | None = None,
+    feasible_mask: pd.Series | None = None,
+    color_by: str | None = None,
+    size_by: str | None = None,
+    ax: plt.Axes | None = None,
+    title: str | None = None,
+    x_label: str | None = None,
+    y_label: str | None = None,
+    show_pareto_line: bool = True,
+    figsize: tuple[float, float] = (8, 6),
+) -> plt.Figure:
+    """Create a Pareto plot showing trade-offs between two objectives.
+
+    Args:
+        results: DataFrame with all evaluation results
+        x: Column name for x-axis
+        y: Column name for y-axis
+        pareto_front: Optional DataFrame with Pareto-optimal points to highlight
+        feasible_mask: Optional boolean Series marking feasible designs
+        color_by: Optional column name to color points by
+        size_by: Optional column name to size points by
+        ax: Optional existing Axes to plot on
+        title: Plot title
+        x_label: X-axis label (defaults to column name)
+        y_label: Y-axis label (defaults to column name)
+        show_pareto_line: If True, draw line connecting Pareto points
+        figsize: Figure size (width, height)
+
+    Returns:
+        matplotlib Figure object
+    """
+    if ax is None:
+        fig, ax = plt.subplots(figsize=figsize)
+    else:
+        fig = ax.figure
+
+    # Determine point sizes
+    if size_by is not None and size_by in results.columns:
+        sizes = results[size_by]
+        sizes = (sizes - sizes.min()) / (sizes.max() - sizes.min() + 1e-10) * 100 + 20
+    else:
+        sizes = 50
+
+    # Determine colors
+    if color_by is not None and color_by in results.columns:
+        colors = results[color_by]
+        cmap = plt.cm.viridis
+    else:
+        colors = "steelblue"
+        cmap = None
+
+    # Plot infeasible points (if mask provided)
+    if feasible_mask is not None:
+        infeasible = results[~feasible_mask]
+        if len(infeasible) > 0:
+            ax.scatter(
+                infeasible[x],
+                infeasible[y],
+                c="lightgray",
+                s=30,
+                alpha=0.5,
+                marker="x",
+                label="Infeasible",
+            )
+
+    # Plot all feasible points
+    plot_data = results[feasible_mask] if feasible_mask is not None else results
+
+    scatter = ax.scatter(
+        plot_data[x],
+        plot_data[y],
+        c=colors if color_by is None else plot_data[color_by],
+        s=sizes if isinstance(sizes, int) else plot_data[size_by] if size_by else 50,
+        alpha=0.7,
+        cmap=cmap,
+        label="Feasible" if feasible_mask is not None else None,
+    )
+
+    # Add colorbar if coloring by a metric
+    if color_by is not None and cmap is not None:
+        cbar = plt.colorbar(scatter, ax=ax)
+        cbar.set_label(color_by)
+
+    # Highlight Pareto front
+    if pareto_front is not None and len(pareto_front) > 0:
+        ax.scatter(
+            pareto_front[x],
+            pareto_front[y],
+            facecolors="none",
+            edgecolors="red",
+            s=100,
+            linewidths=2,
+            label="Pareto Optimal",
+            zorder=5,
+        )
+
+        # Draw Pareto line
+        if show_pareto_line and len(pareto_front) > 1:
+            sorted_pareto = pareto_front.sort_values(x)
+            ax.plot(
+                sorted_pareto[x],
+                sorted_pareto[y],
+                "r--",
+                alpha=0.5,
+                linewidth=1.5,
+                zorder=4,
+            )
+
+    # Labels and title
+    ax.set_xlabel(x_label or x)
+    ax.set_ylabel(y_label or y)
+    ax.set_title(title or f"Pareto Trade-off: {x} vs {y}")
+
+    # Legend
+    handles, labels = ax.get_legend_handles_labels()
+    if handles:
+        ax.legend(loc="best")
+
+    ax.grid(True, alpha=0.3)
+    fig.tight_layout()
+
+    return fig
+
+
+def scatter_matrix(
+    results: pd.DataFrame,
+    columns: list[str],
+    color_by: str | None = None,
+    diagonal: Literal["hist", "kde"] = "hist",
+    figsize: tuple[float, float] | None = None,
+    title: str | None = None,
+) -> plt.Figure:
+    """Create a scatter matrix showing pairwise relationships.
+
+    Args:
+        results: DataFrame with evaluation results
+        columns: List of column names to include
+        color_by: Optional column name to color points by
+        diagonal: What to show on diagonal ("hist" or "kde")
+        figsize: Figure size (auto-calculated if None)
+        title: Overall figure title
+
+    Returns:
+        matplotlib Figure object
+    """
+    n = len(columns)
+    if figsize is None:
+        figsize = (n * 2.5, n * 2.5)
+
+    fig, axes = plt.subplots(n, n, figsize=figsize)
+
+    # Determine colors
+    if color_by is not None and color_by in results.columns:
+        colors = results[color_by].values
+        cmap = plt.cm.viridis
+        norm = plt.Normalize(colors.min(), colors.max())
+        point_colors = cmap(norm(colors))
+    else:
+        point_colors = "steelblue"
+
+    for i, col_i in enumerate(columns):
+        for j, col_j in enumerate(columns):
+            ax = axes[i, j]
+
+            if i == j:
+                # Diagonal: histogram or KDE
+                if diagonal == "hist":
+                    ax.hist(results[col_i], bins=20, alpha=0.7, color="steelblue")
+                else:  # kde
+                    from scipy import stats
+
+                    data = results[col_i].dropna()
+                    if len(data) > 1:
+                        kde = stats.gaussian_kde(data)
+                        x_range = np.linspace(data.min(), data.max(), 100)
+                        ax.fill_between(x_range, kde(x_range), alpha=0.5)
+                        ax.plot(x_range, kde(x_range), color="steelblue")
+            else:
+                # Off-diagonal: scatter plot
+                ax.scatter(
+                    results[col_j],
+                    results[col_i],
+                    c=point_colors,
+                    s=10,
+                    alpha=0.5,
+                )
+
+            # Labels on edges only
+            if i == n - 1:
+                ax.set_xlabel(col_j, fontsize=8)
+            else:
+                ax.set_xticklabels([])
+
+            if j == 0:
+                ax.set_ylabel(col_i, fontsize=8)
+            else:
+                ax.set_yticklabels([])
+
+            ax.tick_params(labelsize=6)
+
+    if title:
+        fig.suptitle(title, fontsize=12)
+
+    fig.tight_layout()
+    if title:
+        fig.subplots_adjust(top=0.95)
+
+    return fig
+
+
+def trade_space_plot(
+    results: pd.DataFrame,
+    x: str,
+    y: str,
+    z: str,
+    feasible_mask: pd.Series | None = None,
+    pareto_front: pd.DataFrame | None = None,
+    ax: plt.Axes | None = None,
+    figsize: tuple[float, float] = (10, 8),
+    title: str | None = None,
+) -> plt.Figure:
+    """Create a 3D trade space visualization.
+
+    Args:
+        results: DataFrame with evaluation results
+        x: Column name for x-axis
+        y: Column name for y-axis
+        z: Column name for z-axis (color)
+        feasible_mask: Optional boolean mask for feasible designs
+        pareto_front: Optional DataFrame with Pareto-optimal points
+        ax: Optional existing 3D Axes
+        figsize: Figure size
+        title: Plot title
+
+    Returns:
+        matplotlib Figure object
+    """
+    if ax is None:
+        fig = plt.figure(figsize=figsize)
+        ax = fig.add_subplot(111, projection="3d")
+    else:
+        fig = ax.figure
+
+    # Plot points
+    if feasible_mask is not None:
+        # Infeasible
+        inf_data = results[~feasible_mask]
+        ax.scatter(
+            inf_data[x],
+            inf_data[y],
+            inf_data[z],
+            c="lightgray",
+            alpha=0.3,
+            s=20,
+            marker="x",
+        )
+        plot_data = results[feasible_mask]
+    else:
+        plot_data = results
+
+    scatter = ax.scatter(
+        plot_data[x],
+        plot_data[y],
+        plot_data[z],
+        c=plot_data[z],
+        cmap="viridis",
+        alpha=0.7,
+        s=40,
+    )
+
+    # Highlight Pareto front
+    if pareto_front is not None and len(pareto_front) > 0:
+        ax.scatter(
+            pareto_front[x],
+            pareto_front[y],
+            pareto_front[z],
+            c="red",
+            s=100,
+            marker="*",
+            label="Pareto Optimal",
+            zorder=5,
+        )
+        ax.legend()
+
+    ax.set_xlabel(x)
+    ax.set_ylabel(y)
+    ax.set_zlabel(z)
+
+    fig.colorbar(scatter, ax=ax, label=z, shrink=0.5)
+
+    if title:
+        ax.set_title(title)
+
+    return fig
+
+
+def save_figure(
+    fig: plt.Figure,
+    path: str,
+    dpi: int = 150,
+    transparent: bool = False,
+) -> None:
+    """Save a figure to file.
+
+    Args:
+        fig: matplotlib Figure to save
+        path: Output path (extension determines format)
+        dpi: Resolution for raster formats
+        transparent: Whether to use transparent background
+    """
+    fig.savefig(path, dpi=dpi, transparent=transparent, bbox_inches="tight")

phased_array_systems-0.1.0.dist-info/METADATA

@@ -0,0 +1,174 @@
+Metadata-Version: 2.4
+Name: phased-array-systems
+Version: 0.1.0
+Summary: Phased array antenna system design, optimization, and performance visualization
+Project-URL: Homepage, https://github.com/jman4162/phased-array-systems
+Project-URL: Documentation, https://github.com/jman4162/phased-array-systems#readme
+Project-URL: Repository, https://github.com/jman4162/phased-array-systems
+Project-URL: Issues, https://github.com/jman4162/phased-array-systems/issues
+Author: phased-array-systems contributors
+License-Expression: MIT
+License-File: LICENSE
+Keywords: RF,antenna,communications,optimization,phased array,radar,system design,trade study
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+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.10
+Requires-Dist: matplotlib>=3.7.0
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: phased-array-modeling>=1.2.0
+Requires-Dist: pydantic>=2.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: scipy>=1.10.0
+Provides-Extra: dev
+Requires-Dist: mypy>=1.0; extra == 'dev'
+Requires-Dist: pandas-stubs>=2.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Provides-Extra: plotting
+Requires-Dist: kaleido>=0.2; extra == 'plotting'
+Requires-Dist: plotly>=5.0; extra == 'plotting'
+Description-Content-Type: text/markdown
+
+# phased-array-systems
+
+[![CI](https://github.com/jman4162/phased-array-systems/actions/workflows/ci.yml/badge.svg)](https://github.com/jman4162/phased-array-systems/actions/workflows/ci.yml)
+[![PyPI version](https://badge.fury.io/py/phased-array-systems.svg)](https://badge.fury.io/py/phased-array-systems)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Phased array antenna system design, optimization, and performance visualization for wireless communications and radar applications.
+
+## Features
+
+- **Requirements as first-class objects**: Every run produces pass/fail + margins with traceability
+- **Trade-space exploration**: DOE + Pareto optimization over single-point designs
+- **Flat metrics dictionary**: All models return consistent `dict[str, float]` for interchange
+- **Config-driven reproducibility**: Stable case IDs, seed control, version stamping
+
+## Installation
+
+```bash
+pip install phased-array-systems
+
+# Development dependencies
+pip install phased-array-systems[dev]
+
+# Visualization extras
+pip install phased-array-systems[plotting]
+```
+
+## Quick Start
+
+### Single Case Evaluation
+
+```python
+from phased_array_systems.architecture import Architecture, ArrayConfig, RFChainConfig
+from phased_array_systems.scenarios import CommsLinkScenario
+from phased_array_systems.evaluate import evaluate_case
+
+# Define architecture
+arch = Architecture(
+    array=ArrayConfig(nx=8, ny=8, dx_lambda=0.5, dy_lambda=0.5),
+    rf=RFChainConfig(tx_power_w_per_elem=1.0, pa_efficiency=0.3),
+)
+
+# Define scenario
+scenario = CommsLinkScenario(
+    freq_hz=10e9,
+    bandwidth_hz=10e6,
+    range_m=100e3,
+    required_snr_db=10.0,
+)
+
+# Evaluate
+metrics = evaluate_case(arch, scenario)
+print(f"EIRP: {metrics['eirp_dbw']:.1f} dBW")
+print(f"Link Margin: {metrics['link_margin_db']:.1f} dB")
+```
+
+### DOE Trade Study
+
+```python
+from phased_array_systems.trades import DesignSpace, generate_doe, BatchRunner, extract_pareto
+
+# Define design space
+space = (
+    DesignSpace()
+    .add_variable("array.nx", "int", low=4, high=16)
+    .add_variable("array.ny", "int", low=4, high=16)
+    .add_variable("rf.tx_power_w_per_elem", "float", low=0.5, high=3.0)
+)
+
+# Generate DOE
+doe = generate_doe(space, method="lhs", n_samples=100, seed=42)
+
+# Run batch evaluation
+runner = BatchRunner(scenario)
+results = runner.run(doe)
+
+# Extract Pareto frontier
+pareto = extract_pareto(results, [
+    ("cost_usd", "minimize"),
+    ("eirp_dbw", "maximize"),
+])
+```
+
+## Examples
+
+See the `examples/` directory:
+- `01_comms_single_case.py` - Single case evaluation
+- `02_comms_doe_trade.py` - Full DOE trade study workflow
+
+### Tutorial Notebook
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/jman4162/phased-array-systems/blob/main/notebooks/tutorial_phased_array_trade_study.ipynb)
+
+Try the interactive tutorial in Google Colab!
+
+## Package Structure
+
+```
+phased_array_systems/
+├── architecture/     # Array, RF chain, cost configurations
+├── scenarios/        # CommsLinkScenario, RadarDetectionScenario
+├── requirements/     # Requirement definitions and verification
+├── models/
+│   ├── antenna/      # Phased array adapter and metrics
+│   ├── comms/        # Link budget, propagation models
+│   └── swapc/        # Power and cost models
+├── trades/           # DOE, batch runner, Pareto analysis
+├── viz/              # Plotting utilities
+└── io/               # Config loading, results export
+```
+
+## Development
+
+```bash
+# Clone the repository
+git clone https://github.com/jman4162/phased-array-systems.git
+cd phased-array-systems
+
+# Install in development mode
+pip install -e ".[dev]"
+
+# Run tests
+pytest tests/ -v
+
+# Run linting
+ruff check .
+```
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.

phased_array_systems-0.1.0.dist-info/RECORD

@@ -0,0 +1,43 @@
+phased_array_systems/__about__.py,sha256=Qe_T9JvLe3C-9zBcXDIoQjsjy25E-ox3VlYm2AK2GTg,125
+phased_array_systems/__init__.py,sha256=47SV42pztafqI3b0kVwjfQxdp8eKoEuda69PD9oXgVM,362
+phased_array_systems/cli.py,sha256=x_D3sGeOeo9RpDLkOBTX8bhfpmATieUAgii_uS8MISw,642
+phased_array_systems/constants.py,sha256=-WjHG4CJXmckxJsG2ymVGrqbTtWFKvAdARe3S03Ybjw,1310
+phased_array_systems/evaluate.py,sha256=EgQXtM9zztAr9QHM6wcschA055eH6rY3i9xft10s-7c,4825
+phased_array_systems/types.py,sha256=_K-9wvl2UO5jzjZgvHWw3MC-Aiz2WDfdgLV6IT6llK0,1521
+phased_array_systems/architecture/__init__.py,sha256=ksS18SuMWiWxO4ov8fx13LYV4sn2-R9c67IrTyfpLoM,265
+phased_array_systems/architecture/config.py,sha256=oc8bOKrGuJsUp5ZKLVCIE2KZQ3-P70q26naVy2J1u5s,5274
+phased_array_systems/io/__init__.py,sha256=j8h7-fYUKTiFknqHTxdUIJJQaaXHmyKf76f_pyH4fZQ,387
+phased_array_systems/io/config_loader.py,sha256=eEeEO5nqUewXrjs5ZlQDCeo_E5eIVjCQer0C4Pvpot0,2470
+phased_array_systems/io/exporters.py,sha256=m6f4ZhT6cQaJLE3v1zMVbatKQRlOUViaAnYzAZTE3rY,4441
+phased_array_systems/io/schema.py,sha256=43_O9U_w8ALjAYL64XajHV_zwq-TeRqP7zL8WFveYaI,4858
+phased_array_systems/models/__init__.py,sha256=kjl_doYE2uyGRnjxrJzC0Pp_UcdjZY_GeY9GHWh9iOs,123
+phased_array_systems/models/base.py,sha256=AP6C70tU8jXKxMCiuvB4oy5Vw2KFX_CTfK5oiYjrGo0,937
+phased_array_systems/models/antenna/__init__.py,sha256=N1SEfVY1IuT0kEuq5H-1wk4hZwWRJeVp1TKnJlgy4Uk,394
+phased_array_systems/models/antenna/adapter.py,sha256=jkoGnQ0d5DMASK9iRodosaGa6gM-bF3syhJKSFyTynQ,6670
+phased_array_systems/models/antenna/metrics.py,sha256=cw2DCZ_vGpT9vNcurdSSxVB9zV9524fNM5nxrsWiwro,4875
+phased_array_systems/models/comms/__init__.py,sha256=7aPkt-zKpe6yECynehGwAoP14I62n-M5w1lkMGgaiRM,243
+phased_array_systems/models/comms/link_budget.py,sha256=dGKO7VA5C8RI5lffzqDs6H7l7fujfNe5HM5mgeTUfHc,6017
+phased_array_systems/models/comms/propagation.py,sha256=mXsmgCAZ3h3FZIk0L9NykQga_fCHXVXBFSm2oRq_Xks,2364
+phased_array_systems/models/swapc/__init__.py,sha256=0UCAWinqnMVW6c_num8qYTVHF3EYsJHGoOh44xKjd-I,228
+phased_array_systems/models/swapc/cost.py,sha256=5c_vHDZXjmANoBbB2sTYotzNPgirIoGFKSBlfsqbPtA,2898
+phased_array_systems/models/swapc/power.py,sha256=f7ECkfnM8MvlW4po-TboeWU6kyqrcmix_2IWTJsK7LY,3187
+phased_array_systems/requirements/__init__.py,sha256=4eNoTS1ySN0toEYLAo1ttpe3u6Bu8YXFOUP0k4GTwUc,302
+phased_array_systems/requirements/core.py,sha256=E3Bp474UXLyMhYLrlmERa0jaP3hl8iskgCvAJmVhJ70,8095
+phased_array_systems/scenarios/__init__.py,sha256=4LAbI_zz3oQt36-WSxkHFSV1rRtTy13aG1s8YgodTvc,361
+phased_array_systems/scenarios/base.py,sha256=Mlq-hMob1an4TviLQfFekRsQfCyOsNFJwCavKjrDaxs,818
+phased_array_systems/scenarios/comms.py,sha256=d-IubHyWZC5iFZLUJdkwoDkMWAnptQn0bvkvN1KDBj4,2216
+phased_array_systems/scenarios/radar.py,sha256=1DHMT8Mjrtg_hLUWuvh0iHQJomJT1Ct4Az9EWa_jF5I,1576
+phased_array_systems/trades/__init__.py,sha256=3YIx1FvSwJWq9ai7zpFA7Ss2AiwcUJMAbZxuOCqxhjY,514
+phased_array_systems/trades/design_space.py,sha256=mVH5FcBTjQmhr5IqucLlcCaLIZYcqvSKElowY8YvARw,8524
+phased_array_systems/trades/doe.py,sha256=bEj946EcC8NqP0QQ6zxAw0rqEhAIMmDd3M3biNCm9Ow,4836
+phased_array_systems/trades/pareto.py,sha256=4kyXP30SlEACbWyXk1mVBccGsG6mFXcQfPjYigsrxZk,8588
+phased_array_systems/trades/runner.py,sha256=_4Wac8QS7alZAjijz5kIaWiRY54zGvXIVqP0av4gfAo,8225
+phased_array_systems/utils/__init__.py,sha256=gGnUsnK_3Yv_7mG86dNIlV0PdQzR8lYuCvBab7P-hlE,200
+phased_array_systems/utils/hashing.py,sha256=vNuMvM9Mh_qtvfIpiGvyKor2FjWMVAeGqNWjrCpjysI,1836
+phased_array_systems/viz/__init__.py,sha256=ofsSeB8GVu_YbpSNJiu8UdoIxfO2GeIbChIp8hhRBhc,225
+phased_array_systems/viz/plots.py,sha256=bAcBVMlLCv7Mj5bT8m6k6mGQmEhqsLGB-R6X8qs-U84,9128
+phased_array_systems-0.1.0.dist-info/METADATA,sha256=z2RgzLRfESqAN8CZGIUWqLHmI-8t0DCiPxnhYVO9-9c,5826
+phased_array_systems-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+phased_array_systems-0.1.0.dist-info/entry_points.txt,sha256=C5I-JkVj-j99qHvWW3PoXWjnzam62a0N5W4haHHxXxM,56
+phased_array_systems-0.1.0.dist-info/licenses/LICENSE,sha256=tTGISmKHj6ZUsuU7scIo5pEognjuz4a7IB3maC4DfBw,1067
+phased_array_systems-0.1.0.dist-info/RECORD,,

phased_array_systems-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

phased_array_systems-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pasys = phased_array_systems.cli:main