sysml2kit-rf-library 0.1.0__py3-none-any.whl

sysml2kit_rf_library/__init__.py

@@ -0,0 +1,40 @@
+"""SysML v2 model library for antenna/RF systems engineering.
+
+Ships the RFVocabulary/RFParts/RFRequirements/RFAnalyses packages plus a
+worked 28 GHz satcom-terminal example, as committed interchange JSON loadable
+through sysml2kit. ``_build.py`` is the authoritative source; the files under
+``models/`` are generated from it.
+"""
+
+from importlib.metadata import PackageNotFoundError, version
+from pathlib import Path
+
+from sysml2kit.model import Model
+
+try:
+    __version__ = version("sysml2kit-rf-library")
+except PackageNotFoundError:  # running from a source tree without an install
+    __version__ = "0.0.0.dev0"
+
+#: Available model names -> interchange file stem.
+MODELS = {
+    "rf-library": "rf_library",
+    "satcom-terminal-t3001": "satcom_terminal_t3001",
+}
+
+
+def models_dir() -> Path:
+    """Return the directory holding the packaged model files."""
+    return Path(__file__).parent / "models"
+
+
+def load_model(name: str = "rf-library") -> Model:
+    """Load a packaged model by name (see ``MODELS``)."""
+    from sysml2kit.interchange import model_from_json
+
+    if name not in MODELS:
+        raise KeyError(f"unknown model {name!r}; available: {sorted(MODELS)}")
+    return model_from_json(models_dir() / "interchange" / f"{MODELS[name]}.json")
+
+
+__all__ = ["MODELS", "__version__", "load_model", "models_dir"]

sysml2kit_rf_library/_build.py

