d0fus 2.3.0__tar.gz → 2.3.2__tar.gz

{d0fus-2.3.0 → d0fus-2.3.2}/D0FUS_BIB/D0FUS_figures.py

@@ -60,6 +60,7 @@ if __name__ != "__main__":
         f_CS_ACAD, f_CS_refined, f_CS_CIRCE,
         F_CIRCE0D, compute_von_mises_stress,
         calculate_E_mag_TF,
+        Number_TF_coils,
     )
     from .D0FUS_parameterization import DEFAULT_CONFIG, E_ELEM
 
@@ -90,6 +91,7 @@ else:
         f_CS_ACAD, f_CS_refined, f_CS_CIRCE,
         F_CIRCE0D, compute_von_mises_stress,
         calculate_E_mag_TF,
+        Number_TF_coils,
     )
     from D0FUS_BIB.D0FUS_parameterization import DEFAULT_CONFIG, E_ELEM
 
@@ -4278,6 +4280,193 @@ def plot_CICC_cross_section(
 # Stand-alone execution — smoke test
 # =============================================================================
 
+
+# =============================================================================
+# 7. TF coil number - ripple and port-access constraints
+# =============================================================================
+
+# D0FUS-consistent palette (matches the hex codes used elsewhere in this file)
+_RIP_C_PLASMA = "#f4a582"   # plasma fill
+_RIP_C_COIL   = "#2166ac"   # TF coil footprint
+_RIP_C_ACCESS = "#4dac26"   # maintenance / heating access sector
+
+
+def plot_tf_ripple(
+    R0: float = 6.2,
+    a: float = 2.0,
+    b: float = 1.2,
+    ripple_adm: float = 0.01,
+    L_min: float = 3.6,
+    grid: int = 460,
+    save_dir: str | None = None,
+) -> None:
+    """
+    Top-view map of the toroidal field magnitude produced by the discrete TF
+    coils, illustrating the field ripple.
+
+    The coil number, ripple and outboard standoff (N_coil, ripple, Delta_ext)
+    are taken from the package routine ``Number_TF_coils`` so the figure stays
+    consistent with the D0FUS sizing.  Each coil is modelled as a pair of
+    infinite straight filaments (inner leg at R0 - a - b carrying +I, outer leg
+    at R0 + a + b + Delta_ext carrying -I, at the same toroidal angle); the field
+    magnitude |B| is evaluated on a Cartesian grid in the toroidal mid-plane.
+    The prefactor mu0*I/(2*pi) is dropped, so |B| is in arbitrary units.  The
+    iso-|B| contours scallop near the coils: that scalloping is the ripple.
+
+    Parameters
+    ----------
+    R0, a    : float   Major and minor radius [m].
+    b        : float   Aggregated inboard build (FW + blanket + shield + gaps) [m].
+    ripple_adm : float Admissible ripple fraction (default 1 %).
+    L_min    : float   Minimum toroidal access per coil [m] (default 3.6 m, the
+                       ITER-reproducing value; the manuscript also uses 3.0 m).
+    grid     : int     Number of grid points per axis for the field map.
+    save_dir : str or None
+
+    References
+    ----------
+    Wesson, Tokamaks, 4th ed., p.169 - ripple model.
+    Goldston & Rutherford, Introduction to Plasma Physics, IOP (1995), ch.14.
+    """
+    n_coil, ripple_sel, Delta_ext = Number_TF_coils(R0, a, b, ripple_adm, L_min)
+    R_in   = R0 - a - b
+    R_out  = R0 + a + b + Delta_ext
+    theta  = 2.0 * np.pi * np.arange(n_coil) / n_coil
+
+    # filament positions (inner + outer legs) and signed currents
+    fx = np.concatenate([R_in * np.cos(theta),  R_out * np.cos(theta)])
+    fy = np.concatenate([R_in * np.sin(theta),  R_out * np.sin(theta)])
+    cur = np.concatenate([np.ones(n_coil),      -np.ones(n_coil)])
+
+    # |B| on a Cartesian grid (loop over filaments to limit memory)
+    L = R_out + 0.7
+    gx = np.linspace(-L, L, grid)
+    X, Y = np.meshgrid(gx, gx)
+    Bx = np.zeros_like(X)
+    By = np.zeros_like(X)
+    dmin = np.full(X.shape, np.inf)
+    for xi, yi, ci in zip(fx, fy, cur):
+        dx = X - xi
+        dy = Y - yi
+        d2 = dx * dx + dy * dy
+        Bx += ci * (-dy) / d2
+        By += ci * (dx) / d2
+        dmin = np.minimum(dmin, np.sqrt(d2))
+    rr = np.sqrt(X ** 2 + Y ** 2)
+    Bmag = np.sqrt(Bx ** 2 + By ** 2)
+    # cap the colour scale to the plasma-region field, then hide near-wire
+    # spikes and the central column for legibility
+    vmax = np.percentile(Bmag[(rr > R0 - a) & (rr < R0 + a) & (dmin > 0.22)], 99)
+    Bmag = np.ma.array(Bmag, mask=(dmin < 0.22) | (rr < R0 - a))
+
+    th = np.linspace(0, 2 * np.pi, 400)
+    fig, ax = plt.subplots(figsize=(6.4, 5.9))
+    ax.set_aspect("equal")
+    pcm = ax.pcolormesh(X, Y, Bmag, shading="auto", cmap="magma", vmin=0, vmax=vmax)
+    ax.contour(X, Y, Bmag, levels=np.linspace(0.35 * vmax, vmax, 7),
+               colors="white", linewidths=0.45, alpha=0.55)
+    ax.add_patch(mpatches.Circle((0, 0), R0 - a, facecolor="0.75",
+                                 edgecolor="0.5", lw=0.8, zorder=4))
+    ax.text(0, 0, "central\ncolumn", ha="center", va="center", fontsize=8,
+            color="0.25", zorder=5)
+    ax.plot((R0 + a) * np.cos(th), (R0 + a) * np.sin(th), color="cyan",
+            lw=1.3, ls="--", alpha=0.9, zorder=4)
+    ax.plot(R_out * np.cos(th), R_out * np.sin(th), color="white", lw=0.7,
+            ls=":", alpha=0.5, zorder=4)
+    ax.plot(R_out * np.cos(theta), R_out * np.sin(theta), "o", color="white",
+            ms=5, mec="k", mew=0.5, zorder=5)
+    ax.text(0, (R0 + a) + 0.15, "plasma edge", color="cyan", fontsize=8,
+            ha="center", va="bottom", zorder=6)
+    ax.text(-L + 0.3, L - 0.5,
+            rf"$\delta_\mathrm{{ripple}} = {ripple_sel * 100:.2f}\,\%$",
+            color="white", fontsize=11, va="top")
+    ax.set_xlim(-L, L)
+    ax.set_ylim(-L, L)
+    ax.set_xlabel("x [m]", fontsize=12)
+    ax.set_ylabel("y [m]", fontsize=12)
+    ax.set_title(rf"Toroidal field magnitude, top view ($N_\mathrm{{coil}} = {n_coil}$)",
+                 fontsize=11)
+    fig.colorbar(pcm, ax=ax, shrink=0.85, label=r"$|B|$ (arb. units)")
+    plt.tight_layout()
+    _save_or_show(fig, save_dir, "tf_ripple")
+
+
+def plot_port_access(
+    R0: float = 6.2,
+    a: float = 2.0,
+    b: float = 1.2,
+    ripple_adm: float = 0.01,
+    L_min: float = 3.6,
+    save_dir: str | None = None,
+) -> None:
+    """
+    Clean top view of the tokamak showing the TF coils and the angular sectors
+    left free between them for maintenance and heating access.
+
+    The coil number and outboard standoff come from ``Number_TF_coils`` (same
+    call as plot_tf_ripple), so the layout matches the D0FUS sizing.
+
+    Parameters
+    ----------
+    R0, a, b   : float   Plasma geometry and aggregated inboard build [m].
+    ripple_adm : float   Admissible ripple fraction (for the N_coil selection).
+    L_min      : float   Minimum toroidal pitch per coil for maintenance [m].
+    save_dir   : str or None
+    """
+    n_coil, ripple_sel, Delta_ext = Number_TF_coils(R0, a, b, ripple_adm, L_min)
+    R_out = R0 + a + b + Delta_ext
+    theta_deg = np.degrees(2.0 * np.pi * np.arange(n_coil) / n_coil)
+    pitch = 360.0 / n_coil
+    coil_hw = 0.30 * pitch                         # illustrative coil half-width
+    band = (R_out + 0.6) - (R0 + a)
+
+    fig, ax = plt.subplots(figsize=(6.2, 6.0))
+    ax.set_aspect("equal")
+
+    # plasma annulus + central column
+    ax.add_patch(mpatches.Wedge((0, 0), R0 + a, 0, 360, width=2 * a,
+                                facecolor=_RIP_C_PLASMA, alpha=0.45, lw=0, zorder=1))
+    ax.add_patch(mpatches.Circle((0, 0), R0 - a, facecolor="0.85",
+                                 edgecolor="0.6", lw=0.8, zorder=2))
+    ax.text(0, 0, "central\ncolumn", ha="center", va="center", fontsize=8.5,
+            color="0.3", zorder=3)
+    ax.text(0, -R0, "plasma", ha="center", va="center", fontsize=9,
+            color="#9c4a2f", zorder=3,
+            bbox=dict(boxstyle="round,pad=0.15", fc="white", ec="none", alpha=0.7))
+
+    # access corridors (gaps) and coil footprints
+    for t in theta_deg:
+        ax.add_patch(mpatches.Wedge((0, 0), R_out + 0.6, t + coil_hw,
+                                    t + pitch - coil_hw, width=band,
+                                    facecolor=_RIP_C_ACCESS, alpha=0.16, lw=0,
+                                    zorder=2))
+        ax.add_patch(mpatches.Wedge((0, 0), R_out + 0.6, t - coil_hw,
+                                    t + coil_hw, width=1.7,
+                                    facecolor=_RIP_C_COIL, edgecolor="none",
+                                    alpha=0.95, zorder=3))
+
+    # single neutral label on one access sector
+    tlab = theta_deg[0] + pitch / 2
+    r_lab = R0 + a + 0.9
+    ax.annotate("maintenance /\nheating access",
+                xy=(r_lab * np.cos(np.radians(tlab)), r_lab * np.sin(np.radians(tlab))),
+                xytext=(1.12 * R_out, 1.02 * R_out), fontsize=9, color="#2f6b16",
+                ha="left", arrowprops=dict(arrowstyle="->", color="#2f6b16", lw=1.0))
+
+    ax.plot([], [], color=_RIP_C_COIL, lw=6, label=rf"TF coils ($N = {n_coil}$)")
+    ax.plot([], [], color=_RIP_C_ACCESS, lw=6, alpha=0.4, label="access sectors")
+    lim = R_out + 1.6
+    ax.set_xlim(-lim, lim)
+    ax.set_ylim(-lim, lim)
+    ax.set_xlabel("x [m]", fontsize=12)
+    ax.set_ylabel("y [m]", fontsize=12)
+    ax.set_title(rf"TF coils and maintenance access, top view ($N_\mathrm{{coil}} = {n_coil}$)",
+                 fontsize=11)
+    ax.legend(fontsize=9, loc="upper left")
+    plt.tight_layout()
+    _save_or_show(fig, save_dir, "port_access")
+
+
 if __name__ == "__main__":
 
     parser = argparse.ArgumentParser(

{d0fus-2.3.0 → d0fus-2.3.2}/D0FUS_BIB/D0FUS_parameterization.py

@@ -101,6 +101,7 @@ class GlobalConfig:
     tau_i_e : float = 1.0          # Ion-to-electron temperature ratio T_i/T_e [-]
                                    # 1.0 -> single-temperature plasma (T_i = T_e).
                                    # Prescribed: T_i(rho) = tau_i_e * T_e(rho),
+    H     : float = 1.0            # Confinement enhancement factor (H-factor) [-]
 
     # ── 2. Physics and operation ─────────────────────────────────────────────
     Operation_mode     : str   = 'Pulsed'       # 'Steady-State' or 'Pulsed'
@@ -171,6 +172,7 @@ class GlobalConfig:
     #   kink_parameter='q95'    → q_limit ≈ 3.0–3.5  (ITER/EU-DEMO practice)
     q_limit         : float = 3.0  # Kink safety factor threshold [-]
     Greenwald_limit : float = 1.0  # Greenwald density fraction limit [-]
+    Ip_limit        : float = None # Upper bound on plasma current [MA]; None = no ceiling (GA)
     ms              : float = 0.3  # Vertical stability margin parameter [-]
 
     # ── 4. Plasma composition ────────────────────────────────────────────────

{d0fus-2.3.0 → d0fus-2.3.2}/D0FUS_EXE/D0FUS_genetic.py

@@ -395,7 +395,10 @@ def _summarize_cloud_per_gen(ga_cloud):
 
 def compute_stability_penalty(nbar_line, nG, betaT, betaN, q_kink,
                                q_min=DEFAULT_CONFIG.q_limit,
+                               betaN_limit=DEFAULT_CONFIG.betaN_limit,
+                               Ip=None, Ip_limit=None,
                                penalty_step=2.0,
+                               penalty_lin=10.0,
                                penalty_slope=20.0,
                                margin_width=0.05,
                                margin_amplitude=0.15):
@@ -425,12 +428,12 @@ def compute_stability_penalty(nbar_line, nG, betaT, betaN, q_kink,
        fitness is multiplied by 1.15 (a 15% cost surcharge).
        At 5% margin, penalty → 0 (no surcharge).
 
-    penalty_per_constraint (violation)  = penalty_step + penalty_slope × excess²
+    penalty_per_constraint (violation)  = penalty_step + penalty_lin × excess + penalty_slope × excess²
     penalty_per_constraint (margin zone) = margin_amplitude × (1 − margin)³
 
     Examples (per constraint, violation side):
       At boundary (ε → 0⁺):  2.0             → multiplier ≈ 3.0
-      At 10% excess:         2.0 + 0.2 = 2.2 → multiplier ≈ 3.2
+      At 10% excess:         2.0 + 1.0 + 0.2 = 3.2 → multiplier ≈ 4.2
 
     Examples (per constraint, margin zone):
       At 0% margin (just feasible):  0.15     → multiplier ≈ 1.15
@@ -456,6 +459,11 @@ def compute_stability_penalty(nbar_line, nG, betaT, betaN, q_kink,
     penalty_step : float
         Discontinuity cost at the stability boundary.  A value of 2.0
         means the fitness is multiplied by ≥ 3 for any violation.
+    penalty_lin : float
+        Linear growth coefficient beyond the boundary.  Provides a non-zero
+        slope AT the boundary so a barely-infeasible design is pulled back to
+        the limit; must exceed ~3x the cost elasticity to remove the infeasible
+        local minimum.
     penalty_slope : float
         Quadratic growth coefficient beyond the boundary.
     margin_width : float
@@ -471,7 +479,7 @@ def compute_stability_penalty(nbar_line, nG, betaT, betaN, q_kink,
         density_ratio = nbar_line / nG
         if density_ratio > 1.0:
             excess = density_ratio - 1.0
-            penalty = penalty_step + penalty_slope * excess ** 2
+            penalty = penalty_step + penalty_lin * excess + penalty_slope * excess ** 2
             penalty_terms.append(penalty)
             violations['density'] = {
                 'value': float(nbar_line), 'limit': float(nG),
@@ -481,26 +489,40 @@ def compute_stability_penalty(nbar_line, nG, betaT, betaN, q_kink,
             margin_used = (density_ratio - (1.0 - margin_width)) / margin_width
             penalty_terms.append(margin_amplitude * margin_used ** 3)
     
-    # Beta limit: betaT (in %) < betaN (in %)
-    betaT_percent = betaT * 100
-    if betaN > 0:
-        beta_ratio = betaT_percent / betaN
+    # Troyon beta limit: normalised beta_N must stay below betaN_limit
+    if betaN_limit > 0:
+        beta_ratio = betaN / betaN_limit
         if beta_ratio > 1.0:
             excess = beta_ratio - 1.0
-            penalty = penalty_step + penalty_slope * excess ** 2
+            penalty = penalty_step + penalty_lin * excess + penalty_slope * excess ** 2
             penalty_terms.append(penalty)
             violations['beta'] = {
-                'value': float(betaT_percent), 'limit': float(betaN),
+                'value': float(betaN), 'limit': float(betaN_limit),
                 'ratio': float(beta_ratio)
             }
         elif beta_ratio > (1.0 - margin_width):
             margin_used = (beta_ratio - (1.0 - margin_width)) / margin_width
             penalty_terms.append(margin_amplitude * margin_used ** 3)
     
+    # Plasma-current ceiling: Ip must stay below Ip_limit (disruption headroom)
+    if Ip is not None and isinstance(Ip_limit, (int, float)) and Ip_limit > 0:
+        ip_ratio = Ip / Ip_limit
+        if ip_ratio > 1.0:
+            excess = ip_ratio - 1.0
+            penalty = penalty_step + penalty_lin * excess + penalty_slope * excess ** 2
+            penalty_terms.append(penalty)
+            violations['Ip'] = {
+                'value': float(Ip), 'limit': float(Ip_limit),
+                'ratio': float(ip_ratio)
+            }
+        elif ip_ratio > (1.0 - margin_width):
+            margin_used = (ip_ratio - (1.0 - margin_width)) / margin_width
+            penalty_terms.append(margin_amplitude * margin_used ** 3)
+    
     # Kink safety factor: q_kink > q_min  (q_kink = q* or q95)
     if q_kink < q_min:
         deficit = (q_min - q_kink) / q_min
-        penalty = penalty_step + penalty_slope * deficit ** 2
+        penalty = penalty_step + penalty_lin * deficit + penalty_slope * deficit ** 2
         penalty_terms.append(penalty)
         violations['q_kink'] = {
             'value': float(q_kink), 'limit': float(q_min),
@@ -609,6 +631,7 @@ def evaluate_individual(individual, verbose=False):
         R0_abcd   = _safe_real(output[_IDX['r_d']])
         c_TF      = _safe_real(output[_IDX['c']])
         d_CS      = _safe_real(output[_IDX['d']])
+        Ip        = _safe_real(output[_IDX['Ip']])
 
         # Select kink parameter (q* or q95) for stability checks.
         _kink_param = static_inputs.get('kink_parameter', DEFAULT_CONFIG.kink_parameter)
@@ -628,7 +651,9 @@ def evaluate_individual(individual, verbose=False):
         q_lim = static_inputs.get('q_limit', DEFAULT_CONFIG.q_limit)
         is_stable, penalty_multiplier, violations = compute_stability_penalty(
             nbar_line, nG, betaT, betaN, q_kink,
-            q_min=q_lim
+            q_min=q_lim,
+            betaN_limit=static_inputs.get('betaN_limit', DEFAULT_CONFIG.betaN_limit),
+            Ip=Ip, Ip_limit=static_inputs.get('Ip_limit', DEFAULT_CONFIG.Ip_limit)
         )
 
         # ── Compute fitness value based on selected objective ────────────
@@ -2602,11 +2627,11 @@ def run_genetic_optimization(input_file,
 
     # Check stability (using line-averaged density for Greenwald comparison)
     q_lim = static_inputs.get('q_limit', DEFAULT_CONFIG.q_limit)
+    betaN_lim = static_inputs.get('betaN_limit', DEFAULT_CONFIG.betaN_limit)
+    Ip_lim = static_inputs.get('Ip_limit', DEFAULT_CONFIG.Ip_limit)
     is_stable, _, violations = compute_stability_penalty(
-        nbar_line, nG, betaT, betaN, q_kink, q_min=q_lim)
-    
-    # betaT is fraction, convert to % for display
-    betaT_percent = betaT * 100
+        nbar_line, nG, betaT, betaN, q_kink, q_min=q_lim, betaN_limit=betaN_lim,
+        Ip=Ip, Ip_limit=Ip_lim)
 
     # Compute Sheffield COE for the best design (regardless of objective)
     _COE_best = np.nan
@@ -2650,7 +2675,9 @@ def run_genetic_optimization(input_file,
     print(f"    Ip:                         {Ip:.2f} MA")
     print(f"    P_elec:                     {P_elec:.1f} MW")
     print(f"    n_line/nG: {nbar_line/nG:.3f} ({(1-nbar_line/nG)*100:+.1f}% margin)")
-    print(f"    betaT/betaN: {betaT_percent/betaN:.3f} ({(1-betaT_percent/betaN)*100:+.1f}% margin)")
+    print(f"    betaN/betaN_limit: {betaN/betaN_lim:.3f} ({(1-betaN/betaN_lim)*100:+.1f}% margin)")
+    if Ip_lim is not None:
+        print(f"    Ip/Ip_limit: {Ip/Ip_lim:.3f} ({(1-Ip/Ip_lim)*100:+.1f}% margin)")
     q_lim = static_inputs.get('q_limit', DEFAULT_CONFIG.q_limit)
     print(f"    {_q_label}/q_limit: {q_kink/q_lim:.3f} ({(q_kink/q_lim-1)*100:+.1f}% margin)")
     print(f"    c_TF: {c_TF:.3f} m   d_CS: {d_CS:.3f} m   r_d: {r_d:.3f} m")
@@ -2764,7 +2791,8 @@ def run_genetic_optimization(input_file,
             "n_line_over_nG": to_serializable(nbar_line/nG),
             "q_kink_over_qlim": to_serializable(q_kink/q_lim),
             "kink_parameter": _kink_param,
-            "betaT_over_betaN": to_serializable(betaT_percent/betaN) if betaN > 0 else None
+            "betaN_over_betaN_limit": to_serializable(betaN/betaN_lim) if betaN_lim > 0 else None,
+            "Ip_over_Ip_limit": to_serializable(Ip/Ip_lim) if Ip_lim is not None else None
         },
         "radial_build": {
             "c_TF_m": to_serializable(c_TF),

{d0fus-2.3.0 → d0fus-2.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: d0fus
-Version: 2.3.0
+Version: 2.3.2
 Summary: Design 0-dimensional for Fusion Systems - Tokamak power plant design and optimization tool
 Author-email: Timothé Auclair <timothe.auclair@gmail.com>
 Maintainer-email: Timothé Auclair <timothe.auclair@gmail.com>

{d0fus-2.3.0 → d0fus-2.3.2}/d0fus.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: d0fus
-Version: 2.3.0
+Version: 2.3.2
 Summary: Design 0-dimensional for Fusion Systems - Tokamak power plant design and optimization tool
 Author-email: Timothé Auclair <timothe.auclair@gmail.com>
 Maintainer-email: Timothé Auclair <timothe.auclair@gmail.com>

{d0fus-2.3.0 → d0fus-2.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "d0fus"
-version = "2.3.0"
+version = "2.3.2"
 description = "Design 0-dimensional for Fusion Systems - Tokamak power plant design and optimization tool"
 readme = "README.md"
 license = {text = "CeCILL-C"}