feat: Pass OperatingPoint to StrayCapacitance for proper voltage scaling

Add new calculate_capacitance(Coil, OperatingPoint) overload that extracts
actual RMS voltages from the operating point excitations. This enables
correct electric field visualization with actual operating voltages instead
of hardcoded 10V reference.

Changes:
- Add calculate_capacitance(Coil, OperatingPoint) with validation
- Extract RMS voltages from winding excitations with exception handling
- Add private helper calculate_capacitance_with_voltages() for shared logic
- Update calculate_electric_field_sdf() to pass operating point
- Update test to use SDF_PHYSICS model for electric field visualization

The electric field now properly scales with actual operating voltage
(~676V RMS) showing visible color variation from blue (low) to red/yellow
(high field intensity).

Author: AlfVII

src/physical_models/StrayCapacitance.cpp

@@ -1452,6 +1452,46 @@ std::pair<SixCapacitorNetworkPerWinding, TripoleCapacitancePerWinding> StrayCapa
 
 
 StrayCapacitanceOutput StrayCapacitance::calculate_capacitance(Coil coil) {
+    std::map<std::string, double> voltageRmsPerWinding;
+    double primaryNumberTurns = coil.get_functional_description()[0].get_number_turns();
+    for (auto winding : coil.get_functional_description()) {
+        double turnsRatio = primaryNumberTurns /  winding.get_number_turns();
+        voltageRmsPerWinding[winding.get_name()] = 10.0 / turnsRatio;
+    }
+    return calculate_capacitance_with_voltages(coil, voltageRmsPerWinding);
+}
+
+StrayCapacitanceOutput StrayCapacitance::calculate_capacitance(Coil coil, OperatingPoint operatingPoint) {
+    // Extract actual RMS voltages from operating point
+    std::map<std::string, double> voltageRmsPerWinding;
+    
+    for (size_t windingIndex = 0; windingIndex < coil.get_functional_description().size(); ++windingIndex) {
+        if (windingIndex >= operatingPoint.get_excitations_per_winding().size()) {
+            throw InvalidInputException(ErrorCode::MISSING_DATA, "Missing excitation for winding index: " + std::to_string(windingIndex));
+        }
+        
+        auto& excitation = operatingPoint.get_excitations_per_winding()[windingIndex];
+        
+        if (!excitation.get_voltage()) {
+            throw InvalidInputException(ErrorCode::MISSING_DATA, "Missing voltage in excitation for winding: " + coil.get_functional_description()[windingIndex].get_name());
+        }
+        
+        if (!excitation.get_voltage()->get_processed()) {
+            throw InvalidInputException(ErrorCode::MISSING_DATA, "Voltage is not processed for winding: " + coil.get_functional_description()[windingIndex].get_name());
+        }
+        
+        auto rmsVoltage = excitation.get_voltage()->get_processed()->get_rms();
+        if (!rmsVoltage) {
+            throw InvalidInputException(ErrorCode::MISSING_DATA, "Missing RMS voltage value for winding: " + coil.get_functional_description()[windingIndex].get_name());
+        }
+        
+        voltageRmsPerWinding[coil.get_functional_description()[windingIndex].get_name()] = rmsVoltage.value();
+    }
+    
+    return calculate_capacitance_with_voltages(coil, voltageRmsPerWinding);
+}
+
+StrayCapacitanceOutput StrayCapacitance::calculate_capacitance_with_voltages(Coil coil, std::map<std::string, double> voltageRmsPerWinding) {
     std::map<std::pair<size_t, size_t>, double> electricEnergyBetweenTurnsMap;
     std::map<std::pair<size_t, size_t>, double> voltageDropBetweenTurnsMap;
     std::map<std::string, std::map<std::string, ScalarMatrixAtFrequency>> capacitanceMatrix;
@@ -1460,13 +1500,6 @@ StrayCapacitanceOutput StrayCapacitance::calculate_capacitance(Coil coil) {
 
     auto capacitanceAmongTurns = calculate_capacitance_among_turns(coil);
 
-    std::map<std::string, double> voltageRmsPerWinding;
-    double primaryNumberTurns = coil.get_functional_description()[0].get_number_turns();
-    for (auto winding : coil.get_functional_description()) {
-        double turnsRatio = primaryNumberTurns /  winding.get_number_turns();
-        voltageRmsPerWinding[winding.get_name()] = 10.0 / turnsRatio;
-    }
-
     auto strayCapacitanceOutput = StrayCapacitance::calculate_voltages_per_turn(coil, voltageRmsPerWinding);
     auto voltagesPerTurn = strayCapacitanceOutput.get_voltage_per_turn().value();
     auto windings = coil.get_functional_description();

src/physical_models/StrayCapacitance.h

@@ -72,6 +72,7 @@ class StrayCapacitance{
         StrayCapacitanceModels _modelName;
         static double calculate_area_between_two_turns_using_diagonals(Turn firstTurn, Turn secondTurn);
         static double calculate_area_between_two_turns_using_vecticals_and_horizontals(Turn firstTurn, Turn secondTurn);
+        StrayCapacitanceOutput calculate_capacitance_with_voltages(Coil coil, std::map<std::string, double> voltageRmsPerWinding);
     public:
 
         StrayCapacitance(StrayCapacitanceModels strayCapacitanceModel = StrayCapacitanceModels::ALBACH){
@@ -93,6 +94,7 @@ class StrayCapacitance{
         std::map<std::pair<size_t, size_t>, double> calculate_capacitance_among_turns(Coil coil);
 
         StrayCapacitanceOutput calculate_capacitance(Coil coil);
+        StrayCapacitanceOutput calculate_capacitance(Coil coil, OperatingPoint operatingPoint);
 
     // Bipolar coordinate system for round-round energy density computation
     struct BipolarParams {

src/support/Painter.cpp

@@ -474,7 +474,7 @@ Field PainterInterface::calculate_electric_field_sdf(OperatingPoint operatingPoi
     size_t numberPointsY = settings.get_painter_number_points_y();
     Field inducedField = CoilMesher::generate_mesh_induced_grid(magnetic, frequency, numberPointsX, numberPointsY, false, false).first;
 
-    auto capacitanceOutput = strayCapacitance.calculate_capacitance(coil);
+    auto capacitanceOutput = strayCapacitance.calculate_capacitance(coil, operatingPoint);
     auto voltageDropAmongTurnsOpt = capacitanceOutput.get_voltage_drop_among_turns();
     if (!voltageDropAmongTurnsOpt) {
         // Return the mesh field even without voltage data

tests/TestCoilAdviser.cpp

@@ -6,6 +6,7 @@
 #include "advisers/CoreAdviser.h"
 #include "advisers/CoilAdviser.h"
 #include "processors/Inputs.h"
+#include "physical_models/StrayCapacitance.h"
 #include <magic_enum.hpp>
 #include "TestingUtils.h"
 #include "support/Settings.h"
@@ -2173,6 +2174,28 @@ TEST_CASE("Test_CoilAdviser_WASM_Replication", "[adviser][coil-adviser][wasm-rep
         REQUIRE(currentDensity < 12e6);
     }
 
+    // Calculate voltage for each winding (needed for electric field calculation)
+    // Get the actual magnetizing inductance from the designed magnetic
+    auto magnetic = masMagneticsWithCoil[0].get_mutable_magnetic();
+    OpenMagnetics::MagnetizingInductance magnetizingInductanceModel("ZHANG");
+    
+    // Add voltage to each winding's excitation
+    for (size_t opIndex = 0; opIndex < masMagneticsWithCoil[0].get_inputs().get_operating_points().size(); ++opIndex) {
+        auto& operatingPoint = masMagneticsWithCoil[0].get_mutable_inputs().get_mutable_operating_points()[opIndex];
+        auto inductanceOutput = magnetizingInductanceModel.calculate_inductance_from_number_turns_and_gapping(
+            magnetic.get_mutable_core(), coil, &operatingPoint);
+        double magnetizingInductance = resolve_dimensional_values(inductanceOutput.get_magnetizing_inductance());
+        
+        for (size_t windingIndex = 0; windingIndex < magnetic.get_coil().get_functional_description().size(); ++windingIndex) {
+            auto& excitation = operatingPoint.get_mutable_excitations_per_winding()[windingIndex];
+            // Calculate induced voltage based on turns ratio
+            double turnsRatio = static_cast<double>(coil.get_functional_description()[windingIndex].get_number_turns()) / static_cast<double>(coil.get_functional_description()[0].get_number_turns());
+            double windingInductance = magnetizingInductance * pow(turnsRatio, 2);
+            auto voltage = OpenMagnetics::Inputs::calculate_induced_voltage(excitation, windingInductance);
+            excitation.set_voltage(voltage);
+        }
+    }
+
     auto outputFilePath = std::filesystem::path{ std::source_location::current().file_name() }.parent_path().append("..").append("output");
     auto outFile = outputFilePath;
     std::string filename = "Test_CoilAdviser_WASM_Replication.svg";
@@ -2184,9 +2207,12 @@ TEST_CASE("Test_CoilAdviser_WASM_Replication", "[adviser][coil-adviser][wasm-rep
     OpenMagnetics::Settings::GetInstance().set_painter_number_points_y(100);
     OpenMagnetics::Settings::GetInstance().set_painter_include_fringing(false);
 
-    // Paint electric field using the first operating point
+    // Paint electric field using the first operating point with SDF_PHYSICS model
     painter.paint_electric_field(masMagneticsWithCoil[0].get_inputs().get_operating_points()[0], 
-                                  masMagneticsWithCoil[0].get_magnetic());
+                                  masMagneticsWithCoil[0].get_magnetic(), 
+                                  1, std::nullopt, 
+                                  ElectricFieldVisualizationModel::SDF_PHYSICS, 
+                                  ColorPalette::VIRIDIS);
 
     painter.paint_core(masMagneticsWithCoil[0].get_mutable_magnetic());
     painter.paint_bobbin(masMagneticsWithCoil[0].get_mutable_magnetic());