@@ -0,0 +1,358 @@
+"""Authoritative construction of the RF model library.
+
+This module is the source of truth. The committed ``.sysml`` files and
+interchange JSON under ``models/`` are generated from it by
+``scripts/regenerate.py`` (CI checks they are in sync). Building with the
+sysml2kit builder keeps full fidelity — attribute values, units, and
+relationship kinds — which a text parse cannot yet guarantee.
+
+The example terminal mirrors the aedl ``t3-001`` benchmark: a 28 GHz LEO
+uplink phased-array ground terminal with its published requirement set.
+"""
+
+from __future__ import annotations
+
+from sysml2kit.model import Element, Model, builder
+
+
+def build_vocabulary(model: Model) -> Element:
+    """RFVocabulary: attribute definitions with canonical units."""
+    pkg = builder.pkg(
+        model,
+        "RFVocabulary",
+        doc="Quantity kinds for antenna/RF systems engineering, with canonical units.",
+    )
+    quantities = [
+        ("Frequency_GHz", "GHz", "Carrier or design frequency."),
+        ("Bandwidth_MHz", "MHz", "Occupied or instantaneous bandwidth."),
+        ("Gain_dBi", "dBi", "Antenna gain relative to isotropic."),
+        ("EIRP_dBW", "dBW", "Effective isotropic radiated power."),
+        ("GOverT_dBK", "dBK", "Receive figure of merit G/T."),
+        ("SidelobeLevel_dB", "dB", "Peak sidelobe level relative to the main beam."),
+        ("ScanLoss_dB", "dB", "Gain loss at the scan angle relative to broadside."),
+        ("LinkMargin_dB", "dB", "Margin above the required SNR."),
+        ("NoiseFigure_dB", "dB", "Cascaded receive noise figure."),
+        ("AxialRatio_dB", "dB", "Polarization axial ratio."),
+        ("ScanAngle_deg", "deg", "Beam scan angle off broadside."),
+        ("PrimePower_W", "W", "Prime (DC input) power draw."),
+        ("UnitCost_USD", None, "Recurring unit cost in US dollars."),
+    ]
+    for name, unit, doc in quantities:
+        builder.attr_def(model, name, owner=pkg, unit=unit, doc=doc)
+    return pkg
+
+
+def build_parts(model: Model) -> Element:
+    """RFParts: part and port definitions for phased-array terminals."""
+    pkg = builder.pkg(
+        model,
+        "RFParts",
+        doc="Part and port definitions for phased-array antenna systems.",
+    )
+    builder.port_def(model, "RFPort", owner=pkg, doc="Guided-wave RF interface.")
+    builder.port_def(model, "BeamPort", owner=pkg, doc="Formed-beam signal interface.")
+    builder.port_def(model, "CtrlPort", owner=pkg, doc="Command and telemetry interface.")
+    parts = [
+        ("AntennaElement", "A single radiating element."),
+        ("RadiatingAperture", "The element lattice as one aperture."),
+        ("TRModule", "Transmit/receive module: PA, LNA, phase shifter, switch."),
+        ("Beamformer", "Analog, digital, or hybrid beamforming network."),
+        ("PhasedArrayAntenna", "Aperture, T/R modules, and beamformer as one antenna."),
+        ("RFFrontEnd", "Up/down conversion and filtering between antenna and modem."),
+        ("Modem", "Waveform modulation and demodulation."),
+        ("SatcomTerminal", "A complete ground terminal."),
+    ]
+    for name, doc in parts:
+        builder.part_def(model, name, owner=pkg, doc=doc)
+    return pkg
+
+
+def build_requirement_defs(model: Model) -> Element:
+    """RFRequirements: requirement definitions carrying the metricKey convention.
+
+    Each definition documents which ``metricKey`` its usages set, so
+    ``sysml2kit.interop.extract_requirements`` can hand them to a requirements
+    engine (phased-array-systems, aedl) without RF knowledge in the kit.
+    """
+    pkg = builder.pkg(
+        model,
+        "RFRequirements",
+        doc=(
+            "Requirement definitions for RF terminals. Usages own attributes "
+            "metricKey (str), threshold (number with unit), op (>=, <=, ==), and "
+            "optionally severity (must/should/nice); sysml2kit.interop reads them."
+        ),
+    )
+    defs = [
+        ("EirpRequirement", "Minimum effective isotropic radiated power."),
+        ("GOverTRequirement", "Minimum receive figure of merit."),
+        ("SidelobeRequirement", "Maximum pattern sidelobe level."),
+        ("ScanLossRequirement", "Maximum gain loss at the scan-angle extreme."),
+        ("LinkMarginRequirement", "Minimum worst-case link margin."),
+        ("BandwidthRequirement", "Minimum instantaneous bandwidth."),
+        ("PowerCeilingRequirement", "Maximum prime-power draw."),
+        ("CostCeilingRequirement", "Maximum recurring unit cost."),
+        ("CrosscheckRequirement", "Maximum disagreement between independent analyses."),
+        ("GratingLobeRequirement", "Minimum grating-lobe margin in wavelengths."),
+    ]
+    for name, doc in defs:
+        builder.req_def(model, name, owner=pkg, doc=doc)
+    return pkg
+
+
+def build_analyses(model: Model) -> Element:
+    """RFAnalyses: analysis case definitions that verification links point at."""
+    pkg = builder.pkg(
+        model,
+        "RFAnalyses",
+        doc="Analysis case definitions; bindings to physics engines live downstream.",
+    )
+    cases = [
+        ("LinkBudgetAnalysis", "Worst-case link closure over an evaluation envelope."),
+        ("ArrayPatternAnalysis", "Full pattern integration: gain, sidelobes, grating lobes."),
+        ("ScanPerformanceAnalysis", "Gain and pattern degradation across the scan envelope."),
+        ("SwapCostAnalysis", "Prime power and recurring cost rollup."),
+    ]
+    for name, doc in cases:
+        builder.analysis_def(model, name, owner=pkg, doc=doc)
+    return pkg
+
+
+def build_library() -> Model:
+    """Build the four library packages in one model."""
+    model = Model()
+    build_vocabulary(model)
+    build_parts(model)
+    build_requirement_defs(model)
+    build_analyses(model)
+    return model
+
+
+def _metric_requirement(
+    model: Model,
+    owner: Element,
+    short: str,
+    name: str,
+    *,
+    definition: Element,
+    text: str,
+    metric_key: str,
+    op: str,
+    threshold: float,
+    unit: str | None,
+    severity: str = "must",
+) -> Element:
+    req = builder.req(model, short, name, owner=owner, text=text, definition=definition)
+    builder.attr(model, "metricKey", metric_key, owner=req)
+    builder.attr(model, "threshold", threshold, owner=req, unit=unit)
+    builder.attr(model, "op", op, owner=req)
+    builder.attr(model, "severity", severity, owner=req)
+    return req
+
+
+def _defs(model: Model) -> dict[str, Element]:
+    return {el.declared_name: el for el in model.iter_elements() if el.declared_name}
+
+
+def _add_example(model: Model) -> Model:
+    defs = _defs(model)
+    pkg = builder.pkg(
+        model,
+        "SatcomTerminal28GHz",
+        doc=(
+            "28 GHz LEO uplink phased-array ground terminal, mirroring the aedl "
+            "t3-001 benchmark: close the worst-case link over the evaluation "
+            "envelope inside a 450 W prime-power and 45 kUSD unit-cost ceiling."
+        ),
+    )
+    pkg.imports = ["RFVocabulary::*", "RFParts::*", "RFRequirements::*", "RFAnalyses::*"]
+
+    terminal = builder.part(model, "terminal", owner=pkg, definition=defs["SatcomTerminal"])
+    array = builder.part(model, "array", owner=terminal, definition=defs["PhasedArrayAntenna"])
+    builder.attr(model, "frequency", 28.0, owner=array, unit="GHz", source="t3-001 brief")
+    builder.attr(model, "bandwidth", 50.0, owner=array, unit="MHz", source="t3-001 brief")
+    builder.attr(model, "maxScanAngle", 60.0, owner=array, unit="deg", source="t3-001 envelope")
+    builder.part(
+        model,
+        "elements",
+        owner=array,
+        definition=defs["AntennaElement"],
+        multiplicity="[1..*]",
+    )
+    builder.part(
+        model, "trModules", owner=array, definition=defs["TRModule"], multiplicity="[1..*]"
+    )
+    beamformer = builder.part(model, "beamformer", owner=array, definition=defs["Beamformer"])
+    front_end = builder.part(model, "frontEnd", owner=terminal, definition=defs["RFFrontEnd"])
+    builder.part(model, "modem", owner=terminal, definition=defs["Modem"])
+    beam_out = builder.port(model, "beamOut", owner=beamformer, definition=defs["BeamPort"])
+    fe_in = builder.port(model, "beamIn", owner=front_end, definition=defs["BeamPort"])
+    builder.connect(model, beam_out, fe_in, owner=terminal, name="beamFeed")
+
+    reqs = [
+        (
+            "REQ-LINK-MARGIN",
+            "WorstCaseLinkMargin",
+            defs["LinkMarginRequirement"],
+            "The link shall close (margin >= 0 dB) worst-case over the evaluation envelope.",
+            "worst_case_link_margin_db",
+            ">=",
+            0.0,
+            "dB",
+            "must",
+        ),
+        (
+            "REQ-SLL",
+            "PatternSidelobes",
+            defs["SidelobeRequirement"],
+            "Worst-case pattern sidelobe level shall not exceed -16 dB.",
+            "worst_case_pattern_sll_db",
+            "<=",
+            -16.0,
+            "dB",
+            "must",
+        ),
+        (
+            "REQ-INDEP-LINK",
+            "IndependentLinkClosure",
+            defs["LinkMarginRequirement"],
+            "The link shall also close under the independent opensatcom recomputation.",
+            "opensatcom_worst_case_margin_db",
+            ">=",
+            0.0,
+            "dB",
+            "must",
+        ),
+        (
+            "REQ-CLEARSKY-AGREE",
+            "ClearSkyAgreement",
+            defs["CrosscheckRequirement"],
+            "Clear-sky margins from the two link analyses shall agree within 1.2 dB.",
+            "crosscheck_clearsky_margin_disagreement_db",
+            "<=",
+            1.2,
+            "dB",
+            "should",
+        ),
+        (
+            "REQ-GAIN-XCHECK",
+            "GainCrosscheck",
+            defs["CrosscheckRequirement"],
+            "Claimed and integrated gain shall agree within 0.5 dB.",
+            "crosscheck_gain_disagreement_db",
+            "<=",
+            0.5,
+            "dB",
+            "should",
+        ),
+        (
+            "REQ-POWER",
+            "PrimePowerCeiling",
+            defs["PowerCeilingRequirement"],
+            "Prime power draw shall not exceed 450 W.",
+            "prime_power_w",
+            "<=",
+            450.0,
+            "W",
+            "must",
+        ),
+        (
+            "REQ-COST",
+            "UnitCostCeiling",
+            defs["CostCeilingRequirement"],
+            "Recurring unit cost shall not exceed 45,000 USD from the parts table.",
+            "unit_cost_usd",
+            "<=",
+            45000.0,
+            None,
+            "must",
+        ),
+        (
+            "REQ-GRATING",
+            "GratingLobeMargin",
+            defs["GratingLobeRequirement"],
+            "The lattice shall keep grating lobes out of visible space over the scan envelope.",
+            "grating_margin_lambda",
+            ">=",
+            0.0,
+            None,
+            "must",
+        ),
+    ]
+    req_elements = {}
+    for short, name, definition, text, key, op, threshold, unit, severity in reqs:
+        req_elements[short] = _metric_requirement(
+            model,
+            pkg,
+            short,
+            name,
+            definition=definition,
+            text=text,
+            metric_key=key,
+            op=op,
+            threshold=threshold,
+            unit=unit,
+            severity=severity,
+        )
+
+    link_budget = builder.analysis(
+        model,
+        "linkBudget",
+        owner=pkg,
+        definition=defs["LinkBudgetAnalysis"],
+        subject=terminal,
+        objective="Close the uplink worst-case over the t3-001 evaluation envelope.",
+    )
+    pattern = builder.analysis(
+        model,
+        "patternAnalysis",
+        owner=pkg,
+        definition=defs["ArrayPatternAnalysis"],
+        subject=array,
+        objective="Integrate the full pattern; recompute gain, sidelobes, grating margin.",
+    )
+    swap = builder.analysis(
+        model,
+        "swapCost",
+        owner=pkg,
+        definition=defs["SwapCostAnalysis"],
+        subject=terminal,
+        objective="Roll up prime power and unit cost from the parts table.",
+    )
+
+    for short, satisfier in [
+        ("REQ-LINK-MARGIN", terminal),
+        ("REQ-INDEP-LINK", terminal),
+        ("REQ-SLL", array),
+        ("REQ-GRATING", array),
+        ("REQ-POWER", terminal),
+        ("REQ-COST", terminal),
+    ]:
+        builder.satisfy(model, source=satisfier, target=req_elements[short], owner=pkg)
+
+    for short, part in [
+        ("REQ-SLL", array),
+        ("REQ-GRATING", array),
+        ("REQ-POWER", terminal),
+    ]:
+        builder.allocate(model, source=req_elements[short], target=part, owner=pkg)
+
+    for short, analysis_usage in [
+        ("REQ-LINK-MARGIN", link_budget),
+        ("REQ-INDEP-LINK", link_budget),
+        ("REQ-CLEARSKY-AGREE", link_budget),
+        ("REQ-SLL", pattern),
+        ("REQ-GAIN-XCHECK", pattern),
+        ("REQ-GRATING", pattern),
+        ("REQ-POWER", swap),
+        ("REQ-COST", swap),
+    ]:
+        builder.verify(model, source=analysis_usage, target=req_elements[short], owner=pkg)
+
+    return model
+
+
+def build_example() -> Model:
+    """Build the library plus the SatcomTerminal28GHz example package."""
+    model = build_library()
+    return _add_example(model)

