From be1352b64cf92a7c2cb067e3cf78664b2ee6faed Mon Sep 17 00:00:00 2001
From: Elias Pipping <elias.pipping@fu-berlin.de>
Date: Fri, 13 Dec 2013 00:34:53 +0100
Subject: [PATCH] [Cleanup] Rename: Singleton -> Scalar
---
dune/tectonic/globalnonlinearity.hh | 4 +--
dune/tectonic/globalruinanonlinearity.hh | 6 ++--
src/assemblers.cc | 8 +++---
src/friction_writer.cc | 4 +--
src/friction_writer.hh | 5 ++--
src/friction_writer_tmpl.cc | 6 ++--
src/one-body-sample.cc | 34 +++++++++++-----------
src/state/dieterichstateupdater.hh | 36 ++++++++++++------------
src/state/ruinastateupdater.hh | 36 ++++++++++++------------
src/state/stateupdater.hh | 4 +--
src/vtk.cc | 15 +++++-----
src/vtk.hh | 7 ++---
src/vtk_tmpl.cc | 8 +++---
13 files changed, 85 insertions(+), 88 deletions(-)
diff --git a/dune/tectonic/globalnonlinearity.hh b/dune/tectonic/globalnonlinearity.hh
index e0a3b8ba..46a001cd 100644
--- a/dune/tectonic/globalnonlinearity.hh
+++ b/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
diff --git a/dune/tectonic/globalruinanonlinearity.hh b/dune/tectonic/globalruinanonlinearity.hh
index 026a9a6a..c08c9619 100644
--- a/dune/tectonic/globalruinanonlinearity.hh
+++ b/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]);
}
diff --git a/src/assemblers.cc b/src/assemblers.cc
index 81b92480..029c1767 100644
--- a/src/assemblers.cc
+++ b/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;
diff --git a/src/friction_writer.cc b/src/friction_writer.cc
index 409ef49f..46ee0e5b 100644
--- a/src/friction_writer.cc
+++ b/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])
diff --git a/src/friction_writer.hh b/src/friction_writer.hh
index 1907f405..c2af5fff 100644
--- a/src/friction_writer.hh
+++ b/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;
diff --git a/src/friction_writer_tmpl.cc b/src/friction_writer_tmpl.cc
index 38ef0fbb..4c907241 100644
--- a/src/friction_writer_tmpl.cc
+++ b/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);
diff --git a/src/one-body-sample.cc b/src/one-body-sample.cc
index 880d3c19..8d96bc68 100644
--- a/src/one-body-sample.cc
+++ b/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);
diff --git a/src/state/dieterichstateupdater.hh b/src/state/dieterichstateupdater.hh
index a027dec8..13f2b62c 100644
--- a/src/state/dieterichstateupdater.hh
+++ b/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;
}
diff --git a/src/state/ruinastateupdater.hh b/src/state/ruinastateupdater.hh
index da0499e3..ea39530e 100644
--- a/src/state/ruinastateupdater.hh
+++ b/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;
}
diff --git a/src/state/stateupdater.hh b/src/state/stateupdater.hh
index 698b91d3..bc7ed84d 100644
--- a/src/state/stateupdater.hh
+++ b/src/state/stateupdater.hh
@@ -1,12 +1,12 @@
#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
diff --git a/src/vtk.cc b/src/vtk.cc
index 37314404..11d44835 100644
--- a/src/vtk.cc
+++ b/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);
diff --git a/src/vtk.hh b/src/vtk.hh
index 0ce10061..122cde5f 100644
--- a/src/vtk.hh
+++ b/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
diff --git a/src/vtk_tmpl.cc b/src/vtk_tmpl.cc
index 1eceed74..6d2c9688 100644
--- a/src/vtk_tmpl.cc
+++ b/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);
--
GitLab