aero-agent-roles 1.0.0

package/roles/do160-environmental-engineer/templates/environmental-qualification-plan-template.md

@@ -0,0 +1,114 @@
+# Equipment Environmental Qualification Plan/Report
+
+**Item:** Terrain Awareness Warning System (TAWS) computer LRU
+**Installation:** Forward equipment bay, pressurized and temperature-controlled, FAR/CS-25 transport
+**Certification basis:** FAR/CS-25
+**Standard:** DO-160G (environmental conditions and test procedures for airborne equipment)
+**Status:** draft-for-review
+
+## 1. Scope
+
+This plan/report covers environmental qualification of the LRU Terrain Awareness Warning System (TAWS) computer LRU. Line-replaceable unit hosting the TAWS alerting function for a FAR/CS-25 transport.
+Expected operating temperature extremes: -40 to 55 deg C.
+
+## 2. Environmental categories
+
+- Temperature/altitude category: B1 (typical operating range -55 to 55 deg C; typical reference data, confirm against the current revision).
+- ESD category: A (single category per Section 25).
+- RF emissions installation category: A (reference-only RE102 floor model).
+- Lightning: Section 22 test level 3, waveform set A, B, C, H.
+- Power input: 28 VDC bus, Section 16 envelope (see Section 6).
+
+## 3. Qualification test matrix
+
+Required test-condition sections for the equipment category (B1) and planned coverage:
+
+| Section | Test condition | Planned |
+|---|---|---|
+| 4 | Temperature and altitude | yes |
+| 5 | Temperature variation | yes |
+| 6 | Humidity | yes |
+| 7 | Operational shocks and crash safety | yes |
+| 8 | Vibration | yes |
+| 9 | Explosion proofness | yes |
+| 10 | Waterproofness | yes |
+| 11 | Fluids susceptibility | yes |
+| 16 | Power input | yes |
+| 19 | Induced signal susceptibility | yes |
+| 20 | Radio frequency susceptibility | yes |
+| 21 | Emission of radio frequency energy | yes |
+| 22 | Lightning induced transient susceptibility | yes |
+| 23 | Lightning direct effects | yes |
+| 24 | Icing | yes |
+| 25 | Electrostatic discharge | yes |
+
+Matrix completeness: COMPLETE - no required section missing.
+Category-specific section exclusions must be confirmed against the current revision before freezing the matrix.
+
+## 4. Electrostatic discharge (Section 25)
+
+- Equipment category: A (the only Section 25 category).
+- Test level: 15 kV air discharge on the equipment bonded to the ground plane.
+- Discharge generator (IEC 61000-4-2 human-body model): 150 pF storage capacitance, 330 ohm discharge resistance.
+- Stored energy at test level: 0.016875 J (16.875 mJ).
+- Waveform: first peak 56.25 A, 30.00 A at 30 ns, 15.00 A at 60 ns; rise time 0.7 to 1.0 ns; RC time constant 49.5 ns.
+- Discharges per test point: 10 positive and 10 negative (valid: true).
+- Test points: surfaces accessible to personnel during normal operation or maintenance; connector pins are not applicable test points.
+- Verdict (planned): PASS - operates as specified with no permanent degradation.
+
+## 5. Lightning protection (Sections 22/23)
+
+- Section 22 induced transient susceptibility test level: 3 (valid range 1-5: true).
+- Waveform set: A, B, C, H (letters within A-H: true).
+- Section 22/23 pass criteria: no physical damage, no upset, no latch-up after the applied transients.
+- Verdict (planned): PASS.
+- Level and waveform tables are standard data in the current revision; verify selection before freezing the plan.
+
+## 6. Power input (Section 16)
+
+- Bus: 28 VDC; Section 16 category envelope values applied from the current revision (data-driven, summary reference).
+- Normal steady-state range: 22.0 to 29.0 V. Emergency range: 18.0 to 32.2 V (emergency-rated: true).
+- Measured steady state 27.5 V: within normal range; margins 5.5 V low / 1.5 V high.
+- Measured sag 20.0% of nominal (80 ms event vs 25% max / 100 ms envelope): within envelope; margins 20.0 ms, 5.0%.
+- Recovery after transient 60 ms vs 100 ms allowable: within.
+- Ripple: 3.57% of nominal (characterization).
+- Emergency classification of measured bus: normal.
+
+## 7. Radio frequency susceptibility (Section 20)
+
+- RS103 radiated test field: 100 V/m (typical mid-range category value; verify against the current revision).
+- Calibration field with 6 dB margin: 199.5 V/m.
+- Amplifier budget for 3 m, 3 dBi, 3 dB cable loss, 6 dB margin: 11943 W.
+- Far-field check: wavelength at 1 GHz is 0.2998 m; the far-field relation E = sqrt(30*P*G)/d holds beyond the Fraunhofer distance.
+- CS114 conducted category C: limit 75.7 dBuA (summary reference base); measured 60.0 dBuA gives margin 15.7 dB (within limit).
+
+## 8. Radio frequency emissions (Section 21)
+
+- RE102 radiated, installation category A (reference-only floor 24 dBuV/m, 2 MHz to 18 GHz):
+  - Measured sweep: 15.0 dBuV/m at 10 MHz, 20.0 dBuV/m at 100 MHz, 18.0 dBuV/m at 1 GHz.
+  - Margins: +9.0 dB, +4.0 dB, +6.0 dB; worst case 100 MHz at +4.0 dB.
+  - Verdict: PASS (minimum margin >= 0 dB).
+- CE102 conducted (10 kHz to 10 MHz, reference-only band curve):
+  - Measured sweep: 68.0 dBuV at 50 kHz, 54.0 dBuV at 150 kHz, 66.0 dBuV at 5 MHz.
+  - Margins: +10.0 dB, +6.0 dB, +4.0 dB; worst case 5 MHz at +4.0 dB.
+  - Verdict: PASS (minimum margin >= 0 dB).
+- A margin band of at least 6 dB is typical engineering recommendation (reference-only, not an RTCA requirement).
+
+## 9. Verdicts and open items
+
+| Domain | Section | Verdict |
+|---|---|---|
+| Electrostatic discharge | 25 | PASS |
+| Lightning | 22/23 | PASS |
+| Power input | 16 | PASS |
+| RF susceptibility (CS114) | 20 | PASS |
+| RF emissions (RE102) | 21 | PASS |
+| RF emissions (CE102) | 21 | PASS |
+
+Open items before the human environmental qualification engineer signs:
+- Confirm level/waveform/limit tables against the current DO-160 revision (typical reference data used throughout).
+- Confirm category-specific matrix exclusions for the installed location.
+- Review measured bench data against the qualification test environment.
+
+---
+*Generated by Aero Agent Roles do160-environmental-engineer core. DRAFT for human environmental qualification engineer review. Not an approval document.*