sysml2kit_rf_library/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.1.0'
+__version_tuple__ = version_tuple = (0, 1, 0)
+
+__commit_id__ = commit_id = None

sysml2kit_rf_library/models/RFAnalyses.sysml

@@ -0,0 +1,15 @@
+package RFAnalyses {
+    doc /* Analysis case definitions; bindings to physics engines live downstream. */
+    analysis def LinkBudgetAnalysis {
+        doc /* Worst-case link closure over an evaluation envelope. */
+    }
+    analysis def ArrayPatternAnalysis {
+        doc /* Full pattern integration: gain, sidelobes, grating lobes. */
+    }
+    analysis def ScanPerformanceAnalysis {
+        doc /* Gain and pattern degradation across the scan envelope. */
+    }
+    analysis def SwapCostAnalysis {
+        doc /* Prime power and recurring cost rollup. */
+    }
+}

sysml2kit_rf_library/models/RFParts.sysml

@@ -0,0 +1,36 @@
+package RFParts {
+    doc /* Part and port definitions for phased-array antenna systems. */
+    port def RFPort {
+        doc /* Guided-wave RF interface. */
+    }
+    port def BeamPort {
+        doc /* Formed-beam signal interface. */
+    }
+    port def CtrlPort {
+        doc /* Command and telemetry interface. */
+    }
+    part def AntennaElement {
+        doc /* A single radiating element. */
+    }
+    part def RadiatingAperture {
+        doc /* The element lattice as one aperture. */
+    }
+    part def TRModule {
+        doc /* Transmit/receive module: PA, LNA, phase shifter, switch. */
+    }
+    part def Beamformer {
+        doc /* Analog, digital, or hybrid beamforming network. */
+    }
+    part def PhasedArrayAntenna {
+        doc /* Aperture, T/R modules, and beamformer as one antenna. */
+    }
+    part def RFFrontEnd {
+        doc /* Up/down conversion and filtering between antenna and modem. */
+    }
+    part def Modem {
+        doc /* Waveform modulation and demodulation. */
+    }
+    part def SatcomTerminal {
+        doc /* A complete ground terminal. */
+    }
+}

