[Cleanup] Turn MyGeometry into a namespace

src/sliding-block-data/mybody.hh

@@ -17,13 +17,13 @@ template <int dimension> class MyBody : public Body<dimension> {
       Dune::FieldVector<double, dimension>, Dune::FieldVector<double, 1>>;
 
 public:
-  MyBody(Dune::ParameterTree const &parset, MyGeometry const &mygeometry)
+  MyBody(Dune::ParameterTree const &parset)
       : poissonRatio_(parset.get<double>("body.poissonRatio")),
         youngModulus_(parset.get<double>("body.youngModulus")),
         shearViscosityField_(parset.get<double>("body.shearViscosity")),
         bulkViscosityField_(parset.get<double>("body.bulkViscosity")),
         densityField_(parset.get<double>("body.density")),
-        gravityField_(densityField_, mygeometry.zenith,
+        gravityField_(densityField_, MyGeometry::zenith,
                       parset.get<double>("gravity")) {}
 
   double getPoissonRatio() const override { return poissonRatio_; }

src/sliding-block-data/mygeometry.hh

@@ -4,23 +4,24 @@
 #include <dune/common/fassign.hh>
 #include <dune/common/fvector.hh>
 
-// kludge because fieldvectors have no initialiser_list constructor,see
-// https://dune-project.org/flyspray/index.php?do=details&task_id=1166
-Dune::FieldVector<double, 2> generateVector(double x, double y) {
-  Dune::FieldVector<double, 2> tmp;
-  tmp <<= x, y;
-  return tmp;
-}
-
-struct MyGeometry {
-  MyGeometry() {}
+namespace MyGeometry {
+namespace {
+  using LocalVector = Dune::FieldVector<double, 2>;
 
-  Dune::FieldVector<double, 2> A = generateVector(0, 0);
-  Dune::FieldVector<double, 2> B = generateVector(5, 0);
-  Dune::FieldVector<double, 2> C = generateVector(5, 1);
-  Dune::FieldVector<double, 2> D = generateVector(0, 1);
+  // kludge because fieldvectors have no initialiser_list constructor, see
+  // https://dune-project.org/flyspray/index.php?do=details&task_id=1166
+  LocalVector generateVector(double x, double y) {
+    LocalVector tmp;
+    tmp <<= x, y;
+    return tmp;
+  }
+}
 
-  Dune::FieldVector<double, 2> zenith = generateVector(0, 1);
-};
+LocalVector const A = generateVector(0, 0);
+LocalVector const B = generateVector(5, 0);
+LocalVector const C = generateVector(5, 1);
+LocalVector const D = generateVector(0, 1);
 
+LocalVector const zenith = generateVector(0, 1);
+}
 #endif

src/sliding-block-data/myglobalfrictiondata.hh

@@ -16,7 +16,7 @@ class MyGlobalFrictionData : public GlobalFrictionData<dimension> {
   using typename GlobalFrictionData<dimension>::VirtualFunction;
 
 public:
-  MyGlobalFrictionData(Dune::ParameterTree const &parset, MyGeometry const &tri)
+  MyGlobalFrictionData(Dune::ParameterTree const &parset)
       : C_(parset.get<double>("C")),
         L_(parset.get<double>("L")),
         V0_(parset.get<double>("V0")),
@@ -42,5 +42,4 @@ class MyGlobalFrictionData : public GlobalFrictionData<dimension> {
   MyConstantFunction const b_;
   double const mu0_;
 };
-
 #endif

src/sliding-block-data/mygrid.hh

@@ -7,28 +7,26 @@
 
 #include "mygeometry.hh"
 
-template <class Grid>
-std::shared_ptr<Grid> constructGrid(MyGeometry const &myGeometry) {
+template <class Grid> std::shared_ptr<Grid> constructGrid() {
   std::array<unsigned int, 2> elements = { { 5, 1 } };
   return Dune::StructuredGridFactory<Grid>::createSimplexGrid(
-      myGeometry.A, myGeometry.C, elements);
+      MyGeometry::A, MyGeometry::C, elements);
 }
 
-template <class GridView, class MyGeometry> class MyFaces {
+template <class GridView> class MyFaces {
 private:
   bool isClose(double a, double b) {
     return std::abs(a - b) < 1e-14;
   };
 
 public:
-  MyFaces(GridView const &gridView, MyGeometry const &myGeometry)
-      : lower(gridView), upper(gridView) {
+  MyFaces(GridView const &gridView) : lower(gridView), upper(gridView) {
     lower.insertFacesByProperty([&](typename GridView::Intersection const &in) {
-      return isClose(myGeometry.A[1], in.geometry().center()[1]);
+      return isClose(MyGeometry::A[1], in.geometry().center()[1]);
     });
 
     upper.insertFacesByProperty([&](typename GridView::Intersection const &in) {
-      return isClose(myGeometry.C[1], in.geometry().center()[1]);
+      return isClose(MyGeometry::C[1], in.geometry().center()[1]);
     });
   }
 

src/sliding-block.cc

@@ -97,11 +97,9 @@ int main(int argc, char *argv[]) {
     Dune::ParameterTreeParser::readINITree(datadir "/parset.cfg", parset);
     Dune::ParameterTreeParser::readOptions(argc, argv, parset);
 
-    MyGeometry const myGeometry;
-
     // {{{ Set up grid
     using Grid = Dune::ALUGrid<dims, dims, Dune::simplex, Dune::nonconforming>;
-    auto grid = constructGrid<Grid>(myGeometry); // FIXME
+    auto grid = constructGrid<Grid>();
 
     auto const refinements = parset.get<size_t>("grid.refinements");
     grid->globalRefine(refinements);
@@ -112,7 +110,7 @@ int main(int argc, char *argv[]) {
     // }}}
 
     // Set up myFaces
-    MyFaces<GridView, MyGeometry> myFaces(leafView, myGeometry);
+    MyFaces<GridView> myFaces(leafView);
 
     // Neumann boundary
     BoundaryPatch<GridView> const neumannBoundary(leafView);
@@ -157,7 +155,7 @@ int main(int argc, char *argv[]) {
 
     MyAssembler myAssembler(leafView);
 
-    MyBody<dims> const body(parset, myGeometry);
+    MyBody<dims> const body(parset);
 
     Matrix A, C, M;
     myAssembler.assembleElasticity(body.getYoungModulus(),
@@ -232,8 +230,7 @@ int main(int argc, char *argv[]) {
     myAssembler.assembleNormalStress(frictionalBoundary, normalStress,
                                      body.getYoungModulus(),
                                      body.getPoissonRatio(), u_initial);
-    MyGlobalFrictionData<dims> frictionInfo(parset.sub("boundary.friction"),
-                                            myGeometry);
+    MyGlobalFrictionData<dims> frictionInfo(parset.sub("boundary.friction"));
     auto myGlobalNonlinearity = myAssembler.assembleFrictionNonlinearity(
         frictionalBoundary, frictionInfo, normalStress);
     myGlobalNonlinearity->updateLogState(alpha_initial);