Fix FourierCoeffs copy/move span rebinding

src/vmecpp/cpp/vmecpp/vmec/fourier_coefficients/fourier_coefficients.cc

@@ -6,6 +6,7 @@
 
 #include <algorithm>
 #include <iostream>
+#include <utility>
 #include <vector>
 
 #include "absl/algorithm/container.h"
@@ -45,6 +46,42 @@ FourierCoeffs::FourierCoeffs(const Sizes* s, const RadialPartitioning* r,
   }
 }
 
+FourierCoeffs& FourierCoeffs::operator=(const FourierCoeffs& other) {
+  if (this != &other) {
+    rcc = other.rcc;
+    rss = other.rss;
+    rsc = other.rsc;
+    rcs = other.rcs;
+    zsc = other.zsc;
+    zcs = other.zcs;
+    zcc = other.zcc;
+    zss = other.zss;
+    lsc = other.lsc;
+    lcs = other.lcs;
+    lcc = other.lcc;
+    lss = other.lss;
+  }
+  return *this;
+}
+
+FourierCoeffs& FourierCoeffs::operator=(FourierCoeffs&& other) noexcept {
+  if (this != &other) {
+    rcc = std::move(other.rcc);
+    rss = std::move(other.rss);
+    rsc = std::move(other.rsc);
+    rcs = std::move(other.rcs);
+    zsc = std::move(other.zsc);
+    zcs = std::move(other.zcs);
+    zcc = std::move(other.zcc);
+    zss = std::move(other.zss);
+    lsc = std::move(other.lsc);
+    lcs = std::move(other.lcs);
+    lcc = std::move(other.lcc);
+    lss = std::move(other.lss);
+  }
+  return *this;
+}
+
 int FourierCoeffs::nsMin() const { return nsMin_; }
 
 int FourierCoeffs::nsMax() const { return nsMax_; }

src/vmecpp/cpp/vmecpp/vmec/fourier_coefficients/fourier_coefficients.h

