Merge pull request #1470 from boutproject/namespace_globals

Use namespace for global variables 'mesh' and 'dump'

include/boundary_region.hxx

@@ -8,7 +8,11 @@ class BoundaryRegion;
 #include <utility>
 
 class Mesh;
-extern Mesh* mesh;
+namespace bout {
+namespace globals {
+  extern Mesh* mesh; ///< Global mesh
+} // namespace bout
+} // namespace globals
 
 /// Location of boundary
 enum BndryLoc {BNDRY_XIN=1,
@@ -24,9 +28,9 @@ public:
 
   BoundaryRegionBase() = delete;
   BoundaryRegionBase(std::string name, Mesh *passmesh = nullptr)
-      : localmesh(passmesh ? passmesh : mesh), label(std::move(name)) {}
+      : localmesh(passmesh ? passmesh : bout::globals::mesh), label(std::move(name)) {}
   BoundaryRegionBase(std::string name, BndryLoc loc, Mesh *passmesh = nullptr)
-      : localmesh(passmesh ? passmesh : mesh), label(std::move(name)), location(loc) {}
+      : localmesh(passmesh ? passmesh : bout::globals::mesh), label(std::move(name)), location(loc) {}
 
   virtual ~BoundaryRegionBase() {}
 

include/bout.hxx

@@ -38,6 +38,7 @@
 
 #include "boutcomm.hxx"
 
+#include <bout/mesh.hxx>
 #include "globals.hxx"
 
 #include "field2d.hxx"
@@ -65,6 +66,13 @@
 
 const BoutReal BOUT_VERSION = BOUT_VERSION_DOUBLE;  ///< Version number
 
+#ifndef BOUT_NO_USING_NAMESPACE_BOUTGLOBALS
+// Include using statement by default in user code.
+// Macro allows us to include bout.hxx or physicsmodel.hxx without the using
+// statement in library code.
+using namespace bout::globals;
+#endif // BOUT_NO_USING_NAMESPACE_BOUTGLOBALS
+
 // BOUT++ main functions
 
 /*!

include/bout/fv_ops.hxx

@@ -10,6 +10,7 @@
 #include "../vector2d.hxx"
 
 #include "../utils.hxx"
+#include <bout/mesh.hxx>
 
 namespace FV {
   /*!
@@ -182,6 +183,10 @@ namespace FV {
 
     ASSERT2(f_in.getLocation() == v_in.getLocation());
 
+    Mesh* mesh = f_in.getMesh();
+    ASSERT1(mesh == v_in.getMesh());
+    ASSERT1(mesh == wave_speed.getMesh());
+
     CellEdges cellboundary;
 
     Field3D f = mesh->toFieldAligned(f_in);
@@ -341,6 +346,9 @@ namespace FV {
   const Field3D Div_f_v(const Field3D &n_in, const Vector3D &v, bool bndry_flux) {
     ASSERT2(n_in.getLocation() == v.getLocation());
 
+    Mesh* mesh = n_in.getMesh();
+    ASSERT1(mesh == v.x.getMesh());
+
     CellEdges cellboundary;
 
     Coordinates *coord = n_in.getCoordinates();

include/bout/invert/laplacexz.hxx

@@ -39,8 +39,8 @@
 class LaplaceXZ {
 public:
   LaplaceXZ(Mesh* m = nullptr, Options* UNUSED(options) = nullptr,
-      const CELL_LOC loc = CELL_CENTRE)
-    : localmesh(m==nullptr ? mesh : m), location(loc) {}
+            const CELL_LOC loc = CELL_CENTRE)
+      : localmesh(m == nullptr ? bout::globals::mesh : m), location(loc) {}
   virtual ~LaplaceXZ() {}
 
   virtual void setCoefs(const Field2D &A, const Field2D &B) = 0;

include/bout/invertable_operator.hxx

@@ -35,6 +35,7 @@ class InvertableOperator;
 
 #ifdef BOUT_HAS_PETSC
 
+#include <bout/mesh.hxx>
 #include <bout/sys/timer.hxx>
 #include <boutcomm.hxx>
 #include <boutexception.hxx>
@@ -133,7 +134,7 @@ public:
       : operatorFunction(func), preconditionerFunction(func),
         opt(optIn == nullptr ? optIn
                              : Options::getRoot()->getSection("invertableOperator")),
-        localmesh(localmeshIn == nullptr ? mesh : localmeshIn), doneSetup(false) {
+        localmesh(localmeshIn == nullptr ? bout::globals::mesh : localmeshIn), doneSetup(false) {
     AUTO_TRACE();
   };
 

include/bout/physicsmodel.hxx

@@ -43,6 +43,7 @@ class PhysicsModel;
 #include "solver.hxx"
 #include "unused.hxx"
 #include "bout/macro_for_each.hxx"
+
 /*!
   Base class for physics models
  */
@@ -310,7 +311,7 @@ private:
       solver->setModel(model);                        \
       Monitor * bout_monitor = new BoutMonitor();     \
       solver->addMonitor(bout_monitor, Solver::BACK); \
-      solver->outputVars(dump);                       \
+      solver->outputVars(bout::globals::dump);        \
       solver->solve();                                \
       delete model;                                   \
       delete solver;                                  \

include/bout/solver.hxx

@@ -71,7 +71,9 @@ typedef int (*TimestepMonitorFunc)(Solver *solver, BoutReal simtime, BoutReal la
 #include "vector2d.hxx"
 #include "vector3d.hxx"
 
+#define BOUT_NO_USING_NAMESPACE_BOUTGLOBALS
 #include "physicsmodel.hxx"
+#undef BOUT_NO_USING_NAMESPACE_BOUTGLOBALS
 
 #include <string>
 #include <list>
@@ -290,7 +292,7 @@ class Solver {
   ///
   /// @param[inout] outputfile   The file to add variable to
   /// @param[in] save_repeat    If true, add variables with time dimension
-  void outputVars(Datafile &outputfile, bool save_repeat=true);
+  virtual void outputVars(Datafile &outputfile, bool save_repeat=true);
 
   /*!
    * Create a Solver object. This uses the "type" option

include/datafile.hxx

@@ -15,17 +15,18 @@ class Datafile;
 #define __DATAFILE_H__
 
 #include "bout_types.hxx"
-#include "field2d.hxx"
-#include "field3d.hxx"
-#include "vector2d.hxx"
-#include "vector3d.hxx"
 #include "options.hxx"
 #include "bout/macro_for_each.hxx"
 
 #include "dataformat.hxx"
 
 #include <cstdarg>
 #include <cstdio>
+class Mesh;
+class Field2D;
+class Field3D;
+class Vector2D;
+class Vector3D;
 
 #include <vector>
 #include <string>
@@ -37,7 +38,7 @@ class Datafile;
 */
 class Datafile {
  public:
-  Datafile(Options *opt = nullptr);
+  Datafile(Options *opt = nullptr, Mesh* mesh_in = nullptr);
   Datafile(Datafile &&other) noexcept;
   ~Datafile(); // need to delete filename
 
@@ -78,6 +79,7 @@ class Datafile {
   void setAttribute(const std::string &varname, const std::string &attrname, BoutReal value);
 
  private:
+  Mesh* mesh;
   bool parallel; // Use parallel formats?
   bool flush;    // Flush after every write?
   bool guards;   // Write guard cells?
@@ -137,63 +139,63 @@ class Datafile {
 };
 
 /// Write this variable once to the grid file
-#define SAVE_ONCE1(var) dump.add(var, #var, 0);
+#define SAVE_ONCE1(var) bout::globals::dump.add(var, #var, 0);
 #define SAVE_ONCE2(var1, var2) { \
-    dump.add(var1, #var1, 0); \
-    dump.add(var2, #var2, 0);}
+  bout::globals::dump.add(var1, #var1, 0); \
+  bout::globals::dump.add(var2, #var2, 0);}
 #define SAVE_ONCE3(var1, var2, var3) {\
-    dump.add(var1, #var1, 0); \
-    dump.add(var2, #var2, 0); \
-    dump.add(var3, #var3, 0);}
+  bout::globals::dump.add(var1, #var1, 0); \
+  bout::globals::dump.add(var2, #var2, 0); \
+  bout::globals::dump.add(var3, #var3, 0);}
 #define SAVE_ONCE4(var1, var2, var3, var4) { \
-    dump.add(var1, #var1, 0); \
-    dump.add(var2, #var2, 0); \
-    dump.add(var3, #var3, 0); \
-    dump.add(var4, #var4, 0);}
+  bout::globals::dump.add(var1, #var1, 0); \
+  bout::globals::dump.add(var2, #var2, 0); \
+  bout::globals::dump.add(var3, #var3, 0); \
+  bout::globals::dump.add(var4, #var4, 0);}
 #define SAVE_ONCE5(var1, var2, var3, var4, var5) {\
-    dump.add(var1, #var1, 0); \
-    dump.add(var2, #var2, 0); \
-    dump.add(var3, #var3, 0); \
-    dump.add(var4, #var4, 0); \
-    dump.add(var5, #var5, 0);}
+  bout::globals::dump.add(var1, #var1, 0); \
+  bout::globals::dump.add(var2, #var2, 0); \
+  bout::globals::dump.add(var3, #var3, 0); \
+  bout::globals::dump.add(var4, #var4, 0); \
+  bout::globals::dump.add(var5, #var5, 0);}
 #define SAVE_ONCE6(var1, var2, var3, var4, var5, var6) {\
-    dump.add(var1, #var1, 0); \
-    dump.add(var2, #var2, 0); \
-    dump.add(var3, #var3, 0); \
-    dump.add(var4, #var4, 0); \
-    dump.add(var5, #var5, 0); \
-    dump.add(var6, #var6, 0);}
+  bout::globals::dump.add(var1, #var1, 0); \
+  bout::globals::dump.add(var2, #var2, 0); \
+  bout::globals::dump.add(var3, #var3, 0); \
+  bout::globals::dump.add(var4, #var4, 0); \
+  bout::globals::dump.add(var5, #var5, 0); \
+  bout::globals::dump.add(var6, #var6, 0);}
 
 #define SAVE_ONCE(...)                          \
   { MACRO_FOR_EACH(SAVE_ONCE1, __VA_ARGS__) }
 
 /// Write this variable every timestep
-#define SAVE_REPEAT1(var) dump.add(var, #var, 1);
+#define SAVE_REPEAT1(var) bout::globals::dump.add(var, #var, 1);
 #define SAVE_REPEAT2(var1, var2) { \
-    dump.add(var1, #var1, 1); \
-    dump.add(var2, #var2, 1);}
+  bout::globals::dump.add(var1, #var1, 1); \
+  bout::globals::dump.add(var2, #var2, 1);}
 #define SAVE_REPEAT3(var1, var2, var3) {\
-    dump.add(var1, #var1, 1); \
-    dump.add(var2, #var2, 1); \
-    dump.add(var3, #var3, 1);}
+  bout::globals::dump.add(var1, #var1, 1); \
+  bout::globals::dump.add(var2, #var2, 1); \
+  bout::globals::dump.add(var3, #var3, 1);}
 #define SAVE_REPEAT4(var1, var2, var3, var4) { \
-    dump.add(var1, #var1, 1); \
-    dump.add(var2, #var2, 1); \
-    dump.add(var3, #var3, 1); \
-    dump.add(var4, #var4, 1);}
+  bout::globals::dump.add(var1, #var1, 1); \
+  bout::globals::dump.add(var2, #var2, 1); \
+  bout::globals::dump.add(var3, #var3, 1); \
+  bout::globals::dump.add(var4, #var4, 1);}
 #define SAVE_REPEAT5(var1, var2, var3, var4, var5) {\
-    dump.add(var1, #var1, 1); \
-    dump.add(var2, #var2, 1); \
-    dump.add(var3, #var3, 1); \
-    dump.add(var4, #var4, 1); \
-    dump.add(var5, #var5, 1);}
+  bout::globals::dump.add(var1, #var1, 1); \
+  bout::globals::dump.add(var2, #var2, 1); \
+  bout::globals::dump.add(var3, #var3, 1); \
+  bout::globals::dump.add(var4, #var4, 1); \
+  bout::globals::dump.add(var5, #var5, 1);}
 #define SAVE_REPEAT6(var1, var2, var3, var4, var5, var6) {\
-    dump.add(var1, #var1, 1); \
-    dump.add(var2, #var2, 1); \
-    dump.add(var3, #var3, 1); \
-    dump.add(var4, #var4, 1); \
-    dump.add(var5, #var5, 1); \
-    dump.add(var6, #var6, 1);}
+  bout::globals::dump.add(var1, #var1, 1); \
+  bout::globals::dump.add(var2, #var2, 1); \
+  bout::globals::dump.add(var3, #var3, 1); \
+  bout::globals::dump.add(var4, #var4, 1); \
+  bout::globals::dump.add(var5, #var5, 1); \
+  bout::globals::dump.add(var6, #var6, 1);}
 
 #define SAVE_REPEAT(...)                        \
   { MACRO_FOR_EACH(SAVE_REPEAT1, __VA_ARGS__) }

include/dataformat.hxx

@@ -40,9 +40,12 @@ class DataFormat;
 #include <memory>
 #include <vector>
 
+class Mesh;
+
 // Can't copy, to control access to file
 class DataFormat {
  public:
+  DataFormat(Mesh* mesh_in = nullptr);
   virtual ~DataFormat() { }
   // File opening routines
   virtual bool openr(const char *name) = 0;
@@ -195,6 +198,9 @@ class DataFormat {
   /// -------
   /// value                  A BoutReal attribute of the variable
   virtual bool getAttribute(const std::string &varname, const std::string &attrname, BoutReal &value) = 0;
+
+ protected:
+  Mesh* mesh;
 };
 
 // For backwards compatability. In formatfactory.cxx

include/field.hxx

@@ -33,6 +33,7 @@ class Field;
 
 #include "bout_types.hxx"
 #include "boutexception.hxx"
+#include <globals.hxx>
 #include "msg_stack.hxx"
 #include "stencils.hxx"
 #include <bout/rvec.hxx>
@@ -41,7 +42,6 @@ class Field;
 
 class Mesh;
 class Coordinates;
-extern Mesh * mesh; ///< Global mesh
 
 #ifdef TRACK
 #include <string>
@@ -94,7 +94,7 @@ class Field {
     if (fieldmesh){
       return fieldmesh;
     } else {
-      return mesh;
+      return bout::globals::mesh;
     }
   }
 

include/globals.hxx

@@ -27,10 +27,13 @@
 #ifndef __GLOBALS_H__
 #define __GLOBALS_H__
 
-#include "bout/mesh.hxx"
 #include "datafile.hxx"
 #include "bout/macro_for_each.hxx"
 
+class Mesh;
+
+namespace bout {
+namespace globals {
 #ifndef GLOBALORIGIN
 #define GLOBAL extern
 #define SETTING(name, val) extern name
@@ -83,5 +86,7 @@ GLOBAL Datafile dump;
 
 #undef GLOBAL
 #undef SETTING
+} // namespace globals
+} // namespace bout
 
 #endif // __GLOBALS_H__

include/interpolation.hxx

@@ -243,7 +243,7 @@ protected:
 
 public:
   Interpolation(int y_offset = 0, Mesh* localmeshIn = nullptr)
-      : localmesh(localmeshIn == nullptr ? mesh : localmeshIn),
+      : localmesh(localmeshIn == nullptr ? bout::globals::mesh : localmeshIn),
         skip_mask(*localmesh, false), y_offset(y_offset) {}
   Interpolation(const BoutMask &mask, int y_offset = 0, Mesh *mesh = nullptr)
       : Interpolation(y_offset, mesh) {

include/invert_laplace.hxx

@@ -105,7 +105,7 @@ const int INVERT_OUT_RHS = 32768; ///< Use input value in RHS at outer boundary
 /// Base class for Laplacian inversion
 class Laplacian {
 public:
-  Laplacian(Options *options = nullptr, const CELL_LOC loc = CELL_CENTRE, Mesh* mesh_in = mesh);
+  Laplacian(Options *options = nullptr, const CELL_LOC loc = CELL_CENTRE, Mesh* mesh_in = nullptr);
   virtual ~Laplacian() {}
 
   /// Set coefficients for inversion. Re-builds matrices if necessary
@@ -192,7 +192,7 @@ public:
    * 
    * @param[in] opt  The options section to use. By default "laplace" will be used
    */
-  static Laplacian *create(Options *opt = nullptr, const CELL_LOC loc = CELL_CENTRE, Mesh *mesh_in = mesh);
+  static Laplacian *create(Options *opt = nullptr, const CELL_LOC loc = CELL_CENTRE, Mesh *mesh_in = nullptr);
   static Laplacian* defaultInstance(); ///< Return pointer to global singleton
 
   static void cleanup(); ///< Frees all memory