v0.6.1: Expand public API, update README for v0.6.0 features, add test fixtures

- Rich top-level exports in __init__.py (22 classes/functions importable directly)
- Add py.typed marker for PEP 561 type checker support
- Update README: optimization workflow, RF/digital/reliability features, new examples
- Quick start examples now use top-level imports
- Add shared test fixtures in conftest.py
- Bump development status classifier from Alpha to Beta

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: jman4162

README.md

@@ -20,6 +20,8 @@ Phased array antenna system design, optimization, and performance visualization
 - **Model-Based Workflow**: MBSE/MDAO approach from requirements through optimized designs
 - **Requirements-Driven**: Every evaluation produces pass/fail with margins and traceability
 - **Trade-Space Exploration**: DOE generation and Pareto analysis for systematic design exploration
+- **Design Optimization**: Scipy-based solvers (DE, dual annealing, L-BFGS-B) with constraint support
+- **Comprehensive Models**: Comms link budget, radar detection, RF cascade, digital beamformer, reliability
 - **Dual Application**: Supports both communications link budgets and radar detection scenarios
 - **Reproducible**: Config-driven workflow with seed control and version stamping
 
@@ -30,14 +32,20 @@ Config (YAML/JSON) → Architecture + Scenario → DOE Generation → Batch Eval
        ↓                                                              ↓
   Requirements ───────────────────────────────────────────→ Verification
                                                                    ↓
-                    Reports ← Visualization ← Pareto Extraction ←──┘
+                                                           Pareto Extraction
+                                                                   ↓
+              Reports ← Visualization ← Optimization ←────────────┘
 ```
 
 ## Features
 
 - **Requirements as first-class objects**: Every run produces pass/fail + margins with traceability
 - **Trade-space exploration**: DOE + Pareto optimization over single-point designs
+- **Design optimization**: Scipy solvers with weighted multi-objective scalarization and constraint penalties
 - **Communications & Radar**: Link budget analysis and radar detection modeling
+- **RF cascade analysis**: Friis noise figure, IIP3, SFDR, MDS for cascaded receiver chains
+- **Digital beamformer models**: ADC/DAC characterization, bandwidth budgets, scheduling
+- **TRM reliability**: MTBF, availability, graceful degradation with failed elements
 - **Flat metrics dictionary**: All models return consistent `dict[str, float]` for interchange
 - **Config-driven reproducibility**: Stable case IDs, seed control, version stamping
 - **CLI and Python API**: Use from command line or integrate into scripts
@@ -59,9 +67,8 @@ pip install phased-array-systems[plotting]
 ### 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
+from phased_array_systems import Architecture, ArrayConfig, RFChainConfig
+from phased_array_systems import CommsLinkScenario, evaluate_case
 
 # Define architecture
 arch = Architecture(
@@ -86,7 +93,7 @@ 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
+from phased_array_systems import DesignSpace, generate_doe, BatchRunner, extract_pareto
 
 # Define design space
 space = (
@@ -110,12 +117,35 @@ pareto = extract_pareto(results, [
 ])
 ```
 
+### Design Optimization
+
+```python
+from phased_array_systems import optimize_design, DesignSpace, CommsLinkScenario
+
+scenario = CommsLinkScenario(
+    freq_hz=10e9, bandwidth_hz=10e6, range_m=100e3, required_snr_db=10.0,
+)
+space = (
+    DesignSpace()
+    .add_variable("array.nx", "categorical", values=[4, 8, 16])
+    .add_variable("array.ny", "categorical", values=[4, 8, 16])
+    .add_variable("rf.tx_power_w_per_elem", "float", low=0.5, high=3.0)
+)
+
+result = optimize_design(
+    space=space, scenario=scenario,
+    objective="eirp_dbw", sense="maximize", method="de", seed=42,
+)
+print(f"Best EIRP: {result.best_metrics['eirp_dbw']:.1f} dBW")
+```
+
 ## Examples
 
 See the `examples/` directory:
 - `01_comms_single_case.py` - Single case evaluation
 - `02_comms_doe_trade.py` - Full DOE trade study workflow
 - `03_radar_detection_trade.py` - Radar detection analysis and trade study
+- `05_optimization.py` - Design optimization with constraint handling
 
 ### Tutorial Notebook
 
@@ -168,11 +198,14 @@ pasys run config.yaml
 # DOE batch study
 pasys doe config.yaml -n 100 --method lhs
 
-# Generate report
-pasys report results.parquet --format html
+# Design optimization
+pasys optimize config.yaml --objective eirp_dbw --sense maximize
 
 # Extract Pareto frontier
 pasys pareto results.parquet -x cost_usd -y eirp_dbw --plot