@@ -19,6 +19,10 @@ class FourierCoeffs {
  public:
   FourierCoeffs(const Sizes* s, const RadialPartitioning* r, int nsMin,
                 int nsMax, int ns);
+  FourierCoeffs(const FourierCoeffs& other) = default;
+  FourierCoeffs(FourierCoeffs&& other) noexcept = default;
+  FourierCoeffs& operator=(const FourierCoeffs& other);
+  FourierCoeffs& operator=(FourierCoeffs&& other) noexcept;
 
   void setZero();
 

src/vmecpp/cpp/vmecpp/vmec/fourier_forces/fourier_forces.cc

@@ -5,6 +5,7 @@
 #include "vmecpp/vmec/fourier_forces/fourier_forces.h"
 
 #include <algorithm>
+#include <utility>
 #include <vector>
 
 namespace vmecpp {
@@ -25,6 +26,67 @@ FourierForces::FourierForces(const Sizes* s, const RadialPartitioning* r,
       flcc(lcc),
       flss(lss) {}
 
+FourierForces::FourierForces(const FourierForces& other)
+    : FourierCoeffs(other),
+      frcc(rcc),
+      frss(rss),
+      frsc(rsc),
+      frcs(rcs),
+      fzsc(zsc),
+      fzcs(zcs),
+      fzcc(zcc),
+      fzss(zss),
+      flsc(lsc),
+      flcs(lcs),
+      flcc(lcc),
+      flss(lss) {}
+
+void FourierForces::BindSpans() {
+  frcc = rcc;
+  frss = rss;
+  frsc = rsc;
+  frcs = rcs;
+  fzsc = zsc;
+  fzcs = zcs;
+  fzcc = zcc;
+  fzss = zss;
+  flsc = lsc;
+  flcs = lcs;
+  flcc = lcc;
+  flss = lss;
+}
+
+FourierForces& FourierForces::operator=(const FourierForces& other) {
+  if (this != &other) {
+    FourierCoeffs::operator=(other);
+    BindSpans();
+  }
+  return *this;
+}
+
+FourierForces::FourierForces(FourierForces&& other) noexcept
+    : FourierCoeffs(std::move(other)),
+      frcc(rcc),
+      frss(rss),
+      frsc(rsc),
+      frcs(rcs),
+      fzsc(zsc),
+      fzcs(zcs),
+      fzcc(zcc),
+      fzss(zss),
+      flsc(lsc),
+      flcs(lcs),
+      flcc(lcc),
+      flss(lss) {}
+
+FourierForces& FourierForces::operator=(FourierForces&& other) noexcept {
+  if (this != &other) {
+    FourierCoeffs::operator=(std::move(other));
+    BindSpans();
+  }
+  return *this;
+}
+
 void FourierForces::zeroZForceForM1() {
   for (int jF = nsMin_; jF < nsMax_; ++jF) {
     for (int n = 0; n < s_.ntor + 1; ++n) {

src/vmecpp/cpp/vmecpp/vmec/fourier_forces/fourier_forces.h

@@ -15,6 +15,10 @@ namespace vmecpp {
 class FourierForces : public FourierCoeffs {
  public:
   FourierForces(const Sizes* s, const RadialPartitioning* r, int ns);
+  FourierForces(const FourierForces& other);
+  FourierForces& operator=(const FourierForces& other);
+  FourierForces(FourierForces&& other) noexcept;
+  FourierForces& operator=(FourierForces&& other) noexcept;
 
   void zeroZForceForM1();
   void residuals(std::vector<double>& fRes, bool includeEdgeRZ) const;
@@ -34,6 +38,9 @@ class FourierForces : public FourierCoeffs {
   std::span<double> flcs;
   std::span<double> flcc;
   std::span<double> flss;
+
+ private:
+  void BindSpans();
 };
 
 }  // namespace vmecpp

src/vmecpp/cpp/vmecpp/vmec/fourier_geometry/fourier_geometry.cc

@@ -5,6 +5,7 @@
 #include "vmecpp/vmec/fourier_geometry/fourier_geometry.h"
 
 #include <algorithm>
+#include <utility>
 #include <vector>
 
 #include "vmecpp/common/util/util.h"
@@ -29,6 +30,71 @@ FourierGeometry::FourierGeometry(const Sizes* s, const RadialPartitioning* r,
       lmncc(lcc),
       lmnss(lss) {}
 
+FourierGeometry::FourierGeometry(const FourierGeometry& other)
+    : FourierCoeffs(other),
+      rmncc(rcc),
+      rmnss(rss),
+      rmnsc(rsc),
+      rmncs(rcs),
+
+      zmnsc(zsc),
+      zmncs(zcs),
+      zmncc(zcc),
+      zmnss(zss),
+
+      lmnsc(lsc),
+      lmncs(lcs),
+      lmncc(lcc),
+      lmnss(lss) {}
+
+void FourierGeometry::BindSpans() {
+  rmncc = rcc;
+  rmnss = rss;
+  rmnsc = rsc;
+  rmncs = rcs;
+  zmnsc = zsc;
+  zmncs = zcs;
+  zmncc = zcc;
+  zmnss = zss;
+  lmnsc = lsc;
+  lmncs = lcs;
+  lmncc = lcc;
+  lmnss = lss;
+}
+
+FourierGeometry& FourierGeometry::operator=(const FourierGeometry& other) {
+  if (this != &other) {
+    FourierCoeffs::operator=(other);
+    BindSpans();
+  }
+  return *this;
+}
+
+FourierGeometry::FourierGeometry(FourierGeometry&& other) noexcept
+    : FourierCoeffs(std::move(other)),
+      rmncc(rcc),
+      rmnss(rss),
+      rmnsc(rsc),
+      rmncs(rcs),
+
+      zmnsc(zsc),
+      zmncs(zcs),
+      zmncc(zcc),
+      zmnss(zss),
+
+      lmnsc(lsc),
+      lmncs(lcs),
+      lmncc(lcc),
+      lmnss(lss) {}
+
+FourierGeometry& FourierGeometry::operator=(FourierGeometry&& other) noexcept {
+  if (this != &other) {
+    FourierCoeffs::operator=(std::move(other));
+    BindSpans();
+  }
+  return *this;
+}
+
 void FourierGeometry::interpFromBoundaryAndAxis(
     const FourierBasisFastPoloidal& t, const Boundaries& b,
     const RadialProfiles& p) {

src/vmecpp/cpp/vmecpp/vmec/fourier_geometry/fourier_geometry.h

@@ -18,6 +18,10 @@ namespace vmecpp {
 class FourierGeometry : public FourierCoeffs {
  public:
   FourierGeometry(const Sizes *s, const RadialPartitioning *r, int ns);
+  FourierGeometry(const FourierGeometry &other);
+  FourierGeometry &operator=(const FourierGeometry &other);
+  FourierGeometry(FourierGeometry &&other) noexcept;
+  FourierGeometry &operator=(FourierGeometry &&other) noexcept;
 
   void interpFromBoundaryAndAxis(const FourierBasisFastPoloidal &t,
                                  const Boundaries &b, const RadialProfiles &p);
@@ -87,6 +91,9 @@ class FourierGeometry : public FourierCoeffs {
 
   // contrib to lambda ~ sin(m * theta) * sin(n * zeta)
   std::span<double> lmnss;
+
+ private:
+  void BindSpans();
 };
 
 }  // namespace vmecpp

src/vmecpp/cpp/vmecpp/vmec/fourier_velocity/fourier_velocity.cc

@@ -4,6 +4,8 @@
 // SPDX-License-Identifier: MIT
 #include "vmecpp/vmec/fourier_velocity/fourier_velocity.h"
 
+#include <utility>
+
 namespace vmecpp {
 
 FourierVelocity::FourierVelocity(const Sizes* s, const RadialPartitioning* r,
@@ -22,4 +24,65 @@ FourierVelocity::FourierVelocity(const Sizes* s, const RadialPartitioning* r,
       vlcc(lcc),
       vlss(lss) {}
 
+FourierVelocity::FourierVelocity(const FourierVelocity& other)
+    : FourierCoeffs(other),
+      vrcc(rcc),
+      vrss(rss),
+      vrsc(rsc),
+      vrcs(rcs),
+      vzsc(zsc),
+      vzcs(zcs),
+      vzcc(zcc),
+      vzss(zss),
+      vlsc(lsc),
+      vlcs(lcs),
+      vlcc(lcc),
+      vlss(lss) {}
+
+void FourierVelocity::BindSpans() {
+  vrcc = rcc;
+  vrss = rss;
+  vrsc = rsc;
+  vrcs = rcs;
+  vzsc = zsc;
+  vzcs = zcs;
+  vzcc = zcc;
+  vzss = zss;
+  vlsc = lsc;
+  vlcs = lcs;
+  vlcc = lcc;
+  vlss = lss;
+}
+
+FourierVelocity& FourierVelocity::operator=(const FourierVelocity& other) {
+  if (this != &other) {
+    FourierCoeffs::operator=(other);
+    BindSpans();
+  }
+  return *this;
+}
+
+FourierVelocity::FourierVelocity(FourierVelocity&& other) noexcept
+    : FourierCoeffs(std::move(other)),
+      vrcc(rcc),
+      vrss(rss),
+      vrsc(rsc),
+      vrcs(rcs),
+      vzsc(zsc),
+      vzcs(zcs),
+      vzcc(zcc),
+      vzss(zss),
+      vlsc(lsc),
+      vlcs(lcs),
+      vlcc(lcc),
+      vlss(lss) {}
+
+FourierVelocity& FourierVelocity::operator=(FourierVelocity&& other) noexcept {
+  if (this != &other) {
+    FourierCoeffs::operator=(std::move(other));
+    BindSpans();
+  }
+  return *this;
+}
+
 }  // namespace vmecpp

src/vmecpp/cpp/vmecpp/vmec/fourier_velocity/fourier_velocity.h

@@ -14,6 +14,10 @@ namespace vmecpp {
 class FourierVelocity : public FourierCoeffs {
  public:
   FourierVelocity(const Sizes* s, const RadialPartitioning* r, int ns);
+  FourierVelocity(const FourierVelocity& other);
+  FourierVelocity& operator=(const FourierVelocity& other);
+  FourierVelocity(FourierVelocity&& other) noexcept;
+  FourierVelocity& operator=(FourierVelocity&& other) noexcept;
 
   // appropriately-named variables for the data in FourierCoeffs
   std::span<double> vrcc;
@@ -30,6 +34,9 @@ class FourierVelocity : public FourierCoeffs {
   std::span<double> vlcs;
   std::span<double> vlcc;
   std::span<double> vlss;
+
+ private:
+  void BindSpans();
 };
 
 }  // namespace vmecpp

src/vmecpp/simsopt_compat.py

@@ -452,7 +452,12 @@ def set_indata(self) -> None:
         vi = self.indata  # Shorthand
         # Convert boundary to RZFourier if needed:
         boundary_RZFourier = self.boundary.to_RZFourier()
-        boundary_RZFourier.change_resolution(self.indata.mpol, self.indata.ntor)
+        updated_boundary = boundary_RZFourier.change_resolution(
+            self.indata.mpol, self.indata.ntor
+        )
+        if updated_boundary is not None:
+            boundary_RZFourier = updated_boundary
+            self.boundary = updated_boundary
         vi.rbc.fill(0.0)
         vi.zbs.fill(0.0)
 
@@ -521,7 +526,11 @@ def set_mpol_ntor(self, new_mpol: int, new_ntor: int):
         # NOTE: SurfaceRZFourier uses m up to mpol _inclusive_,
         # differently from VMEC++, so have to manually reduce the range by one.
         mpol_for_surfacerzfourier = new_mpol - 1
-        self.boundary.change_resolution(mpol_for_surfacerzfourier, new_ntor)
+        updated_boundary = self.boundary.change_resolution(
+            mpol_for_surfacerzfourier, new_ntor
+        )
+        if updated_boundary is not None:
+            self.boundary = updated_boundary
         self.recompute_bell()