sysml2kit_rf_library/models/RFRequirements.sysml

@@ -0,0 +1,33 @@
+package RFRequirements {
+    doc /* Requirement definitions for RF terminals. Usages own attributes metricKey (str), threshold (number with unit), op (>=, <=, ==), and optionally severity (must/should/nice); sysml2kit.interop reads them. */
+    requirement def EirpRequirement {
+        doc /* Minimum effective isotropic radiated power. */
+    }
+    requirement def GOverTRequirement {
+        doc /* Minimum receive figure of merit. */
+    }
+    requirement def SidelobeRequirement {
+        doc /* Maximum pattern sidelobe level. */
+    }
+    requirement def ScanLossRequirement {
+        doc /* Maximum gain loss at the scan-angle extreme. */
+    }
+    requirement def LinkMarginRequirement {
+        doc /* Minimum worst-case link margin. */
+    }
+    requirement def BandwidthRequirement {
+        doc /* Minimum instantaneous bandwidth. */
+    }
+    requirement def PowerCeilingRequirement {
+        doc /* Maximum prime-power draw. */
+    }
+    requirement def CostCeilingRequirement {
+        doc /* Maximum recurring unit cost. */
+    }
+    requirement def CrosscheckRequirement {
+        doc /* Maximum disagreement between independent analyses. */
+    }
+    requirement def GratingLobeRequirement {
+        doc /* Minimum grating-lobe margin in wavelengths. */
+    }
+}

