[Cleanup] Dune is not the right namespace

dune/tectonic/ellipticenergy.hh

@@ -10,11 +10,10 @@
 
 #include "localfriction.hh"
 
-namespace Dune {
 template <size_t dim> class EllipticEnergy {
 public:
-  using SmallVector = FieldVector<double, dim>;
-  using SmallMatrix = FieldMatrix<double, dim, dim>;
+  using SmallVector = Dune::FieldVector<double, dim>;
+  using SmallMatrix = Dune::FieldMatrix<double, dim, dim>;
 
   using Nonlinearity = LocalFriction<dim>;
 
@@ -44,5 +43,4 @@ template <size_t dim> class EllipticEnergy {
         y[i] = 0;
   }
 };
-}
 #endif

dune/tectonic/frictionpotential.hh

@@ -11,7 +11,6 @@
 
 #include "frictiondata.hh"
 
-namespace Dune {
 class FrictionPotentialWrapper {
 public:
   virtual ~FrictionPotentialWrapper() {}
@@ -21,7 +20,7 @@ class FrictionPotentialWrapper {
   double virtual regularity(double s) const = 0;
 
   double virtual evaluate(double x) const {
-    DUNE_THROW(NotImplemented, "evaluation not implemented");
+    DUNE_THROW(Dune::NotImplemented, "evaluation not implemented");
   }
 
   void virtual updateLogState(double) = 0;
@@ -92,5 +91,4 @@ class TrivialFunction : public FrictionPotentialWrapper {
 
   void updateLogState(double) {}
 };
-}
 #endif

dune/tectonic/globalnonlinearity.hh

@@ -10,10 +10,9 @@
 #include "frictionpotential.hh"
 #include "localfriction.hh"
 
-namespace Dune {
 template <class Matrix, class Vector> class GlobalNonlinearity {
 protected:
-  using ScalarVector = BlockVector<FieldVector<double, 1>>;
+  using ScalarVector = Dune::BlockVector<Dune::FieldVector<double, 1>>;
 
 public:
   using IndexSet = Dune::MatrixIndexSet;
@@ -83,5 +82,4 @@ template <class Matrix, class Vector> class GlobalNonlinearity {
 
   virtual void updateLogState(ScalarVector const &logState) = 0;
 };
-}
 #endif

dune/tectonic/globalruinanonlinearity.hh

@@ -14,7 +14,6 @@
 #include "localfriction.hh"
 #include "frictionpotential.hh"
 
-namespace Dune {
 template <class Matrix, class Vector>
 class GlobalRuinaNonlinearity : public GlobalNonlinearity<Matrix, Vector> {
 public:
@@ -55,5 +54,4 @@ class GlobalRuinaNonlinearity : public GlobalNonlinearity<Matrix, Vector> {
 private:
   std::vector<std::shared_ptr<Friction>> restrictions;
 };
-}
 #endif

dune/tectonic/localfriction.hh

@@ -29,11 +29,10 @@ double dotFirstNormalised(Vector const &x, Vector const &y) {
   return sum;
 }
 
-namespace Dune {
 template <size_t dimension> class LocalFriction {
 public:
-  using VectorType = FieldVector<double, dimension>;
-  using MatrixType = FieldMatrix<double, dimension, dimension>;
+  using VectorType = Dune::FieldVector<double, dimension>;
+  using MatrixType = Dune::FieldMatrix<double, dimension, dimension>;
 
   explicit LocalFriction(std::shared_ptr<FrictionPotentialWrapper> func)
       : func(func) {}
@@ -123,5 +122,4 @@ template <size_t dimension> class LocalFriction {
 private:
   std::shared_ptr<FrictionPotentialWrapper> const func;
 };
-}
 #endif

dune/tectonic/minimisation.hh

@@ -11,7 +11,6 @@
 
 #include "mydirectionalconvexfunction.hh"
 
-namespace Dune {
 template <class Functional>
 void descentMinimisation(Functional const &J,
                          typename Functional::SmallVector &x,
@@ -47,5 +46,4 @@ void minimise(Functional const &J, typename Functional::SmallVector &x,
     descentMinimisation(J, x, v, bisection);
   }
 }
-}
 #endif

dune/tectonic/myblockproblem.hh

@@ -21,7 +21,7 @@
 /* Just for debugging */
 template <class Matrix, class Vector>
 double computeEnergy(Matrix const &A, Vector const &x, Vector const &b,
-                     Dune::GlobalNonlinearity<Matrix, Vector> const &phi) {
+                     GlobalNonlinearity<Matrix, Vector> const &phi) {
   return computeEnergy(A, x, b) + phi(x);
 }
 
@@ -95,7 +95,7 @@ template <class ConvexProblem> class MyBlockProblem {
     v /= vnorm; // Rescale for numerical stability
 
     MyDirectionalConvexFunction<
-        Dune::GlobalNonlinearity<MatrixType, VectorType>> const
+        GlobalNonlinearity<MatrixType, VectorType>> const
     psi(computeDirectionalA(problem.A, v),
         computeDirectionalb(problem.A, problem.f, u, v), problem.phi, u, v);
 
@@ -253,8 +253,8 @@ class MyBlockProblem<ConvexProblem>::IterateObject {
       assert(localA != nullptr);
 
       auto const phi = problem.phi.restriction(m);
-      Dune::EllipticEnergy<block_size> localJ(*localA, localb, phi, ignore);
-      Dune::minimise(localJ, ui, localsteps, bisection);
+      EllipticEnergy<block_size> localJ(*localA, localb, phi, ignore);
+      minimise(localJ, ui, localsteps, bisection);
     }
   }
 

src/assemblers.cc

@@ -91,7 +91,7 @@ void MyAssembler<GridView, dimension>::assembleNeumann(
 template <class GridView, int dimension>
 auto MyAssembler<GridView, dimension>::assembleFrictionNonlinearity(
     BoundaryPatch<GridView> const &frictionalBoundary, FrictionData const &fd)
-    -> std::shared_ptr<Dune::GlobalNonlinearity<Matrix, Vector>> {
+    -> std::shared_ptr<GlobalNonlinearity<Matrix, Vector>> {
   // Lump negative normal stress (kludge)
   ScalarVector weights;
   {
@@ -107,7 +107,7 @@ auto MyAssembler<GridView, dimension>::assembleFrictionNonlinearity(
 
   Dune::BitSetVector<1> frictionalNodes;
   frictionalBoundary.getVertices(frictionalNodes);
-  return std::make_shared<Dune::GlobalRuinaNonlinearity<Matrix, Vector>>(
+  return std::make_shared<GlobalRuinaNonlinearity<Matrix, Vector>>(
       frictionalNodes, weights, fd);
 }
 

src/assemblers.hh

@@ -52,7 +52,7 @@ template <class GridView, int dimension> class MyAssembler {
                        Dune::VirtualFunction<double, double> const &neumann,
                        double relativeTime);
 
-  std::shared_ptr<Dune::GlobalNonlinearity<Matrix, Vector>>
+  std::shared_ptr<GlobalNonlinearity<Matrix, Vector>>
   assembleFrictionNonlinearity(
       BoundaryPatch<GridView> const &frictionalBoundary,
       FrictionData const &fd);

src/one-body-sample.cc

@@ -151,7 +151,7 @@ int main(int argc, char *argv[]) {
     using ScalarMatrix = Dune::BCRSMatrix<SmallScalarMatrix>;
     using Vector = Dune::BlockVector<SmallVector>;
     using ScalarVector = Dune::BlockVector<Dune::FieldVector<double, 1>>;
-    using Nonlinearity = Dune::GlobalNonlinearity<Matrix, Vector>;
+    using Nonlinearity = GlobalNonlinearity<Matrix, Vector>;
 
     auto const E = parset.get<double>("body.E");
     auto const nu = parset.get<double>("body.nu");
@@ -391,9 +391,9 @@ int main(int argc, char *argv[]) {
     writer.writeInfo(alpha_initial, u_initial, v_initial);
 
     // Set up TNNMG solver
-    using NonlinearFactory = SolverFactory<
-        dims, MyBlockProblem<ConvexProblem<
-                  Dune::GlobalNonlinearity<Matrix, Vector>, Matrix>>,
+    using NonlinearFactory =
+        SolverFactory<dims, MyBlockProblem<ConvexProblem<
+                                GlobalNonlinearity<Matrix, Vector>, Matrix>>,
                       Grid>;
     NonlinearFactory factory(parset.sub("solver.tnnmg"), refinements, *grid,
                              velocityDirichletNodes);

src/solverfactory_tmpl.cc

@@ -13,8 +13,8 @@
 #include <dune/tectonic/myblockproblem.hh>
 
 template class SolverFactory<
-    DIM, MyBlockProblem<
-             ConvexProblem<Dune::GlobalNonlinearity<Matrix, Vector>, Matrix>>,
+    DIM,
+    MyBlockProblem<ConvexProblem<GlobalNonlinearity<Matrix, Vector>, Matrix>>,
     Grid>;
 template class SolverFactory<
     DIM, BlockNonlinearTNNMGProblem<