fix(magnetic-adviser): preserve ranking spread for single-filter scenarios

Two related fixes for the El Choker catalog adviser displaying score=100
on every returned magnetic when only one filter weight is active.

1. MagneticFilterImpedance dropped the dead-band clamp that collapsed
   every in-band part to penalty=0. With identical raw scorings,
   normalize_scoring's min==max branch returned 1.0 for every part,
   wiping out the ranking. The dead band is meaningless for ranking
   anyway because min-max normalization rescales to [0,1] and discards
   any constant offset. The score is now the raw mean log10(Zact/Zreq),
   which is monotonic and produces visible spread.

2. The catalogue overload of get_advised_magnetic now uses a stable
   tiebreaker (lexicographic reference) when totalScoring values are
   equal. std::sort on its own is unstable; equal-score blocks were
   reordered between runs depending on input vector order, breaking
   ranking determinism in the UI and tests.

Adds Test_CatalogueAdviser_Single_Filter_Ranking_Spread regression
test (smoke) which mutates a Web_1 catalogue Mas into 4 distinct turn
counts, runs the adviser with a single strict Impedance filter, and
asserts (a) underlying impedances differ, (b) >= 2 distinct scores,
(c) sort is monotonic.

Author: AlfVII

src/advisers/MagneticAdviser.cpp