package/roles/do160-environmental-engineer/tests/test_do160_environmental_core.py

@@ -0,0 +1,312 @@
+#!/usr/bin/env python3
+"""Test do160_environmental_core: the executable engine of the DO-160G
+Environmental Qualification Engineer role.
+
+Proves the role can DO its job standalone (no AeroSkills needed):
+category selection, matrix completeness, ESD/lightning/power/RF domain
+rules, report generation, and evidence-gate checks. Every numeric
+anchor mirrors the bound AeroSkills avionics/do160 leaf logic files.
+"""
+import os
+import sys
+import unittest
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)),
+                                "..", "core"))
+from do160_environmental_core import (  # noqa: E402
+    CE102_BAND_HI_HZ, CE102_BAND_LO_HZ,
+    RE102_BAND_HI_HZ, RE102_BAND_LO_HZ, RE102_FLOOR_DBU_VPM,
+    SECTIONS, TEMPERATURE_RANGES,
+    build_qualification_report, check_qualification_report,
+    check_qualification_report_markdown,
+    cs114_category_offset, cs114_limit_dbu_a, dbu_v_per_m_from_v_per_m,
+    dbu_v_from_volts, emission_verdict, esd_category_test_level_kv,
+    esd_current_30ns_amps, esd_current_60ns_amps, esd_discharge_count_valid,
+    esd_pass_verdict, esd_peak_current_amps, esd_rc_time_constant_ns,
+    esd_rise_time_valid_ns, esd_stored_energy_joules,
+    esd_test_point_applicable, example_item,
+    example_qualification_report_markdown, field_strength_from_erp,
+    frequency_deviation, frequency_within_tolerance, lightning_level_valid,
+    lightning_pass_verdict, lightning_waveform_valid, limits_margins,
+    margin_check_dbu, matrix_complete, power_for_field_strength,
+    required_amp_power_for_test, required_sections, re102_limit_db,
+    render_qualification_report_markdown, ripple_percent,
+    sag_depth_percent, section_name, select_temperature_category,
+    surge_height_percent, temperature_category_range, temp_within_range,
+    transient_check, transient_recovery_ok, voltage_within_limits,
+    worst_case_frequency,
+)
+
+
+class TestEnvironmentalQualificationDomain(unittest.TestCase):
+    """Mirrors avionics/do160/environmental-qualification logic anchors."""
+
+    def test_section_names(self):
+        self.assertEqual(section_name(16), "Power input")
+        self.assertEqual(section_name(25), "Electrostatic discharge")
+        self.assertEqual(section_name(20), "Radio frequency susceptibility")
+        self.assertEqual(section_name(21), "Emission of radio frequency energy")
+        self.assertEqual(section_name(22),
+                         "Lightning induced transient susceptibility")
+        with self.assertRaises(ValueError):
+            section_name(99)
+
+    def test_temperature_ranges(self):
+        self.assertEqual(temperature_category_range("B1"), (-55, 55))
+        self.assertEqual(temperature_category_range("A2"), (-55, 70))
+        self.assertEqual(TEMPERATURE_RANGES["B2"], (-55, 70))
+        with self.assertRaises(ValueError):
+            temperature_category_range("Z9")
+
+    def test_temp_within_range(self):
+        self.assertTrue(temp_within_range(-40, "B1"))
+        self.assertTrue(temp_within_range(55, "B1"))    # inclusive top
+        self.assertFalse(temp_within_range(60, "B1"))
+
+    def test_category_selection_covers_extremes(self):
+        # example LRU: -40..55 deg C in a pressurized bay -> B1 covers
+        cat = select_temperature_category(-40, 55)
+        self.assertEqual(cat, "B1")
+        lo, hi = temperature_category_range(cat)
+        self.assertLessEqual(-40, hi) and self.assertGreaterEqual(55, lo)
+        # any declared extremes must be inside the selected typical range
+        cat2 = select_temperature_category(-55, 70)
+        self.assertTrue(temp_within_range(-55, cat2))
+        self.assertTrue(temp_within_range(70, cat2))
+
+    def test_required_sections_full_set(self):
+        req = required_sections("B1")
+        # full leaf section set, sorted
+        self.assertEqual(req, sorted(SECTIONS))
+        self.assertIn(22, req)  # lightning induced - never omitted by default
+        self.assertIn(25, req)  # ESD
+
+    def test_matrix_complete(self):
+        missing, ok = matrix_complete(sorted(SECTIONS), "B1")
+        self.assertEqual(missing, [])
+        self.assertTrue(ok)
+        missing2, ok2 = matrix_complete([4, 5, 6], "B1")
+        self.assertIn(25, missing2)
+        self.assertFalse(ok2)
+        with self.assertRaises(ValueError):
+            matrix_complete([99], "B1")
+
+
+class TestEsdDomain(unittest.TestCase):
+    """Mirrors avionics/do160/electrostatic-discharge logic anchors."""
+
+    def test_category_level(self):
+        self.assertEqual(esd_category_test_level_kv("A"), 15.0)
+        self.assertEqual(esd_category_test_level_kv("a"), 15.0)
+        with self.assertRaises(ValueError):
+            esd_category_test_level_kv("B")
+
+    def test_stored_energy_anchors(self):
+        # 150 pF at 15 kV -> 16.875 mJ; at 8 kV -> 4.8 mJ
+        self.assertAlmostEqual(esd_stored_energy_joules(150.0, 15.0),
+                               0.016875, places=9)
+        self.assertAlmostEqual(esd_stored_energy_joules(150.0, 8.0),
+                               0.0048, places=9)
+
+    def test_waveform_current_anchors(self):
+        self.assertAlmostEqual(esd_peak_current_amps(15.0), 56.25, places=2)
+        self.assertAlmostEqual(esd_peak_current_amps(2.0), 7.5, places=2)
+        self.assertAlmostEqual(esd_current_30ns_amps(15.0), 30.0, places=2)
+        self.assertAlmostEqual(esd_current_60ns_amps(15.0), 15.0, places=2)
+
+    def test_rise_and_rc(self):
+        self.assertTrue(esd_rise_time_valid_ns(0.8))
+        self.assertFalse(esd_rise_time_valid_ns(0.5))
+        self.assertFalse(esd_rise_time_valid_ns(1.2))
+        self.assertAlmostEqual(esd_rc_time_constant_ns(330.0, 150.0),
+                               49.5, places=1)
+
+    def test_discharge_counts(self):
+        self.assertTrue(esd_discharge_count_valid(10, 10))
+        self.assertFalse(esd_discharge_count_valid(9, 10))
+        self.assertFalse(esd_discharge_count_valid(10, 9))
+        with self.assertRaises(ValueError):
+            esd_discharge_count_valid(10.5, 10)
+
+    def test_test_point_applicability(self):
+        self.assertTrue(esd_test_point_applicable(True, False, False))
+        self.assertTrue(esd_test_point_applicable(False, True, False))
+        # connector pins are NOT applicable test points (DO-160G)
+        self.assertFalse(esd_test_point_applicable(True, False, True))
+        self.assertFalse(esd_test_point_applicable(False, False, False))
+
+    def test_pass_verdict(self):
+        self.assertTrue(esd_pass_verdict(True, True))
+        self.assertFalse(esd_pass_verdict(False, True))
+        self.assertFalse(esd_pass_verdict(True, False))
+
+
+class TestLightningDomain(unittest.TestCase):
+    """Mirrors avionics/do160/lightning-protection logic anchors."""
+
+    def test_level_range(self):
+        self.assertTrue(lightning_level_valid(3))
+        self.assertTrue(lightning_level_valid(1))
+        self.assertTrue(lightning_level_valid(5))
+        self.assertFalse(lightning_level_valid(0))
+        self.assertFalse(lightning_level_valid(6))
+        with self.assertRaises(ValueError):
+            lightning_level_valid("3")
+        with self.assertRaises(ValueError):
+            lightning_level_valid(3.5)
+
+    def test_waveforms(self):
+        for w in "ABCDEFGH":
+            self.assertTrue(lightning_waveform_valid(w))
+        self.assertTrue(lightning_waveform_valid("c"))  # case-insensitive
+        self.assertFalse(lightning_waveform_valid("I"))
+        self.assertFalse(lightning_waveform_valid(""))
+        with self.assertRaises(ValueError):
+            lightning_waveform_valid(7)
+
+    def test_pass_verdict(self):
+        self.assertTrue(lightning_pass_verdict(False, False, False))
+        self.assertFalse(lightning_pass_verdict(True, False, False))
+        self.assertFalse(lightning_pass_verdict(False, True, False))
+        self.assertFalse(lightning_pass_verdict(False, False, True))
+
+
+class TestPowerInputDomain(unittest.TestCase):
+    """Mirrors avionics/do160/power-input logic anchors (data-driven)."""
+
+    def test_sag_surge(self):
+        self.assertAlmostEqual(sag_depth_percent(28.0, 21.0), 25.0, places=6)
+        self.assertAlmostEqual(surge_height_percent(28.0, 32.2), 15.0,
+                               places=6)
+        with self.assertRaises(ValueError):
+            sag_depth_percent(28.0, 32.0)  # that is a surge
+
+    def test_frequency(self):
+        dev_hz, dev_pct = frequency_deviation(412.0, 400.0)
+        self.assertAlmostEqual(dev_hz, 12.0, places=6)
+        self.assertAlmostEqual(dev_pct, 3.0, places=6)
+        self.assertTrue(frequency_within_tolerance(412.0, 400.0, 5.0))
+        self.assertFalse(frequency_within_tolerance(422.0, 400.0, 5.0))
+
+    def test_limits_and_margins(self):
+        self.assertTrue(voltage_within_limits(27.5, 22.0, 29.0))
+        self.assertFalse(voltage_within_limits(21.0, 22.0, 29.0))
+        ml, mh = limits_margins(27.5, 22.0, 29.0)
+        self.assertAlmostEqual(ml, 5.5, places=6)
+        self.assertAlmostEqual(mh, 1.5, places=6)
+
+    def test_transients(self):
+        self.assertTrue(transient_recovery_ok(60.0, 100.0))
+        ok, dm, dp = transient_check(80.0, 20.0, 100.0, 25.0)
+        self.assertTrue(ok)
+        self.assertAlmostEqual(dm, 20.0, places=6)
+        self.assertAlmostEqual(dp, 5.0, places=6)
+
+    def test_ripple(self):
+        self.assertAlmostEqual(ripple_percent(29.0, 27.0, 28.0),
+                               3.5714285714, places=6)
+
+
+class TestRfSusceptibilityDomain(unittest.TestCase):
+    """Mirrors avionics/do160/radio-frequency-susceptibility anchors."""
+
+    def test_amp_budget_anchor(self):
+        # 100 V/m at 3 m, 3 dBi, 3 dB cable loss, 6 dB margin -> ~12 kW
+        w = required_amp_power_for_test(100.0, 3.0, 3.0, 3.0, 6.0)
+        self.assertAlmostEqual(w, 11970.0, delta=120)
+
+    def test_power_roundtrip(self):
+        # E = sqrt(30*P*G)/d; P = E^2 d^2 / (30 G)
+        self.assertAlmostEqual(power_for_field_strength(5.477, 1.0, 10.0),
+                               100.0, delta=0.1)
+
+    def test_cs114_category_steps(self):
+        self.assertEqual(cs114_category_offset("A"), 0.0)
+        self.assertEqual(cs114_category_offset("B"), 10.0)
+        self.assertEqual(cs114_category_offset("C"), 20.0)
+        self.assertEqual(cs114_category_offset("J"), 80.0)
+        with self.assertRaises(ValueError):
+            cs114_category_offset("I")  # letter I is skipped
+        self.assertAlmostEqual(cs114_limit_dbu_a("B"), 65.7, places=1)
+
+    def test_margin_check(self):
+        margin, ok = margin_check_dbu(60.0, 65.7)
+        self.assertTrue(ok)
+        self.assertAlmostEqual(margin, 5.7, places=1)
+        _, bad = margin_check_dbu(70.0, 65.7)
+        self.assertFalse(bad)
+
+
+class TestRfEmissionsDomain(unittest.TestCase):
+    """Mirrors avionics/do160/radio-frequency-emissions anchors."""
+
+    def test_conversions(self):
+        self.assertAlmostEqual(dbu_v_from_volts(1.0), 120.0, places=6)
+        self.assertAlmostEqual(dbu_v_per_m_from_v_per_m(1.0), 120.0,
+                               places=6)
+
+    def test_limit_curves(self):
+        self.assertEqual(RE102_FLOOR_DBU_VPM, {"A": 24.0, "B": 34.0,
+                                               "C": 44.0})
+        self.assertAlmostEqual(re102_limit_db(100e6, "A"), 24.0, places=6)
+        self.assertAlmostEqual(re102_limit_db(100e6, "C"), 44.0, places=6)
+        self.assertEqual(CE102_BAND_LO_HZ, 10e3)
+        self.assertEqual(CE102_BAND_HI_HZ, 10e6)
+        self.assertEqual(RE102_BAND_LO_HZ, 2e6)
+        self.assertEqual(RE102_BAND_HI_HZ, 18e9)
+
+    def test_erp_sanity_check(self):
+        # 100 W ERP at 10 m -> 5.477 V/m (~134.77 dBuV/m)
+        e = field_strength_from_erp(100.0, 10.0)
+        self.assertAlmostEqual(e, 5.477, places=2)
+        self.assertAlmostEqual(dbu_v_per_m_from_v_per_m(e), 134.77,
+                               places=1)
+
+    def test_worst_case_and_verdict(self):
+        freqs = [50e3, 150e3, 5e6]
+        margins = [8.0, 5.0, 8.0]
+        wf, wm = worst_case_frequency(freqs, margins)
+        self.assertEqual(wf, 150e3)
+        self.assertAlmostEqual(wm, 5.0, places=6)
+        v = emission_verdict(margins, freqs, "A", "CE102")
+        self.assertTrue(v["pass"])
+        # negative worst margin fails
+        v2 = emission_verdict([-2.0], [100e6], "A", "RE102")
+        self.assertFalse(v2["pass"])
+
+
+class TestQualificationReportBuilder(unittest.TestCase):
+
+    def test_example_report_all_gates_pass(self):
+        model = build_qualification_report(example_item())
+        self.assertEqual(model["temperature_category"], "B1")
+        self.assertEqual(model["status"], "draft-for-review")
+        self.assertTrue(model["matrix_complete"])
+        self.assertEqual(model["esd"]["test_level_kv"], 15.0)
+        gates = check_qualification_report(model)
+        self.assertTrue(gates["all_pass"], gates)
+
+    def test_report_sections_present(self):
+        md = example_qualification_report_markdown()
+        for sec in ["## 1. Scope", "## 3. Qualification test matrix",
+                    "## 6. Power input (Section 16)",
+                    "## 7. Radio frequency susceptibility (Section 20)",
+                    "## 9. Verdicts and open items"]:
+            self.assertIn(sec, md)
+        self.assertIn("not an approval", md.lower())
+
+    def test_markdown_gates_all_pass(self):
+        md = example_qualification_report_markdown()
+        gates = check_qualification_report_markdown(md, "B1")
+        self.assertTrue(gates["all_pass"], gates)
+
+    def test_standalone_no_skills_repo(self):
+        os.environ["AEROSKILLS_DEV"] = "/nonexistent"
+        model = build_qualification_report(example_item())
+        self.assertTrue(model["matrix_complete"])
+        md = render_qualification_report_markdown(model)
+        self.assertGreater(len(md), 2000)
+
+
+if __name__ == "__main__":
+    unittest.main()