[Cleanup] shared_ptr: Use std::

dune/tectonic/ellipticenergy.hh

@@ -19,7 +19,7 @@ template <size_t dim> class EllipticEnergy {
   using Nonlinearity = LocalFriction<dim>;
 
   EllipticEnergy(SmallMatrix const &A, SmallVector const &b,
-                 shared_ptr<Nonlinearity const> phi,
+                 std::shared_ptr<Nonlinearity const> phi,
                  typename Dune::BitSetVector<dim>::const_reference ignore)
       : A(A), b(b), phi(phi), ignore(ignore) {}
 
@@ -29,7 +29,7 @@ template <size_t dim> class EllipticEnergy {
 
   SmallMatrix const &A;
   SmallVector const &b;
-  shared_ptr<Nonlinearity const> const phi;
+  std::shared_ptr<Nonlinearity const> const phi;
   /* Dimension that should be ignored; goes from 0 to dim-1; the
      special value dim means that no dimension should be ignored */
   typename Dune::BitSetVector<dim>::const_reference const ignore;

dune/tectonic/globalnonlinearity.hh

@@ -3,7 +3,6 @@
 
 #include <dune/common/fmatrix.hh>
 #include <dune/common/fvector.hh>
-#include <dune/common/shared_ptr.hh>
 #include <dune/istl/bcrsmatrix.hh>
 #include <dune/istl/bvector.hh>
 #include <dune/istl/matrixindexset.hh>
@@ -37,7 +36,8 @@ template <class Matrix, class Vector> class GlobalNonlinearity {
   /*
     Return a restriction of the outer function to the i'th node.
   */
-  virtual shared_ptr<LocalFriction<block_size>> restriction(size_t i) const = 0;
+  virtual std::shared_ptr<LocalFriction<block_size>> restriction(size_t i)
+      const = 0;
 
   void addHessian(Vector const &v, Matrix &hessian) const {
     for (size_t i = 0; i < v.size(); ++i) {

dune/tectonic/globalruinanonlinearity.hh

@@ -30,12 +30,12 @@ class GlobalRuinaNonlinearity : public GlobalNonlinearity<Matrix, Vector> {
                           FrictionData const &fd)
       : restrictions(nodalIntegrals.size()) {
     auto trivialNonlinearity =
-        make_shared<Friction>(make_shared<TrivialFunction>());
+        std::make_shared<Friction>(std::make_shared<TrivialFunction>());
     for (size_t i = 0; i < restrictions.size(); ++i) {
       restrictions[i] =
           frictionalNodes[i][0]
-              ? make_shared<Friction>(
-                    make_shared<FrictionPotential>(nodalIntegrals[i], fd))
+              ? std::make_shared<Friction>(
+                    std::make_shared<FrictionPotential>(nodalIntegrals[i], fd))
               : trivialNonlinearity;
     }
   }
@@ -48,12 +48,12 @@ class GlobalRuinaNonlinearity : public GlobalNonlinearity<Matrix, Vector> {
   /*
     Return a restriction of the outer function to the i'th node.
   */
-  shared_ptr<Friction> restriction(size_t i) const override {
+  std::shared_ptr<Friction> restriction(size_t i) const override {
     return restrictions[i];
   }
 
 private:
-  std::vector<shared_ptr<Friction>> restrictions;
+  std::vector<std::shared_ptr<Friction>> restrictions;
 };
 }
 #endif

dune/tectonic/localfriction.hh

@@ -6,7 +6,6 @@
 
 #include <dune/common/fvector.hh>
 #include <dune/common/fmatrix.hh>
-#include <dune/common/shared_ptr.hh>
 
 #include <dune/fufem/arithmetic.hh>
 #include <dune/fufem/interval.hh>
@@ -36,7 +35,7 @@ template <size_t dimension> class LocalFriction {
   using VectorType = FieldVector<double, dimension>;
   using MatrixType = FieldMatrix<double, dimension, dimension>;
 
-  explicit LocalFriction(shared_ptr<FrictionPotentialWrapper> func)
+  explicit LocalFriction(std::shared_ptr<FrictionPotentialWrapper> func)
       : func(func) {}
 
   double operator()(VectorType const &x) const {
@@ -122,7 +121,7 @@ template <size_t dimension> class LocalFriction {
   }
 
 private:
-  shared_ptr<FrictionPotentialWrapper> const func;
+  std::shared_ptr<FrictionPotentialWrapper> const func;
 };
 }
 #endif

src/one-body-sample.cc

@@ -38,7 +38,6 @@
 #include <dune/common/fvector.hh>
 #include <dune/common/parametertree.hh>
 #include <dune/common/parametertreeparser.hh>
-#include <dune/common/shared_ptr.hh>
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wignored-qualifiers"
@@ -94,7 +93,7 @@
 size_t const dims = DIM;
 
 template <class Vector, class Matrix, class Function, int dimension>
-Dune::shared_ptr<TimeSteppingScheme<Vector, Matrix, Function, dimension>>
+std::shared_ptr<TimeSteppingScheme<Vector, Matrix, Function, dimension>>
 initTimeStepper(Config::scheme scheme,
                 Function const &velocityDirichletFunction,
                 Dune::BitSetVector<dimension> const &velocityDirichletNodes,
@@ -103,11 +102,11 @@ initTimeStepper(Config::scheme scheme,
                 Vector const &v_initial, Vector const &a_initial) {
   switch (scheme) {
     case Config::Newmark:
-      return Dune::make_shared<Newmark<Vector, Matrix, Function, dims>>(
+      return std::make_shared<Newmark<Vector, Matrix, Function, dims>>(
           stiffnessMatrix, massMatrix, dampingMatrix, u_initial, v_initial,
           a_initial, velocityDirichletNodes, velocityDirichletFunction);
     case Config::BackwardEuler:
-      return Dune::make_shared<BackwardEuler<Vector, Matrix, Function, dims>>(
+      return std::make_shared<BackwardEuler<Vector, Matrix, Function, dims>>(
           stiffnessMatrix, massMatrix, dampingMatrix, u_initial, v_initial,
           velocityDirichletNodes, velocityDirichletFunction);
     default:
@@ -116,15 +115,15 @@ initTimeStepper(Config::scheme scheme,
 }
 
 template <class ScalarVector, class Vector>
-Dune::shared_ptr<StateUpdater<ScalarVector, Vector>> initStateUpdater(
+std::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<ScalarVector, Vector>>(
+      return std::make_shared<DieterichStateUpdater<ScalarVector, Vector>>(
           alpha_initial, frictionalNodes, fd.L);
     case Config::Ruina:
-      return Dune::make_shared<RuinaStateUpdater<ScalarVector, Vector>>(
+      return std::make_shared<RuinaStateUpdater<ScalarVector, Vector>>(
           alpha_initial, frictionalNodes, fd.L);
     default:
       assert(false);
@@ -167,7 +166,7 @@ int main(int argc, char *argv[]) {
     upperRight[0] = parset.get<size_t>("body.width");
     upperRight[1] = parset.get<size_t>("body.height");
 
-    Dune::shared_ptr<Grid> grid;
+    std::shared_ptr<Grid> grid;
     {
       Dune::array<unsigned int, dims> elements;
       std::fill(elements.begin(), elements.end(), 1);
@@ -529,7 +528,7 @@ int main(int argc, char *argv[]) {
       relaxationWriter << std::endl;
 
       if (parset.get<bool>("io.writeVTK")) {
-        auto const gridDisplacement = Dune::make_shared<
+        auto const gridDisplacement = std::make_shared<
             BasisGridFunction<typename MyAssembler::VertexBasis, Vector> const>(
             myAssembler.vertexBasis, u);
         ScalarVector vonMisesStress;

src/vtk.cc

@@ -12,17 +12,17 @@ void writeVtk(VertexBasis const &vertexBasis, Vector const &displacement,
       vertexBasis.getGridView());
 
   auto const displacementPointer =
-      Dune::make_shared<VTKBasisGridFunction<VertexBasis, Vector> const>(
+      std::make_shared<VTKBasisGridFunction<VertexBasis, Vector> const>(
           vertexBasis, displacement, "displacement");
   writer.addVertexData(displacementPointer);
 
   auto const logStatePointer =
-      Dune::make_shared<VTKBasisGridFunction<VertexBasis, ScalarVector> const>(
+      std::make_shared<VTKBasisGridFunction<VertexBasis, ScalarVector> const>(
           vertexBasis, logState, "logState");
   writer.addVertexData(logStatePointer);
 
   auto const vonmisesPointer =
-      Dune::make_shared<VTKBasisGridFunction<CellBasis, ScalarVector> const>(
+      std::make_shared<VTKBasisGridFunction<CellBasis, ScalarVector> const>(
           cellBasis, stress, "stress");
   writer.addCellData(vonmisesPointer);
 

src/vtk.hh

 #ifndef VTK_HH
 #define VTK_HH
 
-#include <dune/common/shared_ptr.hh>
 #include <dune/grid/io/file/vtk/vtkwriter.hh>
 
 #include <dune/fufem/functions/vtkbasisgridfunction.hh>