vmecpp 0.4.2__tar.gz → 0.4.3__tar.gz

{vmecpp-0.4.2 → vmecpp-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vmecpp
-Version: 0.4.2
+Version: 0.4.3
 Summary: Proxima Fusion's reimplementation of the Variational Moments Equilibrium Code (VMEC), a free-boundary ideal-MHD equilibrium solver for stellarators and Tokamaks.
 Author-Email: Jonathan Schilling <jons@proximafusion.com>, Enrico Guiraud <eguiraud@proximafusion.com>, Philipp Jurasic <jurasic@proximafusion.com>
 License-Expression: MIT
@@ -20,9 +20,10 @@ Project-URL: Source, https://github.com/proximafusion/vmecpp
 Requires-Python: >=3.10
 Requires-Dist: netCDF4
 Requires-Dist: numpy
-Requires-Dist: pydantic
-Requires-Dist: jaxtyping
-Requires-Dist: jax<=0.5.0
+Requires-Dist: pydantic>=2.11
+Requires-Dist: jaxtyping>=0.2.6
+Requires-Dist: jax!=0.5.2
+Requires-Dist: jax!=0.5.1
 Requires-Dist: simsopt>=1.8.1
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
@@ -56,6 +57,7 @@ Description-Content-Type: text/markdown
 
 [![CI](https://github.com/proximafusion/vmecpp/actions/workflows/tests.yaml/badge.svg)](https://github.com/proximafusion/vmecpp/actions/workflows/tests.yaml)
 [![C++ core tests](https://github.com/proximafusion/vmecpp/actions/workflows/test_bazel.yaml/badge.svg)](https://github.com/proximafusion/vmecpp/actions/workflows/test_bazel.yaml)
+[![Publish wheels to PyPI](https://github.com/proximafusion/vmecpp/actions/workflows/pypi_publish.yml/badge.svg)](https://github.com/proximafusion/vmecpp/actions/workflows/pypi_publish.yml)
 
 VMEC++ is a Python-friendly, from-scratch reimplementation in C++ of the Variational Moments Equilibrium Code (VMEC),
 a free-boundary ideal-MHD equilibrium solver for stellarators and tokamaks.
@@ -128,7 +130,7 @@ print(vmec_output.mercier.iota)
 vmec_output.wout.save("wout_w7x.nc")
 ```
 
-Note that other output files are planned to be accessible via members of the `output` object called `threed1`, `jxbout` and `mercier` soon.
+All other output files are accessible via members of the `output` object called `threed1_volumetrics`, `jxbout` and `mercier`.
 
 ### With SIMSOPT
 
@@ -369,7 +371,7 @@ VMEC++:
 ## Roadmap
 
 Some of the things we are planning for VMEC++'s future:
-- [ ] free-boundary hot-restart in Python
+- [x] free-boundary hot-restart in Python
 - [X] open-sourcing the full VMEC++ test suite (including the Verification&Validation part that compares `wout` contents)
 - [x] open-sourcing the source code to reproduce VMEC++'s performance benchmarks
 - [ ] VMEC++ usable as a C++ bazel module

{vmecpp-0.4.2 → vmecpp-0.4.3}/README.md

@@ -19,6 +19,7 @@
 
 [![CI](https://github.com/proximafusion/vmecpp/actions/workflows/tests.yaml/badge.svg)](https://github.com/proximafusion/vmecpp/actions/workflows/tests.yaml)
 [![C++ core tests](https://github.com/proximafusion/vmecpp/actions/workflows/test_bazel.yaml/badge.svg)](https://github.com/proximafusion/vmecpp/actions/workflows/test_bazel.yaml)
+[![Publish wheels to PyPI](https://github.com/proximafusion/vmecpp/actions/workflows/pypi_publish.yml/badge.svg)](https://github.com/proximafusion/vmecpp/actions/workflows/pypi_publish.yml)
 
 VMEC++ is a Python-friendly, from-scratch reimplementation in C++ of the Variational Moments Equilibrium Code (VMEC),
 a free-boundary ideal-MHD equilibrium solver for stellarators and tokamaks.
@@ -91,7 +92,7 @@ print(vmec_output.mercier.iota)
 vmec_output.wout.save("wout_w7x.nc")
 ```
 
-Note that other output files are planned to be accessible via members of the `output` object called `threed1`, `jxbout` and `mercier` soon.
+All other output files are accessible via members of the `output` object called `threed1_volumetrics`, `jxbout` and `mercier`.
 
 ### With SIMSOPT
 
@@ -332,7 +333,7 @@ VMEC++:
 ## Roadmap
 
 Some of the things we are planning for VMEC++'s future:
-- [ ] free-boundary hot-restart in Python
+- [x] free-boundary hot-restart in Python
 - [X] open-sourcing the full VMEC++ test suite (including the Verification&Validation part that compares `wout` contents)
 - [x] open-sourcing the source code to reproduce VMEC++'s performance benchmarks
 - [ ] VMEC++ usable as a C++ bazel module

{vmecpp-0.4.2 → vmecpp-0.4.3}/pyproject.toml

@@ -30,9 +30,10 @@ classifiers = [
 dependencies = [
   "netCDF4",
   "numpy",
-  "pydantic",
-  "jaxtyping",
-  "jax<=0.5.0", # To prevent a circular import bug in jax on arch Linux
+  "pydantic>=2.11", # Introduced support for by_alias validation
+  "jaxtyping>=0.2.6",
+  "jax!=0.5.2", # To prevent a circular import bug in jax on arch Linux
+  "jax!=0.5.1", # To prevent a circular import bug in jax on arch Linux
   "simsopt>=1.8.1",
 ]
 

{vmecpp-0.4.2 → vmecpp-0.4.3}/src/vmecpp/__init__.py

@@ -38,10 +38,10 @@ SerializableSparseCoefficientArray: typing.TypeAlias = typing.Annotated[
     ),
     pydantic.BeforeValidator(_util.sparse_to_dense_coefficients_implicit),
 ]
-SerializeInt32AsFloat: typing.TypeAlias = typing.Annotated[
+SerializeIntAsFloat: typing.TypeAlias = typing.Annotated[
     _ArrayType,
-    pydantic.PlainSerializer(lambda x: x.astype(np.float64)),
-    pydantic.BeforeValidator(lambda x: x.astype(np.int32)),
+    pydantic.PlainSerializer(lambda x: np.array(x).astype(np.float64).tolist()),
+    pydantic.BeforeValidator(lambda x: np.array(x).astype(np.int64)),
 ]
 
 AuxFType = typing.Annotated[
@@ -85,7 +85,8 @@ class VmecInput(BaseModelWithNumpy):
     lasym: bool
     """Flag to indicate non-stellarator-symmetry.
 
-    Note: this flag is False if stellarator symmetry is present, True if not.
+    - False, assumes stellarator symmetry (only cosine/sine coefficients used).
+    - True, (currently unsupported) allows for non-stellarator-symmetric terms.
     """
 
     nfp: int
@@ -99,15 +100,24 @@ class VmecInput(BaseModelWithNumpy):
     ntor-1, ntor."""
 
     ntheta: int
-    """Number of poloidal grid points; if odd: is rounded to next smaller even
-    number."""
+    """Number of poloidal grid points (ntheta >= 0).
+
+    Controls the poloidal resolution in real space. If 0, chosen automatically as
+    minimally allowed. Must be at least 2*mpol + 6.
+    """
 
     nzeta: int
-    """Number of toroidal grid points; must match nzeta of mgrid file if using free-
-    boundary."""
+    """Number of toroidal grid points (nzeta >= 0).
+
+    Controls the toroidal resolution in real space. If 0, chosen automatically as
+    minimally allowed. Must be at least 2*ntor + 4.
+    """
 
     ns_array: jt.Int[np.ndarray, "num_grids"]
-    """Number of flux surfaces per multigrid step."""
+    """Number of flux surfaces per multigrid step.
+
+    Each entry >= 3 and >= previous entry.
+    """
 
     ftol_array: jt.Float[np.ndarray, "num_grids"]
     """Requested force tolerance for convergence per multigrid step."""
@@ -116,16 +126,28 @@ class VmecInput(BaseModelWithNumpy):
     """Maximum number of iterations per multigrid step."""
 
     phiedge: float
-    """Total enclosed toroidal magnetic flux in Vs == Wb."""
+    """Total enclosed toroidal magnetic flux in Vs == Wb.
+
+    - In fixed-boundary, this determines the magnetic field strength.
+    - In free-boundary, the magnetic field strength is given externally,
+    so this determines cross-section area and volume of the plasma.
+    """
 
     ncurr: typing.Literal[0, 1]
-    """Select constraint on iota or enclosed toroidal current profiles 0: constrained-iota; 1: constrained-current"""
+    """Select constraint on iota or enclosed toroidal current profiles.
+
+    - 0: constrained-iota (rotational transform profile specified)
+    - 1: constrained-current (toroidal current profile specified)
+    """
 
     pmass_type: ProfileType
     """Parametrization of mass/pressure profile."""
 
     am: jt.Float[np.ndarray, "am_len"]
-    """Mass/pressure profile coefficients."""
+    """Mass/pressure profile coefficients.
+
+    Units: Pascals for pressure.
+    """
 
     am_aux_s: jt.Float[np.ndarray, "am_aux_len"]
     """Spline mass/pressure profile: knot locations in s"""
@@ -137,13 +159,20 @@ class VmecInput(BaseModelWithNumpy):
     """Global scaling factor for mass/pressure profile."""
 
     gamma: float
-    """Adiabatic index."""
+    """Adiabatic index (ratio of specific heats).
+
+    Specifying 0 implies that the pressure profile is specified. For all other values,
+    the mass profile is specified.
+    """
 
     spres_ped: float
-    """Location of pressure pedestal in s."""
+    """Location of pressure pedestal in s.
+
+    Outside this radial location, pressure is constant.
+    """
 
     piota_type: ProfileType
-    """Parametrization of iota profile."""
+    """Parametrization of iota (rotational transform) profile."""
 
     ai: jt.Float[np.ndarray, "ai_len"]
     """Iota profile coefficients."""
@@ -155,7 +184,14 @@ class VmecInput(BaseModelWithNumpy):
     """Spline iota profile: values at knots"""
 
     pcurr_type: ProfileType
-    """Parametrization of toroidal current profile."""
+    """Parametrization of toroidal current profile.
+
+    One of: 'power_series', 'power_series_i', 'gauss_trunc', 'sum_atan', 'two_power',
+    'two_power_gs', 'akima_spline_i', 'akima_spline_ip', 'cubic_spline_i',
+    'cubic_spline_ip', 'pedestal', 'rational', 'line_segment_i', 'line_segment_ip',
+    'sum_cossq_s', 'sum_cossq_sqrts', 'sum_cossq_s_free'.
+    Default: 'power_series'.
+    """
 
     ac: jt.Float[np.ndarray, "ac_len"]
     """Enclosed toroidal current profile coefficients."""
@@ -167,16 +203,25 @@ class VmecInput(BaseModelWithNumpy):
     """Spline toroidal current profile: values at knots"""
 
     curtor: float
-    """Toroidal current in A."""
+    """Toroidal current in A.
+
+    Net toroidal current. The toroidal current profile is scaled to yield this total.
+    """
 
     bloat: float
     """Bloating factor (for constrained toroidal current)"""
 
     lfreeb: bool
-    """Flag to indicate free-boundary."""
+    """Flag to indicate free-boundary.
+
+    If True, run in free-boundary mode; if False, fixed-boundary.
+    """
 
     mgrid_file: typing.Annotated[str, pydantic.Field(max_length=200)]
-    """Full path for vacuum Green's function data."""
+    """Full path for vacuum Green's function data.
+
+    NetCDF MGRID file with magnetic field response factors for external coils.
+    """
 
     extcur: jt.Float[np.ndarray, "ext_current"]
     """Coil currents in A."""
@@ -185,7 +230,7 @@ class VmecInput(BaseModelWithNumpy):
     """Number of iterations between full vacuum calculations."""
 
     nstep: int
-    """Printout interval."""
+    """Printout interval at which convergence progress is logged."""
 
     aphi: jt.Float[np.ndarray, "aphi_len"]
     """Radial flux zoning profile coefficients."""
@@ -206,16 +251,28 @@ class VmecInput(BaseModelWithNumpy):
     """
 
     raxis_c: jt.Float[np.ndarray, "ntor_plus_1"]
-    """Magnetic axis coefficients for R ~ cos(n*v); stellarator-symmetric."""
+    """Magnetic axis coefficients for R ~ cos(n*v); stellarator-symmetric.
+
+    At least 1 value required, up to n=ntor considered.
+    """
 
     zaxis_s: jt.Float[np.ndarray, "ntor_plus_1"]
-    """Magnetic axis coefficients for Z ~ sin(n*v); stellarator-symmetric."""
+    """Magnetic axis coefficients for Z ~ sin(n*v); stellarator-symmetric.
+
+    Up to n=ntor considered; first entry (n=0) is ignored.
+    """
 
     raxis_s: jt.Float[np.ndarray, "ntor_plus_1"] | None = None
-    """Magnetic axis coefficients for R ~ sin(n*v); non-stellarator-symmetric."""
+    """Magnetic axis coefficients for R ~ sin(n*v); non-stellarator-symmetric.
+
+    Up to n=ntor considered; first entry (n=0) is ignored. Only used if lasym=True.
+    """
 
     zaxis_c: jt.Float[np.ndarray, "ntor_plus_1"] | None = None
-    """Magnetic axis coefficients for Z ~ cos(n*v); non-stellarator-symmetric."""
+    """Magnetic axis coefficients for Z ~ cos(n*v); non-stellarator-symmetric.
+
+    Only used if lasym=True.
+    """
 
     rbc: SerializableSparseCoefficientArray[
         jt.Float[np.ndarray, "mpol two_ntor_plus_one"]
@@ -233,7 +290,10 @@ class VmecInput(BaseModelWithNumpy):
         ]
         | None
     ) = None
-    """Boundary coefficients for R ~ sin(m*u - n*v); non-stellarator-symmetric"""
+    """Boundary coefficients for R ~ sin(m*u - n*v); non-stellarator-symmetric.
+
+    Only used if lasym=True.
+    """
 
     zbc: (
         SerializableSparseCoefficientArray[
@@ -241,25 +301,32 @@ class VmecInput(BaseModelWithNumpy):
         ]
         | None
     ) = None
-    """Boundary coefficients for Z ~ cos(m*u - n*v); non-stellarator-symmetric"""
+    """Boundary coefficients for Z ~ cos(m*u - n*v); non-stellarator-symmetric.
+
+    Only used if lasym=True.
+    """
 
     @pydantic.model_validator(mode="after")
     def _validate_fourier_coefficients_shapes(self) -> VmecInput:
         """All geometry coefficients need to have the shape (mpol, 2*ntor+1), wit 'rbs',
         'zbc' only populated for non-stellarator symmetric configurations."""
         mpol_two_ntor_plus_one_fields = ["rbc", "zbs"]
-        mpol_two_ntor_plus_one_fields_lasym = ["rbs", "zbc"]
         if self.lasym:
-            mpol_two_ntor_plus_one_fields.extend(mpol_two_ntor_plus_one_fields_lasym)
+            mpol_two_ntor_plus_one_fields.extend(["rbs", "zbc"])
 
         expected_shape = (self.mpol, 2 * self.ntor + 1)
         for field in mpol_two_ntor_plus_one_fields:
             shape = np.shape(getattr(self, field))
             if shape != expected_shape:
-                msg = f"{field} has shape {shape} instead of the expected {expected_shape}."
-                "Please resize your coefficient array using vmecpp.VmecInput.resize_2d_coeff"
-                f"({field}, {self.mpol}, {self.ntor}) to match mpol={self.mpol} or ntor={self.ntor}"
-                raise ValueError(msg)
+                setattr(
+                    self,
+                    field,
+                    VmecInput.resize_2d_coeff(
+                        getattr(self, field),
+                        mpol_new=self.mpol,
+                        ntor_new=self.ntor,
+                    ),
+                )
         return self
 
     @pydantic.model_validator(mode="after")
@@ -322,6 +389,11 @@ class VmecInput(BaseModelWithNumpy):
 
         smaller_ntor = min(ntor, ntor_new)
         smaller_mpol = min(mpol, mpol_new)
+        if mpol_new < mpol or ntor_new < ntor:
+            logger.warning(
+                f"Discarding coefficients because mpol={mpol} or ntor={ntor} "
+                f"are smaller than mpol_new={mpol_new} or ntor_new={ntor_new}"
+            )
 
         for m in range(smaller_mpol):
             for n in range(-smaller_ntor, smaller_ntor + 1):
@@ -567,10 +639,10 @@ class VmecWOut(BaseModelWithNumpy):
     DMerc: jt.Float[np.ndarray, "n_surfaces"]
     equif: jt.Float[np.ndarray, "n_surfaces"]
     # In wout these are stored as float64, although they only take integer values.
-    xm: SerializeInt32AsFloat[jt.Int[np.ndarray, "mn_mode"]]
-    xn: SerializeInt32AsFloat[jt.Int[np.ndarray, "mn_mode"]]
-    xm_nyq: SerializeInt32AsFloat[jt.Int[np.ndarray, "mn_mode_nyq"]]
-    xn_nyq: SerializeInt32AsFloat[jt.Int[np.ndarray, "mn_mode_nyq"]]
+    xm: SerializeIntAsFloat[jt.Int[np.ndarray, "mn_mode"]]
+    xn: SerializeIntAsFloat[jt.Int[np.ndarray, "mn_mode"]]
+    xm_nyq: SerializeIntAsFloat[jt.Int[np.ndarray, "mn_mode_nyq"]]
+    xn_nyq: SerializeIntAsFloat[jt.Int[np.ndarray, "mn_mode_nyq"]]
     mass: jt.Float[np.ndarray, "n_surfaces"]
     buco: jt.Float[np.ndarray, "n_surfaces"]
     bvco: jt.Float[np.ndarray, "n_surfaces"]
@@ -609,7 +681,7 @@ class VmecWOut(BaseModelWithNumpy):
         jt.Float[np.ndarray, "ext_current"],
         pydantic.BeforeValidator(lambda x: x if np.shape(x) != () else np.array([])),
         pydantic.PlainSerializer(
-            lambda x: x if x.shape != (0,) else netCDF4.default_fillvals["f8"]
+            lambda x: x if np.shape(x) != (0,) else netCDF4.default_fillvals["f8"]
         ),
     ]
     """Coil currents in A.
@@ -791,7 +863,8 @@ class VmecWOut(BaseModelWithNumpy):
                     )
                     string_variable[:] = padded_value_as_netcdf3_compatible_chararray
 
-                elif field_type is np.ndarray:
+                elif field_type is np.ndarray or field_type is list:
+                    value_array = np.array(value)
                     if (
                         field_info is not None  # is a model field
                         and field_info.annotation is not None  # has an annotation
@@ -809,23 +882,29 @@ class VmecWOut(BaseModelWithNumpy):
                         )
                     else:
                         # The dimensions are not annotated (must be an extra field)
-                        shape_string = tuple([f"dim_{dim:05d}" for dim in value.shape])
+                        shape_string = tuple(
+                            [f"dim_{dim:05d}" for dim in value_array.shape]
+                        )
 
                     for dim_name, dim_size in zip(
-                        shape_string, value.shape, strict=True
+                        shape_string, value_array.shape, strict=True
                     ):
                         if dim_name not in fnc.dimensions:
                             fnc.createDimension(dim_name, dim_size)
 
-                    dtype = value.dtype
+                    dtype = value_array.dtype
+                    if np.issubdtype(dtype, np.integer):
+                        # wout format uses 32 bit integers, Python uses 64 bit by default
+                        dtype = np.int32
+
                     if len(shape_string) == 1:
                         fnc.createVariable(field, dtype, shape_string)
                         # Slice arrays that are padded in wout and unpadded in VMEC++
-                        fnc[field][: len(value)] = value
+                        fnc[field][: len(value_array)] = value_array
                     elif len(shape_string) == 2:
                         # 2D arrays are transposed in Fortran, also reverse the dimension order
                         fnc.createVariable(field, dtype, shape_string[::-1])
-                        fnc[field][:] = value.T
+                        fnc[field][:] = value_array.T
                     else:
                         msg = f"Field {field} has an unsupported shape: {shape_string}"
                         raise ValueError(msg)

{vmecpp-0.4.2 → vmecpp-0.4.3}/src/vmecpp/_pydantic_numpy.py

@@ -21,15 +21,13 @@ class BaseModelWithNumpy(pydantic.BaseModel):
     model_config = pydantic.ConfigDict(
         arbitrary_types_allowed=True,
         # Serialize NaN and infinite floats as strings in JSON output.
-        # See: https://docs.google.com/document/d/1fTvLrCl_tfjgud8SL7PVwhG28az0oy22gVa5wvqXSxY
-        # for why.
         # Due to a bug in Pydantic, this setting is ignored by model_dump(mode="json"),
         # so we override it below to also convert values to string there.
         ser_json_inf_nan="strings",
     )
 
     @pydantic.field_serializer("*", mode="wrap", when_used="json")
-    def _dapper_serialize_field(
+    def _serialize_field(
         self,
         value: typing.Any,
         default_handler: pydantic.SerializerFunctionWrapHandler,
@@ -42,7 +40,7 @@ class BaseModelWithNumpy(pydantic.BaseModel):
 
     @pydantic.field_validator("*", mode="wrap")
     @classmethod
-    def _dapper_validate_field(
+    def _validate_field(
         cls,
         value: typing.Any,
         default_handler: pydantic.ValidatorFunctionWrapHandler,
@@ -75,7 +73,7 @@ class BaseModelWithNumpy(pydantic.BaseModel):
             return output_dict
 
 
-"""This module handles special cases for serialization of DapperData types.
+"""This module handles special cases for serialization of BaseModelWithNumpy types.
 
 Any data type that pydantic cannot natively handle can be supported by
 adding a case in this module.
@@ -87,16 +85,16 @@ Before adding a special case to this module, consider one of these two alternati
 
 1) Wrap the type definition and add Pydantic serializers and validators directly:
    `Annotated[<type>, pydantic.PlainSerializer(...), pydantic.BeforeValidator(...)]`
-   Example can be found here: dapper/examples/annotated_serialization.py
+   Example can be found here: vmecpp/src/vmecpp/__init__.py
 
-2) Convert/wrap the unsupported class in a DapperData class and provide a
+2) Convert/wrap the unsupported class in a BaseModelWithNumpy class and provide a
    @pydantic.field_serializer and @pydantic.field_validator method on that class.
    See: https://docs.pydantic.dev/latest/concepts/serialization/#custom-serializers
 
 The advantage of adding a special case to this module is solely so types can be
-declared in DapperData classes "as-is" without wrapping them with Annotated types.
+declared in BaseModelWithNumpy classes "as-is" without wrapping them with Annotated types.
 For example, you can declare `value: jt.Float[np.ndarray, ...]` instead of
-`value: dapper.NumpyArrayWrapper[...]`.
+`value: NumpyArrayWrapper[...]`.
 
 ----
 
@@ -104,7 +102,7 @@ The mechanism for serialization is to convert "special" fields to JSON-serializa
 values and then let Pydantic take care of the rest.
 In practice:
 - If the field is "special", (e.g. `np.ndarray`) it is converted to either a primitive
-  list or a `dapper.Blob`, depending on the presence of a `dapper.Binary` annotation.
+  list.
 - If the field is a generic/composed type such as a list, an optional or a union,
   recurse and do the same for the inner types.
 - Otherwise just return the field as is.
@@ -119,8 +117,9 @@ JAX array handling works as follows:
  - During serialization, JAX arrays are converted to numpy arrays and serialized with
    the same rules.
  - During validation, "jt.Array" annotations are NOT treated specially, thus only numpy
-   arrays can be produced by the deserialization process. To put JAX arrays into Dapper
-   types that should be serializable, they must be annotated with np.ndarray | jt.Array!
+   arrays can be produced by the deserialization process. To put JAX arrays into
+   BaseModelWithNumpy types that should be serializable, they must be annotated with
+   np.ndarray | jt.Array!
 """
 NpOrAbstractArray = np.ndarray | jt.AbstractArray
 
@@ -187,12 +186,10 @@ def _serialize_value(declared_type: type, value: Any, field_metadata: list[Any])
         declared_type: The innermost declared type of the field. Unused, since for
             serialization, the runtime type of the value is enough.
         value: The scalar value to serialize, that potentially needs special handling.
-        field_metadata: The annotation metadata of the field, which may contain the
-            `dapper.Binary` annotation.
 
     Returns:
-        Any value that can be serialized by Pydantic, for example a `dapper.Blob`,
-        a dict representation of the object, or a raw string.
+        Any value that can be serialized by Pydantic, for example a dict representation
+        of the object, or a raw string.
         Returns the unmodified value if no special handling applies.
     """
     if issubclass(declared_type, NpOrAbstractArray) and _is_arraylike(value):
@@ -295,7 +292,7 @@ def _traverse_field_contents(
     # happen to those and if more cases even exist, so let's be defensive and admit that
     # we don't know how to handle them ...
     if not isinstance(outer_type, type) and outer_type is not Union:
-        msg = f"Dapper serialization does not know how to handle type {outer_type}! "
+        msg = f"BaseModelWithNumpy serialization does not know how to handle type {outer_type}! "
         raise NotImplementedError(msg)
 
     # - Union[T, TOther].
@@ -384,8 +381,6 @@ def sanitize_floats_in_container(value: list | dict) -> None:
             value[key] = _sanitize_float(item)
 
 
-# See: https://docs.google.com/document/d/1fTvLrCl_tfjgud8SL7PVwhG28az0oy22gVa5wvqXSxY
-# for the rationale behind representing these values as strings.
 def _sanitize_float(value: float) -> float | str:
     if np.isnan(value):
         return "NaN"

{vmecpp-0.4.2 → vmecpp-0.4.3}/src/vmecpp/cpp/MODULE.bazel

@@ -1,7 +1,7 @@
 # Find available modules at https://registry.bazel.build
 
 # NOTE: if updating the version, must also update src/vmecpp/__about__.py
-module(name = "vmecpp", version = "0.3.0")
+module(name = "vmecpp", version = "0.4.2")
 
 bazel_dep(name = "abseil-cpp", version = "20230802.0.bcr.1")
 bazel_dep(name = "eigen", version = "3.4.0.bcr.3")

{vmecpp-0.4.2 → vmecpp-0.4.3}/src/vmecpp/cpp/vmecpp/common/util/util.h

@@ -162,6 +162,24 @@ enum class VmecStatus : std::uint8_t {
   SUCCESSFUL_TERMINATION = 11
 };
 
+enum class VacuumPressureState : std::int8_t {
+  // No vacuum pressure
+  kOff = -1,
+
+  // No vacuum pressure yet, force free-boundary update, but ignore the result
+  // in this force-balance computation.
+  kInitializing = 0,
+
+  // vacuum pressure turned on.
+  // soft restart equilibrium calculation by returning BAD_JACOBIAN in the
+  // process of reducing rCon0,zCon0 *= 0.9;
+  kInitialized = 1,
+
+  // vacuum pressure turned on
+  // in the process of reducing rCon0,zCon0 *= 0.9;
+  kActive = 2
+};
+
 int VmecStatusCode(const VmecStatus vmec_status);
 
 std::string VmecStatusAsString(const VmecStatus vmec_status);

{vmecpp-0.4.2 → vmecpp-0.4.3}/src/vmecpp/cpp/vmecpp/free_boundary/free_boundary_base/free_boundary_base.h

@@ -58,10 +58,18 @@ class FreeBoundaryBase {
   SurfaceGeometry sg_;
   ExternalMagneticField ef_;
 
+  // [nZnT] vacuum magnetic pressure |B_vac^2|/2 at the plasma boundary
+  // Points to vacuum_magnetic_pressure in HandoverStorage
   std::span<double> bSqVacShare;
 
+  // [nZnT] cylindrical B^R of Nestor's vacuum magnetic field
+  // Points to vacuum_b_r in HandoverStorage
   std::span<double> vacuum_b_r_share_;
+  // [nZnT] cylindrical B^phi of Nestor's vacuum magnetic field
+  // Points to vacuum_b_phi in HandoverStorage
   std::span<double> vacuum_b_phi_share_;
+  // [nZnT] cylindrical B^Z of Nestor's vacuum magnetic field
+  // Points to vacuum_b_z in HandoverStorage
   std::span<double> vacuum_b_z_share_;
 };  // FreeBoundaryBase
 

{vmecpp-0.4.2 → vmecpp-0.4.3}/src/vmecpp/cpp/vmecpp/vmec/handover_storage/handover_storage.h

@@ -88,6 +88,9 @@ class HandoverStorage {
   // Amperes
   double bSubVVac;
 
+  // Used only in rzConIntoVolume() to extrapolate the constraint force
+  // contribution from the LCFS into the plasma volume.
+  // TODO(jurasic) this should have a smaller scope.
   std::vector<double> rCon_LCFS;
   std::vector<double> zCon_LCFS;