+
+# Generate report
+pasys report results.parquet --format html
 ```
 
 ## Documentation

pyproject.toml

@@ -23,7 +23,7 @@ keywords = [
     "optimization",
 ]
 classifiers = [
-    "Development Status :: 3 - Alpha",
+    "Development Status :: 4 - Beta",
     "Intended Audience :: Science/Research",
     "Intended Audience :: Developers",
     "License :: OSI Approved :: MIT License",

src/phased_array_systems/__about__.py

@@ -1,4 +1,4 @@
 """Version and metadata for phased-array-systems."""
 
-__version__ = "0.6.0"
+__version__ = "0.6.1"
 __author__ = "phased-array-systems contributors"

src/phased_array_systems/__init__.py

@@ -7,4 +7,82 @@
 
 from phased_array_systems.__about__ import __version__
 
-__all__ = ["__version__"]
+# Architecture configs
+from phased_array_systems.architecture import (
+    Architecture,
+    ArrayConfig,
+    CostConfig,
+    DigitalConfig,
+    ReliabilityConfig,
+    RFChainConfig,
+)
+
+# Evaluation
+from phased_array_systems.evaluate import (
+    evaluate_case,
+    evaluate_case_with_report,
+    evaluate_config,
+)
+
+# I/O
+from phased_array_systems.io import (
+    export_results,
+    load_config,
+    load_results,
+)
+
+# Requirements
+from phased_array_systems.requirements import (
+    Requirement,
+    RequirementSet,
+    VerificationReport,
+)
+
+# Scenarios
+from phased_array_systems.scenarios import (
+    CommsLinkScenario,
+    RadarDetectionScenario,
+)
+
+# Trade studies and optimization
+from phased_array_systems.trades import (
+    BatchRunner,
+    DesignSpace,
+    OptimizationResult,
+    extract_pareto,
+    generate_doe,
+    optimize_design,
+)
+
+__all__ = [
+    "__version__",
+    # Architecture
+    "Architecture",
+    "ArrayConfig",
+    "CostConfig",
+    "DigitalConfig",
+    "ReliabilityConfig",
+    "RFChainConfig",
+    # Scenarios
+    "CommsLinkScenario",
+    "RadarDetectionScenario",
+    # Requirements
+    "Requirement",
+    "RequirementSet",
+    "VerificationReport",
+    # Evaluation
+    "evaluate_case",
+    "evaluate_case_with_report",
+    "evaluate_config",
+    # Trades
+    "BatchRunner",
+    "DesignSpace",
+    "OptimizationResult",
+    "extract_pareto",
+    "generate_doe",
+    "optimize_design",
+    # I/O
+    "export_results",
+    "load_config",
+    "load_results",
+]

src/phased_array_systems/py.typed

@@ -0,0 +1,120 @@
+"""Shared test fixtures for phased-array-systems."""
+
+from pathlib import Path
+
+import pytest
+
+from phased_array_systems.architecture import (
+    Architecture,
+    ArrayConfig,
+    CostConfig,
+    RFChainConfig,
+)
+from phased_array_systems.requirements import Requirement, RequirementSet
+from phased_array_systems.scenarios import CommsLinkScenario, RadarDetectionScenario
+from phased_array_systems.trades import DesignSpace
+
+
+@pytest.fixture
+def comms_scenario():
+    """Standard 10 GHz comms scenario at 100 km range."""
+    return CommsLinkScenario(
+        freq_hz=10e9,
+        bandwidth_hz=10e6,
+        range_m=100e3,
+        required_snr_db=10.0,
+        scan_angle_deg=0.0,
+        rx_antenna_gain_db=0.0,
+        rx_noise_temp_k=290.0,
+    )
+
+
+@pytest.fixture
+def radar_scenario():
+    """Standard 10 GHz radar scenario at 50 km range."""
+    return RadarDetectionScenario(
+        freq_hz=10e9,
+        bandwidth_hz=1e6,
+        range_m=50e3,
+        target_rcs_dbsm=0.0,
+        pfa=1e-6,
+        pd_required=0.9,
+        n_pulses=10,
+        integration_type="noncoherent",
+    )
+
+
+@pytest.fixture
+def base_architecture():
+    """8x8 array with 1W/element and standard RF chain."""
+    return Architecture(
+        array=ArrayConfig(
+            nx=8,
+            ny=8,
+            dx_lambda=0.5,
+            dy_lambda=0.5,
+            enforce_subarray_constraint=False,
+        ),
+        rf=RFChainConfig(
+            tx_power_w_per_elem=1.0,
+            pa_efficiency=0.3,
+            noise_figure_db=3.0,
+            feed_loss_db=1.0,
+        ),
+        cost=CostConfig(
+            cost_per_elem_usd=100.0,
+            nre_usd=10000.0,
+        ),
+    )
+
+
+@pytest.fixture
+def basic_requirements():
+    """Simple EIRP + cost requirement set."""
+    return RequirementSet(
+        requirements=[
+            Requirement(
+                id="REQ-001",
+                name="Minimum EIRP",
+                metric_key="eirp_dbw",
+                op=">=",
+                value=30.0,
+                severity="must",
+            ),
+            Requirement(
+                id="REQ-002",
+                name="Maximum Cost",
+                metric_key="cost_usd",
+                op="<=",
+                value=50000.0,
+                severity="must",
+            ),
+        ],
+        name="Basic Requirements",
+    )
+
+
+@pytest.fixture
+def architecture_design_space():
+    """Design space for array sizing and RF parameters."""
+    return (
+        DesignSpace(name="Test Design Space")
+        .add_variable("array.nx", type="categorical", values=[4, 8, 16])
+        .add_variable("array.ny", type="categorical", values=[4, 8, 16])
+        .add_variable(
+            "array.enforce_subarray_constraint",
+            type="categorical",
+            values=[True],
+        )
+        .add_variable("array.geometry", type="categorical", values=["rectangular"])
+        .add_variable("rf.tx_power_w_per_elem", type="float", low=0.5, high=3.0)
+        .add_variable("rf.pa_efficiency", type="float", low=0.2, high=0.5)
+        .add_variable("rf.noise_figure_db", type="float", low=3.0, high=3.0)
+        .add_variable("cost.cost_per_elem_usd", type="float", low=75.0, high=150.0)
+    )
+
+
+@pytest.fixture
+def configs_dir():
+    """Path to example config files."""
+    return Path(__file__).parent.parent / "examples" / "configs"