sysml2kit_rf_library/models/RFVocabulary.sysml

@@ -0,0 +1,42 @@
+package RFVocabulary {
+    doc /* Quantity kinds for antenna/RF systems engineering, with canonical units. */
+    attribute def Frequency_GHz {
+        doc /* Carrier or design frequency. */
+    }
+    attribute def Bandwidth_MHz {
+        doc /* Occupied or instantaneous bandwidth. */
+    }
+    attribute def Gain_dBi {
+        doc /* Antenna gain relative to isotropic. */
+    }
+    attribute def EIRP_dBW {
+        doc /* Effective isotropic radiated power. */
+    }
+    attribute def GOverT_dBK {
+        doc /* Receive figure of merit G/T. */
+    }
+    attribute def SidelobeLevel_dB {
+        doc /* Peak sidelobe level relative to the main beam. */
+    }
+    attribute def ScanLoss_dB {
+        doc /* Gain loss at the scan angle relative to broadside. */
+    }
+    attribute def LinkMargin_dB {
+        doc /* Margin above the required SNR. */
+    }
+    attribute def NoiseFigure_dB {
+        doc /* Cascaded receive noise figure. */
+    }
+    attribute def AxialRatio_dB {
+        doc /* Polarization axial ratio. */
+    }
+    attribute def ScanAngle_deg {
+        doc /* Beam scan angle off broadside. */
+    }
+    attribute def PrimePower_W {
+        doc /* Prime (DC input) power draw. */
+    }
+    attribute def UnitCost_USD {
+        doc /* Recurring unit cost in US dollars. */
+    }
+}

sysml2kit_rf_library/models/SatcomTerminal28GHz.sysml

