[Cleanup] Rename: Singleton -> Scalar

dune/tectonic/globalnonlinearity.hh

@@ -14,7 +14,7 @@
 namespace Dune {
 template <class Matrix, class Vector> class GlobalNonlinearity {
 protected:
-  using SingletonVector = BlockVector<FieldVector<double, 1>>;
+  using ScalarVector = BlockVector<FieldVector<double, 1>>;
 
 public:
   using IndexSet = Dune::MatrixIndexSet;
@@ -81,7 +81,7 @@ template <class Matrix, class Vector> class GlobalNonlinearity {
     return res->regularity(x);
   }
 
-  virtual void updateLogState(SingletonVector const &logState) = 0;
+  virtual void updateLogState(ScalarVector const &logState) = 0;
 };
 }
 #endif

dune/tectonic/globalruinanonlinearity.hh

@@ -22,11 +22,11 @@ class GlobalRuinaNonlinearity : public GlobalNonlinearity<Matrix, Vector> {
   using typename GlobalNonlinearity<Matrix, Vector>::Friction;
 
 private:
-  using typename GlobalNonlinearity<Matrix, Vector>::SingletonVector;
+  using typename GlobalNonlinearity<Matrix, Vector>::ScalarVector;
 
 public:
   GlobalRuinaNonlinearity(Dune::BitSetVector<1> const &frictionalNodes,
-                          SingletonVector const &nodalIntegrals,
+                          ScalarVector const &nodalIntegrals,
                           FrictionData const &fd)
       : restrictions(nodalIntegrals.size()) {
     auto trivialNonlinearity =
@@ -40,7 +40,7 @@ class GlobalRuinaNonlinearity : public GlobalNonlinearity<Matrix, Vector> {
     }
   }
 
-  void updateLogState(SingletonVector const &logState) override {
+  void updateLogState(ScalarVector const &logState) override {
     for (size_t i = 0; i < restrictions.size(); ++i)
       restrictions[i]->updateLogState(logState[i]);
   }

src/assemblers.cc

@@ -33,13 +33,13 @@ template <class GridView, class LocalVector, class Assembler>
 Dune::shared_ptr<Dune::BlockVector<Dune::FieldVector<double, 1>>>
 assembleFrictionWeightsal(GridView const &gridView, Assembler const &assembler,
                           Dune::BitSetVector<1> const &frictionalNodes) {
-  using Singleton = Dune::FieldVector<double, 1>;
+  using Scalar = Dune::FieldVector<double, 1>;
   BoundaryPatch<GridView> const frictionalBoundary(gridView, frictionalNodes);
-  ConstantFunction<LocalVector, Singleton> const constantOneFunction(1);
-  NeumannBoundaryAssembler<typename GridView::Grid, Singleton>
+  ConstantFunction<LocalVector, Scalar> const constantOneFunction(1);
+  NeumannBoundaryAssembler<typename GridView::Grid, Scalar>
   frictionalBoundaryAssembler(constantOneFunction);
 
-  auto const nodalIntegrals = Dune::make_shared<Dune::BlockVector<Singleton>>();
+  auto const nodalIntegrals = Dune::make_shared<Dune::BlockVector<Scalar>>();
   assembler.assembleBoundaryFunctional(frictionalBoundaryAssembler,
                                        *nodalIntegrals, frictionalBoundary);
   return nodalIntegrals;

src/friction_writer.cc

@@ -28,8 +28,8 @@ template <class BitVector> FrictionWriter<BitVector>::~FrictionWriter() {
 }
 
 template <class BitVector>
-template <class SingletonVector, class Vector>
-void FrictionWriter<BitVector>::writeInfo(SingletonVector const &alpha,
+template <class ScalarVector, class Vector>
+void FrictionWriter<BitVector>::writeInfo(ScalarVector const &alpha,
                                           Vector const &u, Vector const &v) {
   for (size_t i = 0; i < boundaryNodes.size(); ++i) {
     if (!boundaryNodes[i][0])

src/friction_writer.hh

@@ -11,9 +11,8 @@ template <class BitVector> class FrictionWriter {
 
   ~FrictionWriter();
 
-  template <class SingletonVector, class Vector>
-  void writeInfo(SingletonVector const &alpha, Vector const &u,
-                 Vector const &v);
+  template <class ScalarVector, class Vector>
+  void writeInfo(ScalarVector const &alpha, Vector const &u, Vector const &v);
 
 private:
   std::fstream coefficientWriter;

src/friction_writer_tmpl.cc

@@ -2,15 +2,15 @@
 #include <dune/istl/bvector.hh>
 
 using BitVector = Dune::BitSetVector<1>;
-using SingletonVector = Dune::BlockVector<Dune::FieldVector<double, 1>>;
+using ScalarVector = Dune::BlockVector<Dune::FieldVector<double, 1>>;
 using Vector2 = Dune::BlockVector<Dune::FieldVector<double, 2>>;
 using Vector3 = Dune::BlockVector<Dune::FieldVector<double, 3>>;
 
 template class FrictionWriter<BitVector>;
 
-template void FrictionWriter<BitVector>::writeInfo(SingletonVector const &alpha,
+template void FrictionWriter<BitVector>::writeInfo(ScalarVector const &alpha,
                                                    Vector2 const &u,
                                                    Vector2 const &v);
-template void FrictionWriter<BitVector>::writeInfo(SingletonVector const &alpha,
+template void FrictionWriter<BitVector>::writeInfo(ScalarVector const &alpha,
                                                    Vector3 const &u,
                                                    Vector3 const &v);

src/one-body-sample.cc

@@ -122,16 +122,16 @@ initTimeStepper(Config::scheme scheme,
   }
 }
 
-template <class SingletonVector, class Vector>
-Dune::shared_ptr<StateUpdater<SingletonVector, Vector>> initStateUpdater(
-    Config::stateModel model, SingletonVector const &alpha_initial,
+template <class ScalarVector, class Vector>
+Dune::shared_ptr<StateUpdater<ScalarVector, Vector>> initStateUpdater(
+    Config::stateModel model, ScalarVector const &alpha_initial,
     Dune::BitSetVector<1> const &frictionalNodes, FrictionData const &fd) {
   switch (model) {
     case Config::Dieterich:
-      return Dune::make_shared<DieterichStateUpdater<SingletonVector, Vector>>(
+      return Dune::make_shared<DieterichStateUpdater<ScalarVector, Vector>>(
           alpha_initial, frictionalNodes, fd.L);
     case Config::Ruina:
-      return Dune::make_shared<RuinaStateUpdater<SingletonVector, Vector>>(
+      return Dune::make_shared<RuinaStateUpdater<ScalarVector, Vector>>(
           alpha_initial, frictionalNodes, fd.L);
     default:
       assert(false);
@@ -154,11 +154,11 @@ int main(int argc, char *argv[]) {
 
     using SmallVector = Dune::FieldVector<double, dims>;
     using SmallMatrix = Dune::FieldMatrix<double, dims, dims>;
-    using SmallSingletonMatrix = Dune::FieldMatrix<double, 1, 1>;
+    using SmallScalarMatrix = Dune::FieldMatrix<double, 1, 1>;
     using Matrix = Dune::BCRSMatrix<SmallMatrix>;
-    using SingletonMatrix = Dune::BCRSMatrix<SmallSingletonMatrix>;
+    using ScalarMatrix = Dune::BCRSMatrix<SmallScalarMatrix>;
     using Vector = Dune::BlockVector<SmallVector>;
-    using SingletonVector = Dune::BlockVector<Dune::FieldVector<double, 1>>;
+    using ScalarVector = Dune::BlockVector<Dune::FieldVector<double, 1>>;
     using Nonlinearity = Dune::GlobalNonlinearity<Matrix, Vector>;
 
     auto const E = parset.get<double>("body.E");
@@ -313,13 +313,13 @@ int main(int argc, char *argv[]) {
       p1Assembler.assembleOperator(localViscosity, C);
     }
 
-    SingletonMatrix frictionalBoundaryMassMatrix;
-    EnergyNorm<SingletonMatrix, SingletonVector> const stateEnergyNorm(
+    ScalarMatrix frictionalBoundaryMassMatrix;
+    EnergyNorm<ScalarMatrix, ScalarVector> const stateEnergyNorm(
         frictionalBoundaryMassMatrix);
     {
       BoundaryMassAssembler<
           Grid, BoundaryPatch<GridView>, P1Basis::LocalFiniteElement,
-          P1Basis::LocalFiniteElement, SmallSingletonMatrix> const
+          P1Basis::LocalFiniteElement, SmallScalarMatrix> const
       frictionalBoundaryMassAssembler(frictionalBoundary);
       p1Assembler.assembleOperator(frictionalBoundaryMassAssembler,
                                    frictionalBoundaryMassMatrix);
@@ -343,7 +343,7 @@ int main(int argc, char *argv[]) {
     createRHS(0.0, ell);
 
     // {{{ Initial conditions
-    SingletonVector alpha_initial(fineVertexCount);
+    ScalarVector alpha_initial(fineVertexCount);
     alpha_initial =
         std::log(parset.get<double>("boundary.friction.initialState"));
 
@@ -454,12 +454,12 @@ int main(int argc, char *argv[]) {
         initTimeStepper(parset.get<Config::scheme>("timeSteps.scheme"),
                         velocityDirichletFunction, velocityDirichletNodes, M, A,
                         C, u_initial, v_initial, a_initial);
-    auto stateUpdater = initStateUpdater<SingletonVector, Vector>(
+    auto stateUpdater = initStateUpdater<ScalarVector, Vector>(
         parset.get<Config::stateModel>("boundary.friction.stateModel"),
         alpha_initial, frictionalNodes, frictionData);
 
     Vector v = v_initial;
-    SingletonVector alpha(fineVertexCount);
+    ScalarVector alpha(fineVertexCount);
 
     auto const timesteps = parset.get<size_t>("timeSteps.number"),
                maximumStateFPI = parset.get<size_t>("v.fpi.maximumIterations"),
@@ -498,7 +498,7 @@ int main(int argc, char *argv[]) {
 
       size_t iterationCounter;
       auto solveVelocityProblem = [&](Vector &_velocityIterate,
-                                      SingletonVector const &_alpha) {
+                                      ScalarVector const &_alpha) {
         myGlobalNonlinearity->updateLogState(_alpha);
 
         // NIT: Do we really need to pass u here?
@@ -519,7 +519,7 @@ int main(int argc, char *argv[]) {
       // Q: is this reasonable?
       Vector u;
       Vector u_saved;
-      SingletonVector alpha_saved;
+      ScalarVector alpha_saved;
       double lastStateCorrection;
       for (size_t stateFPI = 1; stateFPI <= maximumStateFPI; ++stateFPI) {
         stateUpdater->solve(v);
@@ -572,7 +572,7 @@ int main(int argc, char *argv[]) {
         auto const gridDisplacement =
             Dune::make_shared<BasisGridFunction<P1Basis, Vector> const>(p1Basis,
                                                                         u);
-        SingletonVector vonMisesStress;
+        ScalarVector vonMisesStress;
         VonMisesStressAssembler<Grid, P0Basis::LocalFiniteElement>
         localStressAssembler(E, nu, gridDisplacement);
         p0Assembler.assembleFunctional(localStressAssembler, vonMisesStress);

src/state/dieterichstateupdater.hh

@@ -4,43 +4,43 @@
 #include "compute_state_dieterich_euler.hh"
 #include "stateupdater.hh"
 
-template <class SingletonVector, class Vector>
-class DieterichStateUpdater : public StateUpdater<SingletonVector, Vector> {
+template <class ScalarVector, class Vector>
+class DieterichStateUpdater : public StateUpdater<ScalarVector, Vector> {
 public:
-  DieterichStateUpdater(SingletonVector _logState_initial,
+  DieterichStateUpdater(ScalarVector _logState_initial,
                         Dune::BitSetVector<1> const &_nodes, double _L);
 
   virtual void nextTimeStep();
   virtual void setup(double _tau);
   virtual void solve(Vector const &velocity_field);
-  virtual void extractLogState(SingletonVector &);
+  virtual void extractLogState(ScalarVector &);
 
 private:
-  SingletonVector logState_o;
-  SingletonVector logState;
+  ScalarVector logState_o;
+  ScalarVector logState;
   Dune::BitSetVector<1> const &nodes;
   double const L;
   double tau;
 };
 
-template <class SingletonVector, class Vector>
-DieterichStateUpdater<SingletonVector, Vector>::DieterichStateUpdater(
-    SingletonVector _logState_initial, Dune::BitSetVector<1> const &_nodes,
+template <class ScalarVector, class Vector>
+DieterichStateUpdater<ScalarVector, Vector>::DieterichStateUpdater(
+    ScalarVector _logState_initial, Dune::BitSetVector<1> const &_nodes,
     double _L)
     : logState(_logState_initial), nodes(_nodes), L(_L) {}
 
-template <class SingletonVector, class Vector>
-void DieterichStateUpdater<SingletonVector, Vector>::nextTimeStep() {
+template <class ScalarVector, class Vector>
+void DieterichStateUpdater<ScalarVector, Vector>::nextTimeStep() {
   logState_o = logState;
 }
 
-template <class SingletonVector, class Vector>
-void DieterichStateUpdater<SingletonVector, Vector>::setup(double _tau) {
+template <class ScalarVector, class Vector>
+void DieterichStateUpdater<ScalarVector, Vector>::setup(double _tau) {
   tau = _tau;
 }
 
-template <class SingletonVector, class Vector>
-void DieterichStateUpdater<SingletonVector, Vector>::solve(
+template <class ScalarVector, class Vector>
+void DieterichStateUpdater<ScalarVector, Vector>::solve(
     Vector const &velocity_field) {
   for (size_t i = 0; i < nodes.size(); ++i)
     if (nodes[i][0]) {
@@ -49,9 +49,9 @@ void DieterichStateUpdater<SingletonVector, Vector>::solve(
     }
 }
 
-template <class SingletonVector, class Vector>
-void DieterichStateUpdater<SingletonVector, Vector>::extractLogState(
-    SingletonVector &_logState) {
+template <class ScalarVector, class Vector>
+void DieterichStateUpdater<ScalarVector, Vector>::extractLogState(
+    ScalarVector &_logState) {
   _logState = logState;
 }
 

src/state/ruinastateupdater.hh

@@ -4,43 +4,43 @@
 #include "compute_state_ruina.hh"
 #include "stateupdater.hh"
 
-template <class SingletonVector, class Vector>
-class RuinaStateUpdater : public StateUpdater<SingletonVector, Vector> {
+template <class ScalarVector, class Vector>
+class RuinaStateUpdater : public StateUpdater<ScalarVector, Vector> {
 public:
-  RuinaStateUpdater(SingletonVector _logState_initial,
+  RuinaStateUpdater(ScalarVector _logState_initial,
                     Dune::BitSetVector<1> const &_nodes, double _L);
 
   virtual void nextTimeStep();
   virtual void setup(double _tau);
   virtual void solve(Vector const &velocity_field);
-  virtual void extractLogState(SingletonVector &);
+  virtual void extractLogState(ScalarVector &);
 
 private:
-  SingletonVector logState_o;
-  SingletonVector logState;
+  ScalarVector logState_o;
+  ScalarVector logState;
   Dune::BitSetVector<1> const &nodes;
   double const L;
   double tau;
 };
 
-template <class SingletonVector, class Vector>
-RuinaStateUpdater<SingletonVector, Vector>::RuinaStateUpdater(
-    SingletonVector _logState_initial, Dune::BitSetVector<1> const &_nodes,
+template <class ScalarVector, class Vector>
+RuinaStateUpdater<ScalarVector, Vector>::RuinaStateUpdater(
+    ScalarVector _logState_initial, Dune::BitSetVector<1> const &_nodes,
     double _L)
     : logState(_logState_initial), nodes(_nodes), L(_L) {}
 
-template <class SingletonVector, class Vector>
-void RuinaStateUpdater<SingletonVector, Vector>::nextTimeStep() {
+template <class ScalarVector, class Vector>
+void RuinaStateUpdater<ScalarVector, Vector>::nextTimeStep() {
   logState_o = logState;
 }
 
-template <class SingletonVector, class Vector>
-void RuinaStateUpdater<SingletonVector, Vector>::setup(double _tau) {
+template <class ScalarVector, class Vector>
+void RuinaStateUpdater<ScalarVector, Vector>::setup(double _tau) {
   tau = _tau;
 }
 
-template <class SingletonVector, class Vector>
-void RuinaStateUpdater<SingletonVector, Vector>::solve(
+template <class ScalarVector, class Vector>
+void RuinaStateUpdater<ScalarVector, Vector>::solve(
     Vector const &velocity_field) {
   for (size_t i = 0; i < nodes.size(); ++i)
     if (nodes[i][0]) {
@@ -49,9 +49,9 @@ void RuinaStateUpdater<SingletonVector, Vector>::solve(
     }
 }
 
-template <class SingletonVector, class Vector>
-void RuinaStateUpdater<SingletonVector, Vector>::extractLogState(
-    SingletonVector &_logState) {
+template <class ScalarVector, class Vector>
+void RuinaStateUpdater<ScalarVector, Vector>::extractLogState(
+    ScalarVector &_logState) {
   _logState = logState;
 }
 

src/state/stateupdater.hh

 #ifndef STATE_UPDATER_HH
 #define STATE_UPDATER_HH
 
-template <class SingletonVector, class Vector> class StateUpdater {
+template <class ScalarVector, class Vector> class StateUpdater {
 public:
   virtual void nextTimeStep() = 0;
   virtual void setup(double _tau) = 0;
   virtual void solve(Vector const &velocity_field) = 0;
-  virtual void extractLogState(SingletonVector &logState) = 0;
+  virtual void extractLogState(ScalarVector &logState) = 0;
 };
 
 #endif

src/vtk.cc

@@ -4,11 +4,10 @@
 
 #include "vtk.hh"
 
-template <class VertexBasis, class CellBasis, class Vector,
-          class SingletonVector>
+template <class VertexBasis, class CellBasis, class Vector, class ScalarVector>
 void writeVtk(VertexBasis const &vertexBasis, Vector const &displacement,
-              SingletonVector const &logState, CellBasis const &cellBasis,
-              SingletonVector const &stress, std::string const &filename) {
+              ScalarVector const &logState, CellBasis const &cellBasis,
+              ScalarVector const &stress, std::string const &filename) {
   Dune::VTKWriter<typename VertexBasis::GridView> writer(
       vertexBasis.getGridView());
 
@@ -17,13 +16,13 @@ void writeVtk(VertexBasis const &vertexBasis, Vector const &displacement,
           vertexBasis, displacement, "displacement");
   writer.addVertexData(displacementPointer);
 
-  auto const logStatePointer = Dune::make_shared<
-      VTKBasisGridFunction<VertexBasis, SingletonVector> const>(
-      vertexBasis, logState, "logState");
+  auto const logStatePointer =
+      Dune::make_shared<VTKBasisGridFunction<VertexBasis, ScalarVector> const>(
+          vertexBasis, logState, "logState");
   writer.addVertexData(logStatePointer);
 
   auto const vonmisesPointer =
-      Dune::make_shared<VTKBasisGridFunction<CellBasis, SingletonVector> const>(
+      Dune::make_shared<VTKBasisGridFunction<CellBasis, ScalarVector> const>(
           cellBasis, stress, "stress");
   writer.addCellData(vonmisesPointer);
 

src/vtk.hh

@@ -6,10 +6,9 @@
 
 #include <dune/fufem/functions/vtkbasisgridfunction.hh>
 
-template <class VertexBasis, class CellBasis, class Vector,
-          class SingletonVector>
+template <class VertexBasis, class CellBasis, class Vector, class ScalarVector>
 void writeVtk(VertexBasis const &vertexBasis, Vector const &displacement,
-              SingletonVector const &logState, CellBasis const &cellBasis,
-              SingletonVector const &stress, std::string const &filename);
+              ScalarVector const &logState, CellBasis const &cellBasis,
+              ScalarVector const &stress, std::string const &filename);
 
 #endif

src/vtk_tmpl.cc

@@ -15,7 +15,7 @@
 #include <dune/fufem/functionspacebases/p0basis.hh>
 #include <dune/fufem/functionspacebases/p1nodalbasis.hh>
 
-using SingletonVector = Dune::BlockVector<Dune::FieldVector<double, 1>>;
+using ScalarVector = Dune::BlockVector<Dune::FieldVector<double, 1>>;
 
 using SmallVector = Dune::FieldVector<double, DIM>;
 using SmallMatrix = Dune::FieldMatrix<double, DIM, DIM>;
@@ -26,7 +26,7 @@ using GridView = Grid::LeafGridView;
 using P1Basis = P1NodalBasis<GridView, double>;
 using MyP0Basis = P0Basis<GridView, double>;
 
-template void writeVtk<P1Basis, MyP0Basis, Vector, SingletonVector>(
+template void writeVtk<P1Basis, MyP0Basis, Vector, ScalarVector>(
     P1Basis const &vertexBasis, Vector const &displacement,
-    SingletonVector const &logState, MyP0Basis const &cellBasis,
-    SingletonVector const &stress, std::string const &filename);
+    ScalarVector const &logState, MyP0Basis const &cellBasis,
+    ScalarVector const &stress, std::string const &filename);