465 lines
16 KiB
Python
465 lines
16 KiB
Python
"""
|
||
Flask web interface for the toroidal transformer designer + simulator.
|
||
|
||
Routes
|
||
------
|
||
GET / → main page
|
||
POST /api/design → run design_transformer(), return winding info + drawing PNG (base64)
|
||
POST /api/sweep → run sweep_operating_points(), return JSON dataset
|
||
"""
|
||
|
||
import base64
|
||
import json
|
||
import math
|
||
import os
|
||
import tempfile
|
||
|
||
from flask import Flask, render_template, request, jsonify
|
||
|
||
from designer import ToroidCore, WindingSpec, WireSpec, design_transformer
|
||
from sim_toroid import (
|
||
ToroidSimulator, SimConstraints,
|
||
sweep_operating_points, SweepEntry,
|
||
)
|
||
from draw_toroid import draw_toroid
|
||
|
||
app = Flask(__name__)
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Helpers
|
||
# ---------------------------------------------------------------------------
|
||
|
||
def _parse_core(data: dict) -> ToroidCore:
|
||
"""Build ToroidCore from request dict."""
|
||
Ae = data.get("Ae_mm2")
|
||
Ve = data.get("Ve_mm3")
|
||
return ToroidCore(
|
||
ID_mm=float(data["ID_mm"]),
|
||
OD_mm=float(data["OD_mm"]),
|
||
height_mm=float(data["height_mm"]),
|
||
Ae_mm2=float(Ae) if Ae not in (None, "") else None,
|
||
Ve_mm3=float(Ve) if Ve not in (None, "") else None,
|
||
Pv_func=None, # not editable in the UI; uses built-in fallback
|
||
)
|
||
|
||
|
||
def _parse_windings(data: dict) -> list[WindingSpec]:
|
||
"""
|
||
Parse winding list from request dict.
|
||
|
||
Expected format:
|
||
windings: [
|
||
{ name: "primary", taps: [0, 25, 50], awg: [22, 22] },
|
||
{ name: "secondary", taps: [0, 100, 50, 50, 50], awg: [22, 22, 22, 26] },
|
||
]
|
||
"""
|
||
specs = []
|
||
for w in data["windings"]:
|
||
taps = [int(t) for t in w["taps"]]
|
||
awg = [int(a) for a in w["awg"]]
|
||
specs.append(WindingSpec(awg=awg, taps=taps, name=str(w.get("name", "winding"))))
|
||
return specs
|
||
|
||
|
||
def _actual_fill_factor(core: ToroidCore, results) -> float:
|
||
"""
|
||
Compute actual fill factor = total wire cross-section area placed / window area.
|
||
Sums wire area for every turn placed across all windings.
|
||
"""
|
||
window_area = core.window_area_mm2
|
||
if window_area <= 0:
|
||
return 0.0
|
||
total_wire_area = 0.0
|
||
for wr in results:
|
||
for seg in wr.segments:
|
||
wire = WireSpec.from_awg(seg.awg)
|
||
r = wire.diameter_mm / 2.0
|
||
total_wire_area += math.pi * r * r * seg.turns
|
||
return total_wire_area / window_area
|
||
|
||
|
||
def _drawing_b64(core: ToroidCore, results, actual_fill: float) -> str:
|
||
"""Render the toroid PNG and return it as a base64 data-URI string."""
|
||
with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as f:
|
||
tmp_path = f.name
|
||
try:
|
||
draw_toroid(core, results, output_path=tmp_path, dpi=150, fig_size_mm=160,
|
||
actual_fill=actual_fill)
|
||
with open(tmp_path, "rb") as f:
|
||
png_bytes = f.read()
|
||
finally:
|
||
try:
|
||
os.unlink(tmp_path)
|
||
except OSError:
|
||
pass
|
||
return "data:image/png;base64," + base64.b64encode(png_bytes).decode()
|
||
|
||
|
||
def _winding_result_to_dict(wr) -> dict:
|
||
"""Serialise a WindingResult for JSON."""
|
||
segs = []
|
||
for seg in wr.segments:
|
||
segs.append({
|
||
"segment_index": seg.segment_index,
|
||
"tap_number": seg.segment_index + 1,
|
||
"awg": seg.awg,
|
||
"turns": seg.turns,
|
||
"wire_length_m": round(seg.wire_length_m, 4),
|
||
"resistance_mohm": round(seg.resistance_ohm * 1000, 3),
|
||
"weight_g": round(seg.weight_g, 3),
|
||
"fits": seg.fits,
|
||
"layers": [
|
||
{
|
||
"layer_index": lr.layer_index,
|
||
"turns_capacity": lr.turns_capacity,
|
||
"turns_used": lr.turns_used,
|
||
"L_turn_mm": round(lr.L_turn_mm, 2),
|
||
}
|
||
for lr in seg.layers
|
||
],
|
||
})
|
||
return {
|
||
"name": wr.spec.name,
|
||
"total_turns": wr.spec.total_turns,
|
||
"feasible": wr.feasible,
|
||
"total_wire_length_m": round(wr.total_wire_length_m, 4),
|
||
"total_resistance_mohm": round(wr.total_resistance_ohm * 1000, 3),
|
||
"total_weight_g": round(wr.total_weight_g, 3),
|
||
"segments": segs,
|
||
"n_taps": len(wr.spec.taps) - 1,
|
||
}
|
||
|
||
|
||
def _sweep_entry_to_dict(e: SweepEntry) -> dict:
|
||
"""Convert SweepEntry to a plain dict suitable for JSON."""
|
||
d = e.as_dict()
|
||
# Replace NaN (not JSON-serialisable) with None
|
||
for k, v in d.items():
|
||
if isinstance(v, float) and math.isnan(v):
|
||
d[k] = None
|
||
return d
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Routes
|
||
# ---------------------------------------------------------------------------
|
||
|
||
@app.route("/")
|
||
def index():
|
||
return render_template("index.html")
|
||
|
||
|
||
@app.route("/api/design", methods=["POST"])
|
||
def api_design():
|
||
"""
|
||
Run design_transformer() and return winding info + PNG drawing.
|
||
|
||
Request body (JSON):
|
||
{
|
||
"ID_mm": 21.5, "OD_mm": 46.5, "height_mm": 22.8,
|
||
"Ae_mm2": 142.5, // optional
|
||
"Ve_mm3": 15219, // optional
|
||
"fill_factor": 0.35,
|
||
"windings": [
|
||
{ "name": "primary", "taps": [0, 25, 50], "awg": [22, 22] },
|
||
{ "name": "secondary", "taps": [0, 100, 50, 50, 50],"awg": [22, 22, 22, 26] }
|
||
]
|
||
}
|
||
"""
|
||
try:
|
||
data = request.get_json(force=True)
|
||
core = _parse_core(data)
|
||
specs = _parse_windings(data)
|
||
fill_factor = float(data.get("fill_factor", 0.35))
|
||
|
||
results = design_transformer(core, specs, fill_factor=fill_factor)
|
||
|
||
actual_fill = _actual_fill_factor(core, results)
|
||
drawing_b64 = _drawing_b64(core, results, actual_fill)
|
||
windings_info = [_winding_result_to_dict(wr) for wr in results]
|
||
|
||
# Thermal surface area of wound toroid (m²):
|
||
# outer cylinder + top/bottom annular faces + inner bore cylinder
|
||
OD_m = core.OD_mm * 1e-3
|
||
ID_m = core.ID_mm * 1e-3
|
||
H_m = core.height_mm * 1e-3
|
||
A_outer = math.pi * OD_m * H_m
|
||
A_faces = 2 * math.pi / 4 * (OD_m**2 - ID_m**2)
|
||
A_bore = math.pi * ID_m * H_m
|
||
A_surface_m2 = A_outer + A_faces + A_bore
|
||
|
||
return jsonify({
|
||
"success": True,
|
||
"windings": windings_info,
|
||
"drawing": drawing_b64,
|
||
"fill_factor_target": fill_factor,
|
||
"fill_factor_actual": round(actual_fill, 4),
|
||
"window_area_mm2": round(core.window_area_mm2, 2),
|
||
"A_surface_m2": round(A_surface_m2, 6),
|
||
})
|
||
|
||
except Exception as exc:
|
||
return jsonify({"success": False, "error": str(exc)}), 400
|
||
|
||
|
||
@app.route("/api/simulate", methods=["POST"])
|
||
def api_simulate():
|
||
"""
|
||
Compute a single operating point.
|
||
|
||
Request body (JSON):
|
||
{
|
||
// Same core + windings as /api/design ...
|
||
"fill_factor": 0.35,
|
||
"primary_tap": 1,
|
||
"secondary_tap": 1,
|
||
"Vp_rms": 12.0,
|
||
"freq_hz": 1000.0,
|
||
"R_load": 100.0,
|
||
"X_load": 0.0,
|
||
"constraints": { ... } // optional
|
||
}
|
||
"""
|
||
try:
|
||
data = request.get_json(force=True)
|
||
core = _parse_core(data)
|
||
specs = _parse_windings(data)
|
||
fill_factor = float(data.get("fill_factor", 0.35))
|
||
|
||
results = design_transformer(core, specs, fill_factor=fill_factor)
|
||
|
||
if len(results) < 2:
|
||
return jsonify({"success": False, "error": "Need at least 2 windings"}), 400
|
||
|
||
sim = ToroidSimulator(core=core, primary=results[0], secondary=results[1])
|
||
|
||
cdata = data.get("constraints", {})
|
||
constraints = SimConstraints(
|
||
B_max_T=float(cdata.get("B_max_T", 0.3)),
|
||
Vp_max=float(cdata.get("Vp_max", float("inf"))),
|
||
Vs_max=float(cdata.get("Vs_max", float("inf"))),
|
||
Ip_max=float(cdata.get("Ip_max", float("inf"))),
|
||
Is_max=float(cdata.get("Is_max", float("inf"))),
|
||
P_out_max_W=float(cdata.get("P_out_max_W", float("inf"))),
|
||
) if cdata else None
|
||
|
||
r = sim.simulate(
|
||
Vp_rms=float(data["Vp_rms"]),
|
||
freq_hz=float(data["freq_hz"]),
|
||
primary_tap=int(data["primary_tap"]),
|
||
secondary_tap=int(data["secondary_tap"]),
|
||
Z_load=(float(data.get("R_load", 0.0)), float(data.get("X_load", 0.0))),
|
||
constraints=constraints,
|
||
)
|
||
|
||
def _f(v):
|
||
return None if (isinstance(v, float) and math.isnan(v)) else v
|
||
|
||
return jsonify({
|
||
"success": True,
|
||
"Np_eff": r.Np_eff,
|
||
"Ns_eff": r.Ns_eff,
|
||
"turns_ratio": _f(round(r.turns_ratio, 4)),
|
||
"B_peak_T": _f(round(r.B_peak_T, 4)),
|
||
"Vp_rms": _f(round(r.Vp_rms_applied, 4)),
|
||
"Vs_rms": _f(round(r.Vs_rms, 4)),
|
||
"Ip_rms": _f(round(r.Ip_rms, 4)),
|
||
"Is_rms": _f(round(r.Is_rms, 4)),
|
||
"P_out_W": _f(round(r.P_out_W, 4)),
|
||
"P_cu_W": _f(round(r.P_cu_W, 4)),
|
||
"P_cu_primary_W": _f(round(r.P_cu_primary_W, 4)),
|
||
"P_cu_secondary_W": _f(round(r.P_cu_secondary_W, 4)),
|
||
"P_core_W": _f(round(r.P_core_W, 4)),
|
||
"P_in_W": _f(round(r.P_in_W, 4)),
|
||
"efficiency_pct": _f(round(r.efficiency * 100, 2)),
|
||
"violations": r.violations,
|
||
})
|
||
|
||
except Exception as exc:
|
||
import traceback
|
||
return jsonify({"success": False, "error": str(exc),
|
||
"traceback": traceback.format_exc()}), 400
|
||
|
||
|
||
@app.route("/api/sweep", methods=["POST"])
|
||
def api_sweep():
|
||
"""
|
||
Run sweep_operating_points() over a grid of frequencies × loads.
|
||
|
||
Request body (JSON):
|
||
{
|
||
// Same core + windings as /api/design ...
|
||
"fill_factor": 0.35,
|
||
"frequencies": [256, 870, 3140],
|
||
"loads": [[10, 0], [50, 0], [100, 0]], // [R, X] pairs
|
||
"target_power_W": 25.0,
|
||
"Vp_min": 1.0,
|
||
"Vp_max": 50.0,
|
||
"Vp_steps": 100,
|
||
"power_tol_pct": 2.0,
|
||
"constraints": {
|
||
"B_max_T": 0.3,
|
||
"Vp_max": 50.0,
|
||
"Vs_max": 120.0,
|
||
"Ip_max": 3.0,
|
||
"Is_max": 2.0,
|
||
"P_out_max_W": 100.0
|
||
}
|
||
}
|
||
"""
|
||
try:
|
||
data = request.get_json(force=True)
|
||
core = _parse_core(data)
|
||
specs = _parse_windings(data)
|
||
fill_factor = float(data.get("fill_factor", 0.35))
|
||
|
||
results = design_transformer(core, specs, fill_factor=fill_factor)
|
||
|
||
# Expect exactly 2 windings: primary and secondary
|
||
if len(results) < 2:
|
||
return jsonify({"success": False, "error": "Need at least 2 windings"}), 400
|
||
|
||
# Use first winding as primary, second as secondary
|
||
primary_result = results[0]
|
||
secondary_result = results[1]
|
||
|
||
sim = ToroidSimulator(core=core, primary=primary_result, secondary=secondary_result)
|
||
|
||
# Constraints
|
||
cdata = data.get("constraints", {})
|
||
constraints = SimConstraints(
|
||
B_max_T=float(cdata.get("B_max_T", 0.3)),
|
||
Vp_max=float(cdata.get("Vp_max", float("inf"))),
|
||
Vs_max=float(cdata.get("Vs_max", float("inf"))),
|
||
Ip_max=float(cdata.get("Ip_max", float("inf"))),
|
||
Is_max=float(cdata.get("Is_max", float("inf"))),
|
||
P_out_max_W=float(cdata.get("P_out_max_W", float("inf"))),
|
||
)
|
||
|
||
frequencies = [float(f) for f in data.get("frequencies", [256.0])]
|
||
loads = [(float(p[0]), float(p[1])) for p in data.get("loads", [[10.0, 0.0]])]
|
||
target_power_W = float(data.get("target_power_W", 10.0))
|
||
Vp_min = float(data.get("Vp_min", 1.0))
|
||
Vp_max_sweep = float(data.get("Vp_max", 50.0))
|
||
Vp_steps = int(data.get("Vp_steps", 100))
|
||
power_tol_pct = float(data.get("power_tol_pct", 2.0))
|
||
|
||
entries = sweep_operating_points(
|
||
sim=sim,
|
||
frequencies=frequencies,
|
||
loads=loads,
|
||
target_power_W=target_power_W,
|
||
constraints=constraints,
|
||
Vp_min=Vp_min,
|
||
Vp_max=Vp_max_sweep,
|
||
Vp_steps=Vp_steps,
|
||
power_tol_pct=power_tol_pct,
|
||
)
|
||
|
||
rows = [_sweep_entry_to_dict(e) for e in entries]
|
||
|
||
return jsonify({
|
||
"success": True,
|
||
"rows": rows,
|
||
"frequencies": frequencies,
|
||
"loads": [[r, x] for r, x in loads],
|
||
})
|
||
|
||
except Exception as exc:
|
||
import traceback
|
||
return jsonify({"success": False, "error": str(exc),
|
||
"traceback": traceback.format_exc()}), 400
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Preset persistence
|
||
# ---------------------------------------------------------------------------
|
||
|
||
PRESETS_DIR = os.path.join(os.path.dirname(__file__), "presets")
|
||
os.makedirs(PRESETS_DIR, exist_ok=True)
|
||
|
||
# Valid preset categories
|
||
_PRESET_TYPES = {"core", "windings", "constraints", "sim"}
|
||
|
||
|
||
def _preset_path(ptype: str) -> str:
|
||
return os.path.join(PRESETS_DIR, f"{ptype}.json")
|
||
|
||
|
||
def _load_store(ptype: str) -> dict:
|
||
"""Load the JSON store for a preset type; return {} on missing/corrupt."""
|
||
path = _preset_path(ptype)
|
||
if not os.path.exists(path):
|
||
return {}
|
||
try:
|
||
with open(path, "r", encoding="utf-8") as f:
|
||
return json.load(f)
|
||
except Exception:
|
||
return {}
|
||
|
||
|
||
def _save_store(ptype: str, store: dict) -> None:
|
||
path = _preset_path(ptype)
|
||
with open(path, "w", encoding="utf-8") as f:
|
||
json.dump(store, f, indent=2)
|
||
|
||
|
||
@app.route("/api/presets/<ptype>", methods=["GET"])
|
||
def presets_list(ptype: str):
|
||
"""Return list of saved preset names and the last-used name."""
|
||
if ptype not in _PRESET_TYPES:
|
||
return jsonify({"success": False, "error": f"Unknown type '{ptype}'"}), 400
|
||
store = _load_store(ptype)
|
||
names = [k for k in store if not k.startswith("_")]
|
||
last = store.get("_last", None)
|
||
return jsonify({"success": True, "names": sorted(names), "last": last})
|
||
|
||
|
||
@app.route("/api/presets/<ptype>/<name>", methods=["GET"])
|
||
def presets_load(ptype: str, name: str):
|
||
"""Load a named preset and mark it as last-used."""
|
||
if ptype not in _PRESET_TYPES:
|
||
return jsonify({"success": False, "error": f"Unknown type '{ptype}'"}), 400
|
||
store = _load_store(ptype)
|
||
if name not in store:
|
||
return jsonify({"success": False, "error": f"Preset '{name}' not found"}), 404
|
||
store["_last"] = name
|
||
_save_store(ptype, store)
|
||
return jsonify({"success": True, "name": name, "data": store[name]})
|
||
|
||
|
||
@app.route("/api/presets/<ptype>/<name>", methods=["POST"])
|
||
def presets_save(ptype: str, name: str):
|
||
"""Save (create or overwrite) a named preset and mark it as last-used."""
|
||
if ptype not in _PRESET_TYPES:
|
||
return jsonify({"success": False, "error": f"Unknown type '{ptype}'"}), 400
|
||
if not name or name.startswith("_"):
|
||
return jsonify({"success": False, "error": "Invalid preset name"}), 400
|
||
data = request.get_json(force=True)
|
||
store = _load_store(ptype)
|
||
store[name] = data
|
||
store["_last"] = name
|
||
_save_store(ptype, store)
|
||
return jsonify({"success": True, "name": name})
|
||
|
||
|
||
@app.route("/api/presets/<ptype>/<name>", methods=["DELETE"])
|
||
def presets_delete(ptype: str, name: str):
|
||
"""Delete a named preset."""
|
||
if ptype not in _PRESET_TYPES:
|
||
return jsonify({"success": False, "error": f"Unknown type '{ptype}'"}), 400
|
||
store = _load_store(ptype)
|
||
if name not in store:
|
||
return jsonify({"success": False, "error": f"Preset '{name}' not found"}), 404
|
||
del store[name]
|
||
if store.get("_last") == name:
|
||
remaining = [k for k in store if not k.startswith("_")]
|
||
store["_last"] = remaining[-1] if remaining else None
|
||
_save_store(ptype, store)
|
||
return jsonify({"success": True})
|
||
|
||
|
||
if __name__ == "__main__":
|
||
app.run(debug=True, host="0.0.0.0", port=5000)
|