@@ -0,0 +1,109 @@
+package SatcomTerminal28GHz {
+    public import RFVocabulary::*;
+    public import RFParts::*;
+    public import RFRequirements::*;
+    public import RFAnalyses::*;
+    doc /* 28 GHz LEO uplink phased-array ground terminal, mirroring the aedl t3-001 benchmark: close the worst-case link over the evaluation envelope inside a 450 W prime-power and 45 kUSD unit-cost ceiling. */
+    part terminal : SatcomTerminal {
+        part array : PhasedArrayAntenna {
+            attribute frequency = 28.0 [GHz];
+            attribute bandwidth = 50.0 [MHz];
+            attribute maxScanAngle = 60.0 [deg];
+            part elements : AntennaElement [1..*];
+            part trModules : TRModule [1..*];
+            part beamformer : Beamformer {
+                port beamOut : BeamPort;
+            }
+        }
+        part frontEnd : RFFrontEnd {
+            port beamIn : BeamPort;
+        }
+        part modem : Modem;
+        connection beamFeed connect array.beamformer.beamOut to frontEnd.beamIn;
+    }
+    requirement <'REQ-LINK-MARGIN'> WorstCaseLinkMargin {
+        doc /* The link shall close (margin >= 0 dB) worst-case over the evaluation envelope. */
+        attribute metricKey = "worst_case_link_margin_db";
+        attribute threshold = 0.0 [dB];
+        attribute op = ">=";
+        attribute severity = "must";
+    }
+    requirement <'REQ-SLL'> PatternSidelobes {
+        doc /* Worst-case pattern sidelobe level shall not exceed -16 dB. */
+        attribute metricKey = "worst_case_pattern_sll_db";
+        attribute threshold = -16.0 [dB];
+        attribute op = "<=";
+        attribute severity = "must";
+    }
+    requirement <'REQ-INDEP-LINK'> IndependentLinkClosure {
+        doc /* The link shall also close under the independent opensatcom recomputation. */
+        attribute metricKey = "opensatcom_worst_case_margin_db";
+        attribute threshold = 0.0 [dB];
+        attribute op = ">=";
+        attribute severity = "must";
+    }
+    requirement <'REQ-CLEARSKY-AGREE'> ClearSkyAgreement {
+        doc /* Clear-sky margins from the two link analyses shall agree within 1.2 dB. */
+        attribute metricKey = "crosscheck_clearsky_margin_disagreement_db";
+        attribute threshold = 1.2 [dB];
+        attribute op = "<=";
+        attribute severity = "should";
+    }
+    requirement <'REQ-GAIN-XCHECK'> GainCrosscheck {
+        doc /* Claimed and integrated gain shall agree within 0.5 dB. */
+        attribute metricKey = "crosscheck_gain_disagreement_db";
+        attribute threshold = 0.5 [dB];
+        attribute op = "<=";
+        attribute severity = "should";
+    }
+    requirement <'REQ-POWER'> PrimePowerCeiling {
+        doc /* Prime power draw shall not exceed 450 W. */
+        attribute metricKey = "prime_power_w";
+        attribute threshold = 450.0 [W];
+        attribute op = "<=";
+        attribute severity = "must";
+    }
+    requirement <'REQ-COST'> UnitCostCeiling {
+        doc /* Recurring unit cost shall not exceed 45,000 USD from the parts table. */
+        attribute metricKey = "unit_cost_usd";
+        attribute threshold = 45000.0;
+        attribute op = "<=";
+        attribute severity = "must";
+    }
+    requirement <'REQ-GRATING'> GratingLobeMargin {
+        doc /* The lattice shall keep grating lobes out of visible space over the scan envelope. */
+        attribute metricKey = "grating_margin_lambda";
+        attribute threshold = 0.0;
+        attribute op = ">=";
+        attribute severity = "must";
+    }
+    analysis linkBudget : LinkBudgetAnalysis {
+        subject terminal;
+        objective { doc /* Close the uplink worst-case over the t3-001 evaluation envelope. */ }
+    }
+    analysis patternAnalysis : ArrayPatternAnalysis {
+        subject array;
+        objective { doc /* Integrate the full pattern; recompute gain, sidelobes, grating margin. */ }
+    }
+    analysis swapCost : SwapCostAnalysis {
+        subject terminal;
+        objective { doc /* Roll up prime power and unit cost from the parts table. */ }
+    }
+    satisfy WorstCaseLinkMargin by terminal;
+    satisfy IndependentLinkClosure by terminal;
+    satisfy PatternSidelobes by terminal.array;
+    satisfy GratingLobeMargin by terminal.array;
+    satisfy PrimePowerCeiling by terminal;
+    satisfy UnitCostCeiling by terminal;
+    allocate PatternSidelobes to terminal.array;
+    allocate GratingLobeMargin to terminal.array;
+    allocate PrimePowerCeiling to terminal;
+    dependency from linkBudget to WorstCaseLinkMargin; // verify
+    dependency from linkBudget to IndependentLinkClosure; // verify
+    dependency from linkBudget to ClearSkyAgreement; // verify
+    dependency from patternAnalysis to PatternSidelobes; // verify
+    dependency from patternAnalysis to GainCrosscheck; // verify
+    dependency from patternAnalysis to GratingLobeMargin; // verify
+    dependency from swapCost to PrimePowerCeiling; // verify
+    dependency from swapCost to UnitCostCeiling; // verify
+}