@@ -371,9 +371,17 @@ std::vector<std::pair<Mas, double>> MagneticAdviser::get_advised_magnetic(Inputs
     logEntry("Found " + std::to_string(masData.size()) + " magnetics", "MagneticAdviser", 2);
     auto masMagneticsWithScoring = score_magnetics(masData, filterFlow);
 
-    sort(masMagneticsWithScoring.begin(), masMagneticsWithScoring.end(), [](std::pair<Mas, double>& b1, std::pair<Mas, double>& b2) {
-        return b1.second > b2.second;
-    });
+        sort(masMagneticsWithScoring.begin(), masMagneticsWithScoring.end(), [](std::pair<Mas, double>& b1, std::pair<Mas, double>& b2) {
+            if (b1.second != b2.second) {
+                return b1.second > b2.second;
+            }
+            // Deterministic tiebreaker: lexicographic reference. Without this,
+            // parts with equal totalScoring (common when one filter dominates
+            // and other filter contributions saturate) get reordered between
+            // runs by std::sort's unstable behaviour, breaking ranking
+            // determinism in the UI and tests.
+            return b1.first.get_mutable_magnetic().get_reference() < b2.first.get_mutable_magnetic().get_reference();
+        });
 
     if (masMagneticsWithScoring.size() > maximumNumberResults) {
         masMagneticsWithScoring = std::vector<std::pair<Mas, double>>(masMagneticsWithScoring.begin(), masMagneticsWithScoring.end() - (masMagneticsWithScoring.size() - maximumNumberResults));

src/advisers/MagneticFilter.cpp

@@ -1920,26 +1920,23 @@ std::pair<bool, double> MagneticFilterImpedance::evaluate_magnetic(Magnetic* mag
     bool valid = true;
     double scoring = 0;
 
-    // Impedance scoring: dimensionless log-ratio with industry-standard dead band.
+    // Impedance scoring: dimensionless log-ratio.
     //
     // For a "minimum impedance" requirement the part is invalid if Zact < Zreq at any
-    // frequency. Among valid parts we want to:
-    //   - reward parts that comfortably meet the requirement,
-    //   - not over-reward parts that grossly over-dimension (cost / size penalty),
-    //   - leave a tolerance band that absorbs typical CMC manufacturing tolerance
-    //     (~30%) plus a small design margin, so a "well-sized" part is not penalized.
+    // frequency. Among valid parts we want to reward parts close to the requirement
+    // (smallest over-dimensioning) and penalize gross over-dimensioning (cost/size).
     //
-    // Per-frequency penalty:
-    //     dev_i = log10(max(Zact_i / Zreq_i, 1))   // 0 when under-spec (caught by validity)
-    //     pen_i = max(0, dev_i - log10(1 + DEAD_BAND))
+    // Per-frequency:
+    //     dev_i = log10(max(Zact_i / Zreq_i, 1))   // 0 when at-spec (under-spec → invalid)
     // Filter score = mean over frequency points (then min-max normalized + inverted
-    // by normalize_scoring downstream).
+    // downstream so smallest dev becomes the top score).
     //
-    // Dead band: 50% (factor 1.5) - covers typical ±25..30% impedance tolerance of
-    // common-mode chokes (Würth WE-CMB, TDK ACT, Murata DLW, EPCOS B82xxx) plus
-    // ~20% engineering headroom for temperature drift / aging. Tunable below.
-    constexpr double IMPEDANCE_DEAD_BAND = 0.50;
-    const double deadBandLog = std::log10(1.0 + IMPEDANCE_DEAD_BAND);
+    // No dead band on the raw score: normalize_scoring rescales to [0,1] so any
+    // constant offset is wiped out, and a hard zero-clamp collapses all in-band parts
+    // to the same value -- which then triggers the min==max degenerate branch in
+    // normalize_scoring and returns 1.0 for every part (the "all show 100" bug).
+    // Keeping the raw monotonic dev preserves ranking spread when this is the only
+    // active filter.
 
     if (inputs->get_design_requirements().get_minimum_impedance()) {
         auto impedanceRequirement = inputs->get_design_requirements().get_minimum_impedance().value();
@@ -1953,11 +1950,10 @@ std::pair<bool, double> MagneticFilterImpedance::evaluate_magnetic(Magnetic* mag
             }
 
             // Ratio is clamped to >= 1: under-spec parts are already invalidated above,
-            // so we only score over-dimensioning above the dead band.
+            // so we only score over-dimensioning.
             double ratio = (zReq > 0) ? std::max(zAct / zReq, 1.0) : 1.0;
             double dev = std::log10(ratio);
-            double penalty = std::max(0.0, dev - deadBandLog);
-            scoring += penalty;
+            scoring += dev;
         }
         scoring /= impedanceRequirement.size();
     }

tests/TestMagneticAdviser.cpp

@@ -2608,6 +2608,90 @@ namespace {
         REQUIRE(masMagnetics.size() > 0);
     }
 
+    TEST_CASE("Test_CatalogueAdviser_Single_Filter_Ranking_Spread", "[adviser][magnetic-adviser][catalogue][bug][smoke-test]") {
+        // Regression test for "all parts show score 100" bug.
+        //
+        // When the user enables a single filter (e.g. only Impedance at weight=1,
+        // strictlyRequired=true), every returned magnetic in the El Choker UI
+        // displayed the same scoring value (1.0 → 100). Root cause: the Impedance
+        // filter clamped every in-band part to penalty=0, so all per-part scorings
+        // were identical (0). normalize_scoring then hit its min==max degenerate
+        // branch and returned 1.0 for every part, collapsing the ranking.
+        //
+        // This test asserts that with a single strict Impedance filter and a catalogue
+        // of magnetics with measurably different impedances, the per-part scorings
+        // span at least 2 distinct values — proving the ranking is monotonic.
+
+        auto json_path = OpenMagneticsTesting::get_test_data_path(std::source_location::current(), "test_catalogueadviser_web_1_2218.json");
+        std::ifstream json_file(json_path);
+        json catalogueJson = json::parse(json_file);
+
+        std::vector<OpenMagnetics::Mas> catalogue;
+        from_json(catalogueJson, catalogue);
+        REQUIRE(catalogue.size() >= 1);
+
+        // The on-disk fixture is a family of identical magnetics. To get a
+        // ranking-spread test we mutate copies of the first Mas with different
+        // turn counts (impedance scales monotonically with N for an ungapped
+        // ferrite core), producing measurably distinct |Z| at the test frequency.
+        OpenMagnetics::Mas templateMas = catalogue[0];
+        catalogue.clear();
+        for (uint64_t turns : {120UL, 180UL, 240UL, 300UL}) {
+            OpenMagnetics::Mas copy = templateMas;
+            copy.get_mutable_magnetic().get_mutable_coil().get_mutable_functional_description()[0].set_number_turns(turns);
+            // Force a unique reference so add_scoring/get_scorings does not collide.
+            MagneticManufacturerInfo info;
+            info.set_reference("turns_" + std::to_string(turns));
+            copy.get_mutable_magnetic().set_manufacturer_info(info);
+            catalogue.push_back(copy);
+        }
+        REQUIRE(catalogue.size() >= 2);
+
+        // Inject a minimum-impedance requirement that all magnetics in this catalogue
+        // can comfortably meet (so the strict filter does not reject them, and we
+        // can observe the ranking spread among the surviving parts).
+        ImpedancePoint impedancePoint;
+        impedancePoint.set_magnitude(1.0);  // 1 Ω at 150 kHz — trivially met by any CMC
+        ImpedanceAtFrequency impedanceAtFrequency;
+        impedanceAtFrequency.set_frequency(150000);
+        impedanceAtFrequency.set_impedance(impedancePoint);
+        std::vector<ImpedanceAtFrequency> minimumImpedance{impedanceAtFrequency};
+        for (auto& mas : catalogue) {
+            mas.get_mutable_inputs().get_mutable_design_requirements().set_minimum_impedance(minimumImpedance);
+        }
+
+        // Single filter, strict, full weight — exactly the El Choker UI scenario when
+        // the user sets only the Impedance slider to 100.
+        json filterFlowJson = json::parse(R"([{"filter": "Impedance", "invert": true, "log": false, "strictlyRequired": true, "weight": 1 }])");
+        std::vector<OpenMagnetics::MagneticFilterOperation> filterFlow = filterFlowJson.get<std::vector<OpenMagnetics::MagneticFilterOperation>>();
+
+        MagneticAdviser magneticAdviser(false);
+        auto masMagnetics = magneticAdviser.get_advised_magnetic(catalogue, filterFlow, catalogue.size());
+        REQUIRE(masMagnetics.size() >= 2);
+
+        // Sanity-check the underlying raw impedances actually differ across the
+        // catalogue. If they don't, the test data is unsuitable and we should
+        // fail loudly rather than silently passing on identical scores.
+        std::set<double> distinctImpedances;
+        for (auto& [mas, _] : masMagnetics) {
+            auto z = abs(Impedance().calculate_impedance(mas.get_mutable_magnetic(), 150000));
+            distinctImpedances.insert(std::round(z * 1e6) / 1e6);
+        }
+        REQUIRE(distinctImpedances.size() >= 2);
+
+        // The actual regression assertion: scores must span at least 2 distinct
+        // values. Pre-fix this collapsed to {1.0} for every part.
+        std::set<double> distinctScores;
+        for (auto& [mas, scoring] : masMagnetics) {
+            distinctScores.insert(std::round(scoring * 1e6) / 1e6);
+        }
+        REQUIRE(distinctScores.size() >= 2);
+
+        // Adviser sorts highest-first; with invert=true on Impedance, the smallest
+        // over-dimensioning (closest to requirement) should be the top score.
+        REQUIRE(masMagnetics.front().second > masMagnetics.back().second);
+    }
+
     TEST_CASE("Test_CatalogueAdviser_Web_4", "[adviser][magnetic-adviser][catalogue][bug]") {
         SKIP("Test needs investigation");