rafmudaf-floris 4.6.4.post1.dev9__tar.gz → 4.6.4.post1.dev13__tar.gz

{rafmudaf_floris-4.6.4.post1.dev9 → rafmudaf_floris-4.6.4.post1.dev13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rafmudaf-floris
-Version: 4.6.4.post1.dev9
+Version: 4.6.4.post1.dev13
 Summary: A controls-oriented engineering wake model.
 Author-email: Rafael Mudafort <rafael@clementinescientific.com>
 License: BSD 3-Clause License

{rafmudaf_floris-4.6.4.post1.dev9 → rafmudaf_floris-4.6.4.post1.dev13}/floris/core/cpp_core.py

@@ -1,5 +1,5 @@
 """
-cpp_core.py — Phase 8: CppCore Python wrapper
+cpp_core.py — CppCore Python wrapper
 ==============================================
 
 Drop-in replacement for ``floris.core.core.Core`` backed by the C++ libtorch
@@ -28,16 +28,16 @@ unchanged.
 Supported
 ---------
 ``run()``, ``run_no_wake()``, ``get_turbine_powers()`` and all gradient-based
-optimisation inputs (layout_x, yaw_angles fully differentiable through the C++
+optimization inputs (layout_x, yaw_angles fully differentiable through the C++
 wavefront solver).
 
 Not supported
 -------------
 ``solve_for_viz``, ``solve_for_points``,
 ``solve_for_velocity_deficit_profiles`` — these raise ``NotImplementedError``.
-Use ``FlorisModel(backend='python')`` for flow-field visualisation.
+Use ``FlorisModel(backend='python')`` for flow-field visualization.
 
-Phase 8 limitations
+limitations
 -------------------
 * Heterogeneous turbine farms: the C++ solver uses the first power/thrust table
   for **all** turbines.  Full per-turbine table dispatch is a Phase 11 task.
@@ -67,9 +67,16 @@ from floris.utilities import load_yaml
 # the cpp backend is actually requested).
 # ---------------------------------------------------------------------------
 
-def _to_f32(x, device="cpu"):
+# dtype used for all tensors passed to the C++ extension.  Defaults to
+# float32; overridden to float64 once the extension is imported and
+# floris_cpp.using_double() is known.  Set in CppCore.from_dict().
+_KFLOAT_DTYPE: torch.dtype = torch.float32
+
+
+def _to_kfloat(x, device="cpu"):
     """
-    Convert *x* to a float32 ``torch.Tensor`` on *device*.
+    Convert *x* to a ``torch.Tensor`` on *device* using the precision
+    required by the compiled C++ extension (_KFLOAT_DTYPE).
 
     Accepts both ``numpy.ndarray`` (v4.6.4 Python core) and
     ``torch.Tensor``.  The autograd graph is preserved so that inputs
@@ -77,8 +84,8 @@ def _to_f32(x, device="cpu"):
     enabling gradient-based layout and yaw optimisation.
     """
     if isinstance(x, torch.Tensor):
-        return x.float().to(device)
-    return torch.tensor(np.asarray(x, dtype=np.float32)).to(device)
+        return x.to(dtype=_KFLOAT_DTYPE, device=device)
+    return torch.tensor(np.asarray(x), dtype=_KFLOAT_DTYPE).to(device)
 
 
 def _get_tilt_angles(py_farm):
@@ -141,7 +148,7 @@ def _build_turbine_tables(floris_cpp, cpp_farm, py_farm, device="cpu"):
     Populate ``cpp_farm.turbine_tables`` from the Python farm's
     ``turbine_power_thrust_tables`` dict.
 
-    Phase 8 note: one table per *unique* turbine type is added.  For
+    Note: one table per *unique* turbine type is added.  For
     heterogeneous farms the C++ solver uses index 0 for all turbines; full
     per-turbine dispatch is deferred to Phase 11.
     """
@@ -151,9 +158,9 @@ def _build_turbine_tables(floris_cpp, cpp_farm, py_farm, device="cpu"):
             continue
         added_types.add(turb_type)
         tbl = floris_cpp.PowerThrustTable()
-        tbl.wind_speed          = _to_f32(tbl_dict["wind_speed"], device)
-        tbl.thrust_coefficient  = _to_f32(tbl_dict["thrust_coefficient"], device)
-        tbl.power               = _to_f32(tbl_dict["power"], device)
+        tbl.wind_speed          = _to_kfloat(tbl_dict["wind_speed"], device)
+        tbl.thrust_coefficient  = _to_kfloat(tbl_dict["thrust_coefficient"], device)
+        tbl.power               = _to_kfloat(tbl_dict["power"], device)
         # ref_tilt: used for CosineLossTurbine CT correction CT *= cos(yaw)*cos(tilt)/cos(ref_tilt)
         tbl.ref_tilt = float(tbl_dict["ref_tilt"])
         floris_cpp.farm_add_turbine_table(cpp_farm, tbl)
@@ -280,6 +287,10 @@ class CppCore:
         wake_model = d["wake"]["model_strings"]["velocity_model"]
         floris_cpp = _get_floris_cpp(solver=cpp_solver_paradigm, wake_model=wake_model)
 
+        # Sync tensor precision with the compiled extension.
+        global _KFLOAT_DTYPE
+        _KFLOAT_DTYPE = torch.float64 if floris_cpp.using_double() else torch.float32
+
         # Validate solver key early so errors surface at init time, not run().
         available = floris_cpp.available_solvers()
         if cpp_solver_paradigm not in available:
@@ -294,7 +305,7 @@ class CppCore:
         obj._cpp_solver_paradigm = cpp_solver_paradigm
 
         # Python Core — owns all Python-specific state (power/thrust functions,
-        # turbine type maps, AWC/setpoint arrays, as_dict() serialisation, etc.)
+        # turbine type maps, AWC/setpoint arrays, as_dict() serialization, etc.)
         obj._py_core = Core.from_dict(d)
 
         # C++ ModelConfig — wake hyperparameters + solver selection
@@ -321,16 +332,16 @@ class CppCore:
     @staticmethod
     def _make_cpp_farm(floris_cpp, py_farm, device="cpu") -> object:
         f = floris_cpp.Farm()
-        f.layout_x        = _to_f32(py_farm.layout_x, device)
-        f.layout_y        = _to_f32(py_farm.layout_y, device)
-        f.hub_heights     = _to_f32(py_farm.hub_heights, device)
-        f.rotor_diameters = _to_f32(py_farm.rotor_diameters, device)
-        f.yaw_angles      = _to_f32(py_farm.yaw_angles, device)
+        f.layout_x        = _to_kfloat(py_farm.layout_x, device)
+        f.layout_y        = _to_kfloat(py_farm.layout_y, device)
+        f.hub_heights     = _to_kfloat(py_farm.hub_heights, device)
+        f.rotor_diameters = _to_kfloat(py_farm.rotor_diameters, device)
+        f.yaw_angles      = _to_kfloat(py_farm.yaw_angles, device)
         # tilt_angles: populated by set_tilt_to_ref_tilt() in the Python solver.
         # Fall back to ref_tilts (gives cos(tilt)/cos(ref_tilt) = 1) if unavailable.
         tilt = _get_tilt_angles(py_farm)
         if tilt is not None:
-            f.tilt_angles = _to_f32(tilt, device)
+            f.tilt_angles = _to_kfloat(tilt, device)
         f.n_turbines      = py_farm.n_turbines
         _build_turbine_tables(floris_cpp, f, py_farm, device)
         return f
@@ -339,9 +350,9 @@ class CppCore:
     def _make_cpp_flow_field(py_ff, device="cpu") -> object:
         floris_cpp = _get_floris_cpp()
         ff = floris_cpp.FlowField()
-        ff.wind_speeds            = _to_f32(py_ff.wind_speeds, device)
-        ff.wind_directions        = _to_f32(py_ff.wind_directions, device)
-        ff.turbulence_intensities = _to_f32(py_ff.turbulence_intensities, device)
+        ff.wind_speeds            = _to_kfloat(py_ff.wind_speeds, device)
+        ff.wind_directions        = _to_kfloat(py_ff.wind_directions, device)
+        ff.turbulence_intensities = _to_kfloat(py_ff.turbulence_intensities, device)
         ff.wind_shear             = float(py_ff.wind_shear)
         ff.wind_veer              = float(py_ff.wind_veer)
         ff.air_density            = float(py_ff.air_density)
@@ -353,9 +364,9 @@ class CppCore:
     def _make_cpp_grid(py_farm, py_ff, solver_dict: dict, device="cpu") -> object:
         floris_cpp = _get_floris_cpp()
         g = floris_cpp.TurbineGrid()
-        g.turbine_coordinates = _to_f32(py_farm.coordinates, device)
-        g.turbine_diameters   = _to_f32(py_farm.rotor_diameters, device)
-        g.wind_directions     = _to_f32(py_ff.wind_directions, device)
+        g.turbine_coordinates = _to_kfloat(py_farm.coordinates, device)
+        g.turbine_diameters   = _to_kfloat(py_farm.rotor_diameters, device)
+        g.wind_directions     = _to_kfloat(py_ff.wind_directions, device)
         g.grid_resolution     = int(solver_dict.get("turbine_grid_points", 3))
         g.n_turbines          = py_farm.n_turbines
         g.n_findex            = int(py_ff.n_findex)
@@ -402,24 +413,34 @@ class CppCore:
                 return  # User-injected differentiable tensor; preserve it.
             setattr(self._cpp_farm, attr, default_val)
 
+        # Determine the effective device: if the caller has injected a grad tensor
+        # on a different device (e.g. cuda:0 into a cpu-configured model), use
+        # that device for all tensors so everything is consistent.
+        _existing_lx = getattr(self._cpp_farm, 'layout_x', None)
+        if isinstance(_existing_lx, torch.Tensor) and _existing_lx.requires_grad:
+            device = _existing_lx.device
+            self._device = str(device)  # update self._device to match the grad tensor's device
+        else:
+            device = self._device
+
         # ---- sync farm ----
         # layout_x / layout_y / yaw_angles are preserved if the caller has
         # already injected a requires_grad tensor (common in autograd tests).
-        _preserve_if_grad('layout_x',  _to_f32(py_farm.layout_x, self._device))
-        _preserve_if_grad('layout_y',  _to_f32(py_farm.layout_y, self._device))
-        _preserve_if_grad('yaw_angles', _to_f32(py_farm.yaw_angles, self._device))
-        self._cpp_farm.hub_heights     = _to_f32(py_farm.hub_heights, self._device)
-        self._cpp_farm.rotor_diameters = _to_f32(py_farm.rotor_diameters, self._device)
+        _preserve_if_grad('layout_x',  _to_kfloat(py_farm.layout_x, device))
+        _preserve_if_grad('layout_y',  _to_kfloat(py_farm.layout_y, device))
+        _preserve_if_grad('yaw_angles', _to_kfloat(py_farm.yaw_angles, device))
+        self._cpp_farm.hub_heights     = _to_kfloat(py_farm.hub_heights, device)
+        self._cpp_farm.rotor_diameters = _to_kfloat(py_farm.rotor_diameters, device)
         tilt = _get_tilt_angles(py_farm)
         if tilt is not None:
-            self._cpp_farm.tilt_angles = _to_f32(tilt, self._device)
+            self._cpp_farm.tilt_angles = _to_kfloat(tilt, device)
         self._cpp_farm.n_turbines      = py_farm.n_turbines
 
         # ---- sync flow field ----
-        self._cpp_flow_field.wind_speeds            = _to_f32(py_ff.wind_speeds, self._device)
-        self._cpp_flow_field.wind_directions        = _to_f32(py_ff.wind_directions, self._device)
-        self._cpp_flow_field.turbulence_intensities = _to_f32(
-            py_ff.turbulence_intensities, self._device
+        self._cpp_flow_field.wind_speeds            = _to_kfloat(py_ff.wind_speeds, device)
+        self._cpp_flow_field.wind_directions        = _to_kfloat(py_ff.wind_directions, device)
+        self._cpp_flow_field.turbulence_intensities = _to_kfloat(
+            py_ff.turbulence_intensities, device
         )
         self._cpp_flow_field.wind_shear             = float(py_ff.wind_shear)
         self._cpp_flow_field.wind_veer              = float(py_ff.wind_veer)
@@ -438,15 +459,15 @@ class CppCore:
             isinstance(ly, torch.Tensor) and ly.requires_grad
         )
         if has_layout_grad:
-            hub_h = _to_f32(py_farm.hub_heights, self._device)  # [T], no grad
+            hub_h = _to_kfloat(py_farm.hub_heights, device)  # [T], no grad
             # torch.stack([T], [T], [T], dim=1) → [T, 3]
             self._cpp_grid.turbine_coordinates = torch.stack(
                 [lx.float(), ly.float(), hub_h], dim=1
             )
         else:
-            self._cpp_grid.turbine_coordinates = _to_f32(py_farm.coordinates, self._device)
-        self._cpp_grid.turbine_diameters   = _to_f32(py_farm.rotor_diameters, self._device)
-        self._cpp_grid.wind_directions     = _to_f32(py_ff.wind_directions, self._device)
+            self._cpp_grid.turbine_coordinates = _to_kfloat(py_farm.coordinates, device)
+        self._cpp_grid.turbine_diameters   = _to_kfloat(py_farm.rotor_diameters, device)
+        self._cpp_grid.wind_directions     = _to_kfloat(py_ff.wind_directions, device)
         self._cpp_grid.n_turbines          = py_farm.n_turbines
         self._cpp_grid.n_findex            = int(py_ff.n_findex)
 
@@ -522,15 +543,17 @@ class CppCore:
 
         u = self._u_sorted_tensor  # [F, T_sorted, nG, nG], may carry grad_fn
 
-        # Average velocity over rotor grid points → [F, T_sorted].
-        # Arithmetic mean (rather than cubic-mean) preserves grad_fn correctly.
-        u_avg = u.mean(dim=(2, 3))
+        # Cubic mean over rotor grid points → [F, T_sorted].
+        # pow(3) → mean → pow(1/3) are all differentiable ops; grad_fn is preserved.
+        # pow(1/3) gradient is undefined at exactly zero velocity, which cannot
+        # occur for physically valid wind conditions.
+        u_avg = u.pow(3).mean(dim=(2, 3)).pow(1 / 3)
 
         # Look up power from the first turbine type's power table using the
-        # registered differentiable interp1d op (Phase 6).
-        ptt = self._py_core.farm.turbine_power_thrust_tables
-        first_type = next(iter(ptt))
-        tbl = ptt[first_type]
+        # registered differentiable interp1d op.
+        power_thrust_table = self._py_core.farm.turbine_power_thrust_tables
+        first_type = next(iter(power_thrust_table))
+        tbl = power_thrust_table[first_type]
         dtype = u_avg.dtype
         device = u_avg.device
         ws_t = torch.tensor(
@@ -583,7 +606,7 @@ class CppCore:
         )
 
         # ── velocity field ──────────────────────────────────────────────────
-        # The Phase-2 C++ FlowField::finalize() is a stub: u = u_sorted
+        # The C++ FlowField::finalize() is a stub: u = u_sorted
         # (no spatial un-sorting is applied).  We apply the inverse permutation
         # here so that _get_turbine_powers() receives u in original turbine order.
         u_sorted_np = self._cpp_flow_field.u.detach().cpu().numpy()    # [fi, tu, ng, ng]
@@ -611,13 +634,13 @@ class CppCore:
         self._py_core.state = State.USED
 
     # ------------------------------------------------------------------
-    # Unsupported visualisation methods
+    # Unsupported visualization methods
     # ------------------------------------------------------------------
 
     def solve_for_viz(self, *args, **kwargs):
         raise NotImplementedError(
             "solve_for_viz is not supported by the C++ backend. "
-            "Use FlorisModel(backend='python') for flow-field visualisations."
+            "Use FlorisModel(backend='python') for flow-field visualization."
         )
 
     def solve_for_points(self, *args, **kwargs):
@@ -633,12 +656,12 @@ class CppCore:
         )
 
     # ------------------------------------------------------------------
-    # Serialisation
+    # Serialization
     # ------------------------------------------------------------------
 
     def as_dict(self) -> dict:
         """
-        Reverse-serialise state to the YAML dict schema.
+        Reverse-serialize state to the YAML dict schema.
 
         Delegates to ``_py_core.as_dict()`` so that ``FlorisModel._reinitialize()``
         can call ``Core.from_dict(self.core.as_dict())`` without changes.
@@ -675,7 +698,7 @@ class CppCore:
 
     @property
     def grid(self):
-        """Python Grid — used for visualisation helpers; C++ has its own grid."""
+        """Python Grid — used for visualization helpers; C++ has its own grid."""
         return self._py_core.grid
 
     @property

{rafmudaf_floris-4.6.4.post1.dev9 → rafmudaf_floris-4.6.4.post1.dev13}/rafmudaf_floris.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rafmudaf-floris
-Version: 4.6.4.post1.dev9
+Version: 4.6.4.post1.dev13
 Summary: A controls-oriented engineering wake model.
 Author-email: Rafael Mudafort <rafael@clementinescientific.com>
 License: BSD 3-Clause License