Ensure grid spacings, Bxy, J, are always communicated

Author: ZedThree

include/bout/coordinates.hxx

@@ -108,9 +108,9 @@ public:
   const BoutReal& J(int x, int y) const { return J()(x, y); }
 #endif
 
-  void setDx(FieldMetric dx) { dx_ = std::move(dx); }
-  void setDy(FieldMetric dy) { dy_ = std::move(dy); }
-  void setDz(FieldMetric dz) { dz_ = std::move(dz); }
+  void setDx(FieldMetric dx);
+  void setDy(FieldMetric dy);
+  void setDz(FieldMetric dz);
 
   void setD1_dx(FieldMetric d1_dx) { d1_dx_ = std::move(d1_dx); }
   void setD1_dy(FieldMetric d1_dy) { d1_dy_ = std::move(d1_dy); }

src/mesh/coordinates.cxx

@@ -567,6 +567,10 @@ void Coordinates::readFromMesh(Options* mesh_options, const std::string& suffix)
   dy_ = interpolateAndExtrapolate(dy_, location, extrapolate_x, extrapolate_y, false,
                                   transform.get());
 
+  setDx(dx_);
+  setDy(dy_);
+  setDz(dz_);
+
   // grid data source has staggered fields, so read instead of interpolating
   // Diagonal components of metric tensor g^{ij} (default to 1)
   const auto g11 = getAtLocOrUnaligned(localmesh, "g11", 1.0, suffix, location);
@@ -758,27 +762,39 @@ const Field2D& Coordinates::zlength() const {
   return *zlength_cache;
 }
 
-int Coordinates::communicateAndCheckMeshSpacing() {
-  TRACE("Coordinates::communicateAndCheckMeshSpacing");
-
-  localmesh->communicate(dx_, dy_, dz_, Bxy_, J());
-  covariantMetricTensor.communicate(localmesh);
-  contravariantMetricTensor.communicate(localmesh);
-
-  output_progress.write("Calculating differential geometry terms\n");
-
-  if (min(abs(dx())) < 1e-8) {
+void Coordinates::setDx(FieldMetric dx) {
+  if (min(abs(dx)) < 1e-8) {
     throw BoutException("dx magnitude less than 1e-8");
   }
 
-  if (min(abs(dy())) < 1e-8) {
+  dx_ = std::move(dx);
+  localmesh->communicate(dx_);
+}
+
+void Coordinates::setDy(FieldMetric dy) {
+  if (min(abs(dy)) < 1e-8) {
     throw BoutException("dy magnitude less than 1e-8");
   }
 
-  if (min(abs(dz())) < 1e-8) {
+  dy_ = std::move(dy);
+  localmesh->communicate(dy_);
+}
+
+void Coordinates::setDz(FieldMetric dz) {
+  if (min(abs(dz)) < 1e-8) {
     throw BoutException("dz magnitude less than 1e-8");
   }
 
+  dz_ = std::move(dz);
+  localmesh->communicate(dz_);
+}
+
+int Coordinates::communicateAndCheckMeshSpacing() {
+  TRACE("Coordinates::communicateAndCheckMeshSpacing");
+
+  covariantMetricTensor.communicate(localmesh);
+  contravariantMetricTensor.communicate(localmesh);
+
   return 0;
 }
 
@@ -1503,21 +1519,24 @@ void Coordinates::checkContravariant() {
 FieldMetric& Coordinates::J() const {
   if (jacobian_cache == nullptr) {
     const auto j = recalculateJacobian();
-    auto ptr = std::make_unique<FieldMetric>(j);
-    jacobian_cache = std::move(ptr);
+    jacobian_cache = std::make_unique<FieldMetric>(j);
   }
   return *jacobian_cache;
 }
 
 void Coordinates::setJ(const FieldMetric& J) {
+  bout::checkFinite(J, "J", "RGN_NOCORNERS");
+  bout::checkPositive(J, "J", "RGN_NOCORNERS");
+
   //TODO: Calculate J and check value is close
-  auto ptr = std::make_unique<FieldMetric>(J);
-  jacobian_cache = std::move(ptr);
+  jacobian_cache = std::make_unique<FieldMetric>(J);
+  localmesh->communicate(*jacobian_cache);
 }
 
 void Coordinates::setBxy(FieldMetric Bxy) {
   //TODO: Calculate Bxy and check value is close
   Bxy_ = std::move(Bxy);
+  localmesh->communicate(Bxy_);
 }
 
 void Coordinates::setContravariantMetricTensor(

tests/unit/mesh/test_coordinates.cxx

@@ -231,12 +231,9 @@ TEST_F(CoordinatesTest, SmallMeshSpacing) {
   static_cast<FakeMesh*>(bout::globals::mesh)
       ->setGridDataSource(new FakeGridDataSource({{"dx", 1e-9}}));
 
-  output_info.disable();
-  output_warn.disable();
-  Coordinates coords(mesh);
-  EXPECT_THROW(coords.communicateAndCheckMeshSpacing(), BoutException);
-  output_warn.enable();
-  output_info.enable();
+  WithQuietOutput quiet_info{output_info};
+  WithQuietOutput quiet_warn{output_warn};
+  EXPECT_THROW(Coordinates{mesh}, BoutException);
 }
 
 TEST_F(CoordinatesTest, ConstructWithDiagonalContravariantMetric) {

tools/pylib/_boutpp_build/boutcpp.pxd.jinja

@@ -78,7 +78,6 @@ cdef extern from "bout/coordinates.hxx":
         {{ metric_field }} G1, G2, G3
         {{ metric_field }} ShiftTorsion
         {{ metric_field }} IntShiftTorsion
-        int communicateAndCheckMeshSpacing()
 
 cdef extern from "bout/fieldgroup.hxx":
     cppclass FieldGroup:

tools/pylib/_boutpp_build/helper.cxx.jinja

@@ -173,5 +173,4 @@ void c_mesh_normalise(Mesh * msh, double norm){
   coord->setDx(coord->dx() / norm);
   coord->setDy(coord->dy() / norm);
   coord->setDz(coord->dz() / norm);
-  coord->communicateAndCheckMeshSpacing();
 }