]> https://gitweb.dealii.org/ - dealii.git/commitdiff
C++14 cleanup: do not use wrapper namespace
authorMatthias Maier <tamiko@43-1.org>
Sun, 24 May 2020 05:00:50 +0000 (00:00 -0500)
committerMatthias Maier <tamiko@43-1.org>
Sun, 24 May 2020 05:22:50 +0000 (00:22 -0500)
135 files changed:
contrib/python-bindings/source/manifold_wrapper.cc
examples/step-13/step-13.cc
examples/step-14/step-14.cc
examples/step-27/step-27.cc
examples/step-28/step-28.cc
examples/step-53/step-53.cc
examples/step-60/step-60.cc
examples/step-63/step-63.cc
examples/step-67/step-67.cc
examples/step-70/step-70.cc
include/deal.II/base/mpi_consensus_algorithms.templates.h
include/deal.II/base/parameter_handler.h
include/deal.II/base/patterns.h
include/deal.II/base/polynomials_p.h
include/deal.II/base/std_cxx17/tuple.h
include/deal.II/base/tensor.h
include/deal.II/fe/fe_dg_vector.templates.h
include/deal.II/fe/fe_face.h
include/deal.II/fe/fe_poly.h
include/deal.II/fe/fe_poly_face.h
include/deal.II/fe/fe_poly_tensor.h
include/deal.II/fe/fe_tools.h
include/deal.II/fe/fe_tools.templates.h
include/deal.II/fe/fe_tools_interpolate.templates.h
include/deal.II/grid/composition_manifold.h
include/deal.II/grid/filtered_iterator.h
include/deal.II/grid/manifold_lib.h
include/deal.II/grid/tensor_product_manifold.h
include/deal.II/lac/chunk_sparse_matrix.templates.h
include/deal.II/lac/qr.h
include/deal.II/lac/solver_gmres.h
include/deal.II/lac/sparse_matrix.templates.h
include/deal.II/lac/sparsity_pattern.h
include/deal.II/lac/trilinos_tpetra_vector.templates.h
include/deal.II/lac/vector_memory.templates.h
include/deal.II/numerics/data_out_dof_data.templates.h
include/deal.II/numerics/history.h
include/deal.II/numerics/vector_tools_common.h
source/base/function_parser.cc
source/base/parameter_handler.cc
source/base/patterns.cc
source/base/polynomial.cc
source/base/polynomial_space.cc
source/base/polynomials_abf.cc
source/base/polynomials_adini.cc
source/base/polynomials_bdm.cc
source/base/polynomials_bernardi_raugel.cc
source/base/polynomials_nedelec.cc
source/base/polynomials_rannacher_turek.cc
source/base/polynomials_raviart_thomas.cc
source/base/polynomials_rt_bubbles.cc
source/base/quadrature.cc
source/base/tensor_function_parser.cc
source/base/tensor_product_polynomials.cc
source/base/tensor_product_polynomials_bubbles.cc
source/base/tensor_product_polynomials_const.cc
source/distributed/fully_distributed_tria.cc
source/dofs/dof_handler.cc
source/dofs/dof_handler_policy.cc
source/dofs/dof_tools_constraints.cc
source/fe/fe_abf.cc
source/fe/fe_bdm.cc
source/fe/fe_bernardi_raugel.cc
source/fe/fe_bernstein.cc
source/fe/fe_dgp.cc
source/fe/fe_dgp_monomial.cc
source/fe/fe_dgp_nonparametric.cc
source/fe/fe_dgq.cc
source/fe/fe_enriched.cc
source/fe/fe_face.cc
source/fe/fe_nedelec.cc
source/fe/fe_nedelec_sz.cc
source/fe/fe_nothing.cc
source/fe/fe_p1nc.cc
source/fe/fe_q.cc
source/fe/fe_q_bubbles.cc
source/fe/fe_q_dg0.cc
source/fe/fe_q_hierarchical.cc
source/fe/fe_q_iso_q1.cc
source/fe/fe_rannacher_turek.cc
source/fe/fe_raviart_thomas.cc
source/fe/fe_raviart_thomas_nodal.cc
source/fe/fe_rt_bubbles.cc
source/fe/fe_system.cc
source/fe/fe_trace.cc
source/fe/fe_values.cc
source/fe/mapping_c1.cc
source/fe/mapping_cartesian.cc
source/fe/mapping_fe_field.cc
source/fe/mapping_manifold.cc
source/fe/mapping_q.cc
source/fe/mapping_q1.cc
source/fe/mapping_q1_eulerian.cc
source/fe/mapping_q_cache.cc
source/fe/mapping_q_eulerian.cc
source/fe/mapping_q_generic.cc
source/grid/manifold.cc
source/grid/manifold_lib.cc
source/grid/tria.cc
source/hp/dof_handler.cc
source/hp/fe_values.cc
source/lac/lapack_full_matrix.cc
source/lac/petsc_solver.cc
source/lac/scalapack.cc
source/lac/sparsity_pattern.cc
source/lac/sparsity_tools.cc
source/lac/trilinos_epetra_communication_pattern.cc
source/lac/trilinos_epetra_vector.cc
source/lac/trilinos_precondition_ml.cc
source/lac/trilinos_solver.cc
source/lac/trilinos_sparse_matrix.cc
source/lac/trilinos_sparsity_pattern.cc
source/lac/trilinos_tpetra_communication_pattern.cc
source/lac/trilinos_vector.cc
source/meshworker/scratch_data.cc
source/numerics/kdtree.cc
source/particles/particle_handler.cc
tests/base/dynamic_unique_cast.cc
tests/base/stdcxx14_constexpr_min_max.cc
tests/hp/laplace_mitchell2014_04_peak.cc
tests/hp/step-27.cc
tests/manifold/projection_manifold_01.cc
tests/manifold/transfinite_manifold_10.cc
tests/mappings/mapping_q_convergence.cc
tests/mappings/mapping_q_manifold_01.cc
tests/matrix_free/compress_mapping.cc
tests/matrix_free/matrix_vector_faces_12.cc
tests/matrix_free/parallel_multigrid_adaptive_07.cc
tests/mpi/petsc_step-27.cc
tests/mpi/trilinos_step-27.cc
tests/multigrid/renumbering_06.cc
tests/multigrid/renumbering_07.cc
tests/parameter_handler/patterns_08.cc
tests/parameter_handler/patterns_09.cc
tests/sparsity/sparsity_pattern_13.cc

index 7bc1a441962bde4d7202bdb0539bdb8bbd125251..bf2249fd0d2ef35fa5876b28a9f0bac76aad1662 100644 (file)
@@ -91,8 +91,8 @@ namespace python
                              boost::python::object &pull_back)
     {
       return new FunctionManifold<dim, spacedim>(
-        std_cxx14::make_unique<FunctionWrapper<dim>>(push_forward, spacedim),
-        std_cxx14::make_unique<FunctionWrapper<spacedim>>(pull_back, dim));
+        std::make_unique<FunctionWrapper<dim>>(push_forward, spacedim),
+        std::make_unique<FunctionWrapper<spacedim>>(pull_back, dim));
     }
 
 
index 702892c62b83c0032dc1749533fa9683e9f2f4f8..dbd81a07f8f574f1a9d0f05ca7fc16dc5a849129 100644 (file)
@@ -1368,14 +1368,14 @@ namespace Step13
     // having to delete the pointer after use. For initializing, we want to use
     // the C++14 function std::make_unique. Since deal.II only requires C++11 up
     // to now, we define this function in a separate namespace called
-    // `std_cxx14`. In case the compiler supports C++14, this just calls
+    // `std`. In case the compiler supports C++14, this just calls
     // std::make_unique.
     std::unique_ptr<LaplaceSolver::Base<dim>> solver;
     if (solver_name == "global")
-      solver = std_cxx14::make_unique<LaplaceSolver::RefinementGlobal<dim>>(
+      solver = std::make_unique<LaplaceSolver::RefinementGlobal<dim>>(
         triangulation, fe, quadrature, rhs_function, boundary_values);
     else if (solver_name == "kelly")
-      solver = std_cxx14::make_unique<LaplaceSolver::RefinementKelly<dim>>(
+      solver = std::make_unique<LaplaceSolver::RefinementKelly<dim>>(
         triangulation, fe, quadrature, rhs_function, boundary_values);
     else
       AssertThrow(false, ExcNotImplemented());
index 3332f75102f0046ca4641880ffd3648ba6b1cda5..e21a7627779c0ba9b9fd735134f571fe08259d43 100644 (file)
@@ -2706,56 +2706,53 @@ namespace Step14
       {
         case ProblemDescription::dual_weighted_error_estimator:
           {
-            solver =
-              std_cxx14::make_unique<LaplaceSolver::WeightedResidual<dim>>(
-                triangulation,
-                primal_fe,
-                dual_fe,
-                quadrature,
-                face_quadrature,
-                descriptor.data->get_right_hand_side(),
-                descriptor.data->get_boundary_values(),
-                *descriptor.dual_functional);
+            solver = std::make_unique<LaplaceSolver::WeightedResidual<dim>>(
+              triangulation,
+              primal_fe,
+              dual_fe,
+              quadrature,
+              face_quadrature,
+              descriptor.data->get_right_hand_side(),
+              descriptor.data->get_boundary_values(),
+              *descriptor.dual_functional);
             break;
           }
 
         case ProblemDescription::global_refinement:
           {
-            solver =
-              std_cxx14::make_unique<LaplaceSolver::RefinementGlobal<dim>>(
-                triangulation,
-                primal_fe,
-                quadrature,
-                face_quadrature,
-                descriptor.data->get_right_hand_side(),
-                descriptor.data->get_boundary_values());
+            solver = std::make_unique<LaplaceSolver::RefinementGlobal<dim>>(
+              triangulation,
+              primal_fe,
+              quadrature,
+              face_quadrature,
+              descriptor.data->get_right_hand_side(),
+              descriptor.data->get_boundary_values());
             break;
           }
 
         case ProblemDescription::kelly_indicator:
+          {
+            solver = std::make_unique<LaplaceSolver::RefinementKelly<dim>>(
+              triangulation,
+              primal_fe,
+              quadrature,
+              face_quadrature,
+              descriptor.data->get_right_hand_side(),
+              descriptor.data->get_boundary_values());
+            break;
+          }
+
+        case ProblemDescription::weighted_kelly_indicator:
           {
             solver =
-              std_cxx14::make_unique<LaplaceSolver::RefinementKelly<dim>>(
+              std::make_unique<LaplaceSolver::RefinementWeightedKelly<dim>>(
                 triangulation,
                 primal_fe,
                 quadrature,
                 face_quadrature,
                 descriptor.data->get_right_hand_side(),
-                descriptor.data->get_boundary_values());
-            break;
-          }
-
-        case ProblemDescription::weighted_kelly_indicator:
-          {
-            solver = std_cxx14::make_unique<
-              LaplaceSolver::RefinementWeightedKelly<dim>>(
-              triangulation,
-              primal_fe,
-              quadrature,
-              face_quadrature,
-              descriptor.data->get_right_hand_side(),
-              descriptor.data->get_boundary_values(),
-              *descriptor.kelly_weight);
+                descriptor.data->get_boundary_values(),
+                *descriptor.kelly_weight);
             break;
           }
 
@@ -2838,7 +2835,7 @@ int main()
       // take here the description of <code>Exercise_2_3</code>, but you can
       // also use <code>CurvedRidges@<dim@></code>:
       descriptor.data =
-        std_cxx14::make_unique<Data::SetUp<Data::Exercise_2_3<dim>, dim>>();
+        std::make_unique<Data::SetUp<Data::Exercise_2_3<dim>, dim>>();
 
       // Next set first a dual functional, then a list of evaluation
       // objects. We choose as default the evaluation of the value at an
@@ -2855,7 +2852,7 @@ int main()
       // each step.
       const Point<dim> evaluation_point(0.75, 0.75);
       descriptor.dual_functional =
-        std_cxx14::make_unique<DualFunctional::PointValueEvaluation<dim>>(
+        std::make_unique<DualFunctional::PointValueEvaluation<dim>>(
           evaluation_point);
 
       Evaluation::PointValueEvaluation<dim> postprocessor1(evaluation_point);
index 87f3bb252d31ee30ba02c6197556c082abf9bcaf..cd7d451044adbe111a166eaec4be4ee46282d6c3 100644 (file)
@@ -232,8 +232,10 @@ namespace Step27
     // Now we are ready to set-up the FESeries::Fourier object
     const std::vector<unsigned int> n_coefficients_per_direction(
       fe_collection.size(), N);
-    fourier = std_cxx14::make_unique<FESeries::Fourier<dim>>(
-      n_coefficients_per_direction, fe_collection, fourier_q_collection);
+    fourier =
+      std::make_unique<FESeries::Fourier<dim>>(n_coefficients_per_direction,
+                                               fe_collection,
+                                               fourier_q_collection);
 
     // We need to resize the matrix of fourier coefficients according to the
     // number of modes N.
index e06dc8820691469c127821a7e2e98ffe9b4ace03..f5bb6a7602485587fef00d47ceef65949052c3fe 100644 (file)
@@ -1460,7 +1460,7 @@ namespace Step28
     // of energy group objects and let them initialize their individual meshes
     // with the coarse mesh generated above:
     for (unsigned int group = 0; group < parameters.n_groups; ++group)
-      energy_groups.emplace_back(std_cxx14::make_unique<EnergyGroup<dim>>(
+      energy_groups.emplace_back(std::make_unique<EnergyGroup<dim>>(
         group, material_data, coarse_grid, fe));
     convergence_table_stream.open("convergence_table");
     convergence_table_stream.precision(12);
index 03cc1fdc1cf226ee3c086f43341f2f0c44e9b7db..b0186450357d72baab8b7f49f9dbd07238304a39 100644 (file)
@@ -237,7 +237,7 @@ namespace Step53
   // unique pointer to its base class automatically:
   std::unique_ptr<Manifold<3, 3>> AfricaGeometry::clone() const
   {
-    return std_cxx14::make_unique<AfricaGeometry>();
+    return std::make_unique<AfricaGeometry>();
   }
 
 
index acabe8459191ec790f9945f7405a6359a3780b41..8f02eb8df12e9d50e980d6cc9f5a7ef20439e870 100644 (file)
@@ -594,7 +594,7 @@ namespace Step60
   // @sect3{Set up}
   //
   // The function `DistributedLagrangeProblem::setup_grids_and_dofs()` is used
-  // to set up the finite element spaces. Notice how `std_cxx14::make_unique` is
+  // to set up the finite element spaces. Notice how `std::make_unique` is
   // used to create objects wrapped inside `std::unique_ptr` objects.
   template <int dim, int spacedim>
   void DistributedLagrangeProblem<dim, spacedim>::setup_grids_and_dofs()
@@ -603,7 +603,7 @@ namespace Step60
 
     // Initializing $\Omega$: constructing the Triangulation and wrapping it
     // into a `std::unique_ptr` object
-    space_grid = std_cxx14::make_unique<Triangulation<spacedim>>();
+    space_grid = std::make_unique<Triangulation<spacedim>>();
 
     // Next, we actually create the triangulation using
     // GridGenerator::hyper_cube(). The last argument is set to true: this
@@ -617,22 +617,22 @@ namespace Step60
     // GridTools::Cache with it.
     space_grid->refine_global(parameters.initial_refinement);
     space_grid_tools_cache =
-      std_cxx14::make_unique<GridTools::Cache<spacedim, spacedim>>(*space_grid);
+      std::make_unique<GridTools::Cache<spacedim, spacedim>>(*space_grid);
 
     // The same is done with the embedded grid. Since the embedded grid is
     // deformed, we first need to setup the deformation mapping. We do so in the
     // following few lines:
-    embedded_grid = std_cxx14::make_unique<Triangulation<dim, spacedim>>();
+    embedded_grid = std::make_unique<Triangulation<dim, spacedim>>();
     GridGenerator::hyper_cube(*embedded_grid);
     embedded_grid->refine_global(parameters.initial_embedded_refinement);
 
-    embedded_configuration_fe = std_cxx14::make_unique<FESystem<dim, spacedim>>(
+    embedded_configuration_fe = std::make_unique<FESystem<dim, spacedim>>(
       FE_Q<dim, spacedim>(
         parameters.embedded_configuration_finite_element_degree),
       spacedim);
 
     embedded_configuration_dh =
-      std_cxx14::make_unique<DoFHandler<dim, spacedim>>(*embedded_grid);
+      std::make_unique<DoFHandler<dim, spacedim>>(*embedded_grid);
 
     embedded_configuration_dh->distribute_dofs(*embedded_configuration_fe);
     embedded_configuration.reinit(embedded_configuration_dh->n_dofs());
@@ -671,16 +671,16 @@ namespace Step60
 
     if (parameters.use_displacement == true)
       embedded_mapping =
-        std_cxx14::make_unique<MappingQEulerian<dim, Vector<double>, spacedim>>(
+        std::make_unique<MappingQEulerian<dim, Vector<double>, spacedim>>(
           parameters.embedded_configuration_finite_element_degree,
           *embedded_configuration_dh,
           embedded_configuration);
     else
       embedded_mapping =
-        std_cxx14::make_unique<MappingFEField<dim,
-                                              spacedim,
-                                              Vector<double>,
-                                              DoFHandler<dim, spacedim>>>(
+        std::make_unique<MappingFEField<dim,
+                                        spacedim,
+                                        Vector<double>,
+                                        DoFHandler<dim, spacedim>>>(
           *embedded_configuration_dh, embedded_configuration);
 
     setup_embedded_dofs();
@@ -836,8 +836,8 @@ namespace Step60
   template <int dim, int spacedim>
   void DistributedLagrangeProblem<dim, spacedim>::setup_embedding_dofs()
   {
-    space_dh = std_cxx14::make_unique<DoFHandler<spacedim>>(*space_grid);
-    space_fe = std_cxx14::make_unique<FE_Q<spacedim>>(
+    space_dh = std::make_unique<DoFHandler<spacedim>>(*space_grid);
+    space_fe = std::make_unique<FE_Q<spacedim>>(
       parameters.embedding_space_finite_element_degree);
     space_dh->distribute_dofs(*space_fe);
 
@@ -863,9 +863,8 @@ namespace Step60
   template <int dim, int spacedim>
   void DistributedLagrangeProblem<dim, spacedim>::setup_embedded_dofs()
   {
-    embedded_dh =
-      std_cxx14::make_unique<DoFHandler<dim, spacedim>>(*embedded_grid);
-    embedded_fe = std_cxx14::make_unique<FE_Q<dim, spacedim>>(
+    embedded_dh = std::make_unique<DoFHandler<dim, spacedim>>(*embedded_grid);
+    embedded_fe = std::make_unique<FE_Q<dim, spacedim>>(
       parameters.embedded_space_finite_element_degree);
     embedded_dh->distribute_dofs(*embedded_fe);
 
index 67250df424de62017aa41b74021284f226c46701..8a75ab4f08ce7a791f26951841f951770e9ae124 100644 (file)
@@ -918,9 +918,9 @@ namespace Step63
         using Smoother = PreconditionSOR<SparseMatrix<double>>;
 
         auto smoother =
-          std_cxx14::make_unique<MGSmootherPrecondition<SparseMatrix<double>,
-                                                        Smoother,
-                                                        Vector<double>>>();
+          std::make_unique<MGSmootherPrecondition<SparseMatrix<double>,
+                                                  Smoother,
+                                                  Vector<double>>>();
         smoother->initialize(mg_matrices,
                              Smoother::AdditionalData(fe.degree == 1 ? 1.0 :
                                                                        0.62));
@@ -931,9 +931,9 @@ namespace Step63
       {
         using Smoother = PreconditionJacobi<SparseMatrix<double>>;
         auto smoother =
-          std_cxx14::make_unique<MGSmootherPrecondition<SparseMatrix<double>,
-                                                        Smoother,
-                                                        Vector<double>>>();
+          std::make_unique<MGSmootherPrecondition<SparseMatrix<double>,
+                                                  Smoother,
+                                                  Vector<double>>>();
         smoother->initialize(mg_matrices,
                              Smoother::AdditionalData(fe.degree == 1 ? 0.6667 :
                                                                        0.47));
@@ -991,7 +991,7 @@ namespace Step63
 
         if (settings.smoother_type == "block SOR")
           {
-            auto smoother = std_cxx14::make_unique<MGSmootherPrecondition<
+            auto smoother = std::make_unique<MGSmootherPrecondition<
               SparseMatrix<double>,
               RelaxationBlockSOR<SparseMatrix<double>, double, Vector<double>>,
               Vector<double>>>();
@@ -1001,7 +1001,7 @@ namespace Step63
           }
         else if (settings.smoother_type == "block Jacobi")
           {
-            auto smoother = std_cxx14::make_unique<
+            auto smoother = std::make_unique<
               MGSmootherPrecondition<SparseMatrix<double>,
                                      RelaxationBlockJacobi<SparseMatrix<double>,
                                                            double,
index 86f9862a7b7dd9c986b124931396434f3d3d7d16..835abf0169c306813676f5faf073cc70ada67032 100644 (file)
@@ -2012,7 +2012,7 @@ namespace Euler_DG
             triangulation.refine_global(2);
 
             euler_operator.set_inflow_boundary(
-              0, std_cxx14::make_unique<ExactSolution<dim>>(0));
+              0, std::make_unique<ExactSolution<dim>>(0));
 
             break;
           }
@@ -2023,16 +2023,16 @@ namespace Euler_DG
               triangulation, 0.03, 1, 0, true);
 
             euler_operator.set_inflow_boundary(
-              0, std_cxx14::make_unique<ExactSolution<dim>>(0));
+              0, std::make_unique<ExactSolution<dim>>(0));
             euler_operator.set_subsonic_outflow_boundary(
-              1, std_cxx14::make_unique<ExactSolution<dim>>(0));
+              1, std::make_unique<ExactSolution<dim>>(0));
 
             euler_operator.set_wall_boundary(2);
             euler_operator.set_wall_boundary(3);
 
             if (dim == 3)
               euler_operator.set_body_force(
-                std_cxx14::make_unique<Functions::ConstantFunction<dim>>(
+                std::make_unique<Functions::ConstantFunction<dim>>(
                   std::vector<double>({0., 0., -0.2})));
 
             break;
index 6ad11701ea34ddebc3ca1e48ccd1401312384b29..cdfa13c229becce80cf21f2f7bde4c97a24d4c8f 100644 (file)
@@ -1232,20 +1232,21 @@ namespace Step70
   {
     TimerOutput::Scope t(computing_timer, "Initial setup");
 
-    fluid_fe = std_cxx14::make_unique<FESystem<spacedim>>(
-      FE_Q<spacedim>(par.velocity_degree),
-      spacedim,
-      FE_Q<spacedim>(par.velocity_degree - 1),
-      1);
+    fluid_fe =
+      std::make_unique<FESystem<spacedim>>(FE_Q<spacedim>(par.velocity_degree),
+                                           spacedim,
+                                           FE_Q<spacedim>(par.velocity_degree -
+                                                          1),
+                                           1);
 
 
-    solid_fe = std_cxx14::make_unique<FE_Nothing<dim, spacedim>>();
+    solid_fe = std::make_unique<FE_Nothing<dim, spacedim>>();
     solid_dh.distribute_dofs(*solid_fe);
 
     fluid_quadrature_formula =
-      std_cxx14::make_unique<QGauss<spacedim>>(par.velocity_degree + 1);
+      std::make_unique<QGauss<spacedim>>(par.velocity_degree + 1);
     solid_quadrature_formula =
-      std_cxx14::make_unique<QGauss<dim>>(par.velocity_degree + 1);
+      std::make_unique<QGauss<dim>>(par.velocity_degree + 1);
   }
 
 
index 6da99a594321dc28b8ec1f9ce450e33045d1f4c7..ad878a53dbc36f1660157cbb5d249c886edc3a67 100644 (file)
@@ -238,10 +238,8 @@ namespace Utilities
             AssertThrowMPI(ierr);
 
             // allocate memory for answer message
-            request_buffers.emplace_back(
-              std_cxx14::make_unique<std::vector<T2>>());
-            request_requests.emplace_back(
-              std_cxx14::make_unique<MPI_Request>());
+            request_buffers.emplace_back(std::make_unique<std::vector<T2>>());
+            request_requests.emplace_back(std::make_unique<MPI_Request>());
 
             // process request
             auto &request_buffer = *request_buffers.back();
index 206401efabb371b6cba607d13fbc10ac636442b1..b593ca0552e81d1f852f62a2fa5f20140ebbd00e 100644 (file)
@@ -1939,7 +1939,7 @@ operator|(const ParameterHandler::OutputStyle f1,
  *
  *     void HelperClass::create_new (const unsigned int run_no)
  *     {
- *       p = std_cxx14::make_unique<Problem>());
+ *       p = std::make_unique<Problem>());
  *     }
  *
  *
index a4582cd63c64b4978d7ab67abe50bedc229b12cc..b5698fd43a666c68133eeacc7de38c3020f04ce5 100644 (file)
@@ -1504,7 +1504,7 @@ namespace Patterns
                                 std::unique_ptr<Patterns::PatternBase>>::type
         to_pattern()
       {
-        return std_cxx14::make_unique<Patterns::Bool>();
+        return std::make_unique<Patterns::Bool>();
       }
 
       template <typename Dummy = T>
@@ -1515,7 +1515,7 @@ namespace Patterns
                                 std::unique_ptr<Patterns::PatternBase>>::type
         to_pattern()
       {
-        return std_cxx14::make_unique<Patterns::Integer>(
+        return std::make_unique<Patterns::Integer>(
           std::numeric_limits<T>::lowest(), std::numeric_limits<T>::max());
       }
 
@@ -1527,7 +1527,7 @@ namespace Patterns
                                 std::unique_ptr<Patterns::PatternBase>>::type
         to_pattern()
       {
-        return std_cxx14::make_unique<Patterns::Double>(
+        return std::make_unique<Patterns::Double>(
           std::numeric_limits<T>::lowest(), std::numeric_limits<T>::max());
       }
 
@@ -1677,8 +1677,7 @@ namespace Patterns
       constexpr int
       max_list_rank()
       {
-        return std_cxx14::max(RankInfo<T1>::list_rank,
-                              max_list_rank<T2, Types...>());
+        return std::max(RankInfo<T1>::list_rank, max_list_rank<T2, Types...>());
       }
 
       // Helper function for map_rank
@@ -1693,8 +1692,7 @@ namespace Patterns
       constexpr int
       max_map_rank()
       {
-        return std_cxx14::max(RankInfo<T1>::map_rank,
-                              max_map_rank<T2, Types...>());
+        return std::max(RankInfo<T1>::map_rank, max_map_rank<T2, Types...>());
       }
 
       // Rank of vector types
@@ -1762,10 +1760,9 @@ namespace Patterns
       struct RankInfo<std::pair<Key, Value>>
       {
         static constexpr int list_rank =
-          std_cxx14::max(RankInfo<Key>::list_rank, RankInfo<Value>::list_rank);
+          std::max(RankInfo<Key>::list_rank, RankInfo<Value>::list_rank);
         static constexpr int map_rank =
-          std_cxx14::max(RankInfo<Key>::map_rank, RankInfo<Value>::map_rank) +
-          1;
+          std::max(RankInfo<Key>::map_rank, RankInfo<Value>::map_rank) + 1;
       };
 
 
@@ -1787,7 +1784,7 @@ namespace Patterns
       {
         static_assert(internal::RankInfo<T>::list_rank > 0,
                       "Cannot use this class for non List-compatible types.");
-        return std_cxx14::make_unique<Patterns::List>(
+        return std::make_unique<Patterns::List>(
           *Convert<typename T::value_type>::to_pattern(),
           0,
           std::numeric_limits<unsigned int>::max(),
@@ -1857,7 +1854,7 @@ namespace Patterns
                       "Cannot use this class for non List-compatible types.");
         static_assert(internal::RankInfo<T>::map_rank > 0,
                       "Cannot use this class for non Map-compatible types.");
-        return std_cxx14::make_unique<Patterns::Map>(
+        return std::make_unique<Patterns::Map>(
           *Convert<typename T::key_type>::to_pattern(),
           *Convert<typename T::mapped_type>::to_pattern(),
           0,
@@ -1938,7 +1935,7 @@ namespace Patterns
       {
         static_assert(internal::RankInfo<T>::list_rank > 0,
                       "Cannot use this class for non List-compatible types.");
-        return std_cxx14::make_unique<Patterns::List>(
+        return std::make_unique<Patterns::List>(
           *Convert<typename T::value_type>::to_pattern(),
           dim,
           dim,
@@ -2037,7 +2034,7 @@ namespace Patterns
         static_assert(internal::RankInfo<T>::list_rank > 0,
                       "Cannot use this class for non List-compatible types.");
 
-        return std_cxx14::make_unique<Patterns::List>(
+        return std::make_unique<Patterns::List>(
           Patterns::Anything(),
           1,
           Patterns::List::max_int_value,
@@ -2082,7 +2079,7 @@ namespace Patterns
         const auto expressions =
           Utilities::split_string_list(s, p->get_separator());
 
-        T t = std_cxx14::make_unique<FunctionParser<dim>>(expressions.size());
+        T t = std::make_unique<FunctionParser<dim>>(expressions.size());
         const std::string var =
           FunctionParser<dim>::default_variable_names() + ",t";
         const typename FunctionParser<dim>::ConstMap constants;
@@ -2136,7 +2133,7 @@ namespace Patterns
       {
         static_assert(internal::RankInfo<T>::list_rank > 0,
                       "Cannot use this class for non List-compatible types.");
-        return std_cxx14::make_unique<Patterns::List>(
+        return std::make_unique<Patterns::List>(
           *Convert<typename T::value_type>::to_pattern(),
           2,
           2,
@@ -2198,7 +2195,7 @@ namespace Patterns
       static std::unique_ptr<Patterns::PatternBase>
       to_pattern()
       {
-        return std_cxx14::make_unique<Patterns::Anything>();
+        return std::make_unique<Patterns::Anything>();
       }
 
       static std::string
@@ -2231,7 +2228,7 @@ namespace Patterns
       {
         static_assert(internal::RankInfo<T>::map_rank > 0,
                       "Cannot use this class for non Map-compatible types.");
-        return std_cxx14::make_unique<Patterns::Tuple>(
+        return std::make_unique<Patterns::Tuple>(
           internal::default_map_separator[internal::RankInfo<T>::map_rank - 1],
           *Convert<Key>::to_pattern(),
           *Convert<Value>::to_pattern());
@@ -2270,7 +2267,7 @@ namespace Patterns
       {
         static_assert(internal::RankInfo<T>::map_rank > 0,
                       "Cannot use this class for non tuple-compatible types.");
-        return std_cxx14::make_unique<Patterns::Tuple>(
+        return std::make_unique<Patterns::Tuple>(
           internal::default_map_separator[internal::RankInfo<T>::map_rank - 1],
           *Convert<Args>::to_pattern()...);
       }
@@ -2315,7 +2312,7 @@ namespace Patterns
       static std::array<std::string, std::tuple_size<T>::value>
       to_string_internal_1(const T &              t,
                            const Patterns::Tuple &pattern,
-                           std_cxx14::index_sequence<U...>)
+                           std::index_sequence<U...>)
       {
         std::array<std::string, std::tuple_size<T>::value> a = {
           {Convert<typename std::tuple_element<U, T>::type>::to_string(
@@ -2327,16 +2324,14 @@ namespace Patterns
       to_string_internal_2(const T &t, const Patterns::Tuple &pattern)
       {
         return Convert<T>::to_string_internal_1(
-          t,
-          pattern,
-          std_cxx14::make_index_sequence<std::tuple_size<T>::value>{});
+          t, pattern, std::make_index_sequence<std::tuple_size<T>::value>{});
       }
 
       template <std::size_t... U>
       static T
       to_value_internal_1(const std::vector<std::string> &s,
                           const Patterns::Tuple &         pattern,
-                          std_cxx14::index_sequence<U...>)
+                          std::index_sequence<U...>)
       {
         return std::make_tuple(
           Convert<typename std::tuple_element<U, T>::type>::to_value(
@@ -2348,9 +2343,7 @@ namespace Patterns
                           const Patterns::Tuple &         pattern)
       {
         return Convert<T>::to_value_internal_1(
-          s,
-          pattern,
-          std_cxx14::make_index_sequence<std::tuple_size<T>::value>{});
+          s, pattern, std::make_index_sequence<std::tuple_size<T>::value>{});
       }
     };
 
index 5f2dc4b488161caf6d848292122d0b6388822f2f..c5cb90d2ea5d561fa141a9ed5867df3cc8c8a0a9 100644 (file)
@@ -82,7 +82,7 @@ public:
   std::unique_ptr<ScalarPolynomialsBase<dim>>
   clone() const override
   {
-    return std_cxx14::make_unique<PolynomialsP<dim>>(*this);
+    return std::make_unique<PolynomialsP<dim>>(*this);
   }
 
 private:
index e3a465a317c035f90535c003e89f301e3578e3c7..2228e155778f21b11e17231215940a145f6416c2 100644 (file)
@@ -29,7 +29,7 @@ namespace std_cxx17
 #ifndef __cpp_lib_apply
   template <typename F, typename Tuple, size_t... S>
   auto
-  apply_impl(F &&fn, Tuple &&t, std_cxx14::index_sequence<S...>)
+  apply_impl(F &&fn, Tuple &&t, std::index_sequence<S...>)
     -> decltype(std::forward<F>(fn)(std::get<S>(std::forward<Tuple>(t))...))
   {
     return std::forward<F>(fn)(std::get<S>(std::forward<Tuple>(t))...);
@@ -40,14 +40,14 @@ namespace std_cxx17
   apply(F &&fn, Tuple &&t) -> decltype(apply_impl(
     std::forward<F>(fn),
     std::forward<Tuple>(t),
-    std_cxx14::make_index_sequence<
+    std::make_index_sequence<
       std::tuple_size<typename std::remove_reference<Tuple>::type>::value>()))
   {
     std::size_t constexpr tSize =
       std::tuple_size<typename std::remove_reference<Tuple>::type>::value;
     return apply_impl(std::forward<F>(fn),
                       std::forward<Tuple>(t),
-                      std_cxx14::make_index_sequence<tSize>());
+                      std::make_index_sequence<tSize>());
   }
 #else
   using std::apply;
index 9580b92999409a467a33755180a47d7a683788de..c8ecc33b57d4db6195371aecbf85b3a004d7701c 100644 (file)
@@ -774,7 +774,7 @@ private:
    */
   template <typename ArrayLike, std::size_t... Indices>
   constexpr DEAL_II_CUDA_HOST_DEV
-  Tensor(const ArrayLike &initializer, std_cxx14::index_sequence<Indices...>);
+  Tensor(const ArrayLike &initializer, std::index_sequence<Indices...>);
 
   // Allow an arbitrary Tensor to access the underlying values.
   template <int, int, typename>
@@ -1143,7 +1143,7 @@ template <int rank_, int dim, typename Number>
 template <typename ArrayLike, std::size_t... indices>
 constexpr DEAL_II_ALWAYS_INLINE DEAL_II_CUDA_HOST_DEV
                                 Tensor<rank_, dim, Number>::Tensor(const ArrayLike &initializer,
-                                   std_cxx14::index_sequence<indices...>)
+                                   std::index_sequence<indices...>)
   : values{Tensor<rank_ - 1, dim, Number>(initializer[indices])...}
 {
   static_assert(sizeof...(indices) == dim,
@@ -1154,7 +1154,7 @@ constexpr DEAL_II_ALWAYS_INLINE DEAL_II_CUDA_HOST_DEV
 template <int rank_, int dim, typename Number>
 constexpr DEAL_II_ALWAYS_INLINE DEAL_II_CUDA_HOST_DEV
                                 Tensor<rank_, dim, Number>::Tensor(const array_type &initializer)
-  : Tensor(initializer, std_cxx14::make_index_sequence<dim>{})
+  : Tensor(initializer, std::make_index_sequence<dim>{})
 {}
 
 
@@ -1163,7 +1163,7 @@ template <typename OtherNumber>
 constexpr DEAL_II_ALWAYS_INLINE DEAL_II_CUDA_HOST_DEV
                                 Tensor<rank_, dim, Number>::Tensor(
   const Tensor<rank_, dim, OtherNumber> &initializer)
-  : Tensor(initializer, std_cxx14::make_index_sequence<dim>{})
+  : Tensor(initializer, std::make_index_sequence<dim>{})
 {}
 
 
@@ -1172,7 +1172,7 @@ template <typename OtherNumber>
 constexpr DEAL_II_ALWAYS_INLINE
 Tensor<rank_, dim, Number>::Tensor(
   const Tensor<1, dim, Tensor<rank_ - 1, dim, OtherNumber>> &initializer)
-  : Tensor(initializer, std_cxx14::make_index_sequence<dim>{})
+  : Tensor(initializer, std::make_index_sequence<dim>{})
 {}
 
 
index dce721214189c6a64e155491bfe4b4e100317735..69e85b6b3dd7714a91abba90b32047915e6648b1 100644 (file)
@@ -61,8 +61,7 @@ template <class PolynomialType, int dim, int spacedim>
 std::unique_ptr<FiniteElement<dim, spacedim>>
 FE_DGVector<PolynomialType, dim, spacedim>::clone() const
 {
-  return std_cxx14::make_unique<FE_DGVector<PolynomialType, dim, spacedim>>(
-    *this);
+  return std::make_unique<FE_DGVector<PolynomialType, dim, spacedim>>(*this);
 }
 
 
index dc9194ce422500827cefa97e8811d3a2f307c247..178293f1499fa17d66b3a90a91c448c8609a1efc 100644 (file)
@@ -343,7 +343,7 @@ protected:
                                                                        spacedim>
       & /*output_data*/) const override
   {
-    return std_cxx14::make_unique<
+    return std::make_unique<
       typename FiniteElement<1, spacedim>::InternalDataBase>();
   }
 
@@ -357,8 +357,8 @@ protected:
       & /*output_data*/) const override
   {
     // generate a new data object and initialize some fields
-    auto data_ptr = std_cxx14::make_unique<
-      typename FiniteElement<1, spacedim>::InternalDataBase>();
+    auto data_ptr =
+      std::make_unique<typename FiniteElement<1, spacedim>::InternalDataBase>();
     data_ptr->update_each = requires_update_flags(update_flags);
 
     const unsigned int n_q_points = quadrature.size();
index 23834d51a3094f440d1a36dfc5e0763fa2161dde..2afd1087d97cbe1ca6bf3fb8a266eed2e33874ef 100644 (file)
@@ -264,7 +264,7 @@ protected:
     // generate a new data object and
     // initialize some fields
     std::unique_ptr<typename FiniteElement<dim, spacedim>::InternalDataBase>
-          data_ptr   = std_cxx14::make_unique<InternalData>();
+          data_ptr   = std::make_unique<InternalData>();
     auto &data       = dynamic_cast<InternalData &>(*data_ptr);
     data.update_each = requires_update_flags(update_flags);
 
index c6a47626cf54597f9c43e4d0ddbdd019e7184672..f07e5a7381099c367fc7c34b88992d21aaff0a29 100644 (file)
@@ -97,7 +97,7 @@ protected:
                                                                        spacedim>
       & /*output_data*/) const override
   {
-    return std_cxx14::make_unique<InternalData>();
+    return std::make_unique<InternalData>();
   }
 
   std::unique_ptr<typename FiniteElement<dim, spacedim>::InternalDataBase>
@@ -112,7 +112,7 @@ protected:
     // generate a new data object and
     // initialize some fields
     std::unique_ptr<typename FiniteElement<dim, spacedim>::InternalDataBase>
-          data_ptr   = std_cxx14::make_unique<InternalData>();
+          data_ptr   = std::make_unique<InternalData>();
     auto &data       = dynamic_cast<InternalData &>(*data_ptr);
     data.update_each = requires_update_flags(update_flags);
 
index 48f2dc887b5762a88a138b8f84f8f53ffc7a3f5b..0bf7b691edf0cb39bc17df7eafb134c36842c531 100644 (file)
@@ -248,7 +248,7 @@ protected:
     // generate a new data object and
     // initialize some fields
     std::unique_ptr<typename FiniteElement<dim, spacedim>::InternalDataBase>
-          data_ptr   = std_cxx14::make_unique<InternalData>();
+          data_ptr   = std::make_unique<InternalData>();
     auto &data       = dynamic_cast<InternalData &>(*data_ptr);
     data.update_each = requires_update_flags(update_flags);
 
index 060f15571720912c1b91527ebbb32f1dff61c37c..fe8b0821fcd434209bee14b5ff0ca5a0b90f9d15 100644 (file)
@@ -1477,7 +1477,7 @@ namespace FETools
   std::unique_ptr<FiniteElement<FE::dimension, FE::space_dimension>>
   FEFactory<FE>::get(const unsigned int degree) const
   {
-    return std_cxx14::make_unique<FE>(degree);
+    return std::make_unique<FE>(degree);
   }
 
   namespace Compositing
index 8eefec7ae619d26180011a79f9b0f166d7a14590..2e4073539655192ce4047ae80f7e8104376fedbe 100644 (file)
@@ -1035,21 +1035,21 @@ namespace FETools
   std::unique_ptr<FiniteElement<1, 1>>
   FEFactory<FE_Q<1, 1>>::get(const Quadrature<1> &quad) const
   {
-    return std_cxx14::make_unique<FE_Q<1>>(quad);
+    return std::make_unique<FE_Q<1>>(quad);
   }
 
   template <>
   std::unique_ptr<FiniteElement<2, 2>>
   FEFactory<FE_Q<2, 2>>::get(const Quadrature<1> &quad) const
   {
-    return std_cxx14::make_unique<FE_Q<2>>(quad);
+    return std::make_unique<FE_Q<2>>(quad);
   }
 
   template <>
   std::unique_ptr<FiniteElement<3, 3>>
   FEFactory<FE_Q<3, 3>>::get(const Quadrature<1> &quad) const
   {
-    return std_cxx14::make_unique<FE_Q<3>>(quad);
+    return std::make_unique<FE_Q<3>>(quad);
   }
 
   // Specializations for FE_Q_DG0.
@@ -1057,21 +1057,21 @@ namespace FETools
   std::unique_ptr<FiniteElement<1, 1>>
   FEFactory<FE_Q_DG0<1, 1>>::get(const Quadrature<1> &quad) const
   {
-    return std_cxx14::make_unique<FE_Q_DG0<1>>(quad);
+    return std::make_unique<FE_Q_DG0<1>>(quad);
   }
 
   template <>
   std::unique_ptr<FiniteElement<2, 2>>
   FEFactory<FE_Q_DG0<2, 2>>::get(const Quadrature<1> &quad) const
   {
-    return std_cxx14::make_unique<FE_Q_DG0<2>>(quad);
+    return std::make_unique<FE_Q_DG0<2>>(quad);
   }
 
   template <>
   std::unique_ptr<FiniteElement<3, 3>>
   FEFactory<FE_Q_DG0<3, 3>>::get(const Quadrature<1> &quad) const
   {
-    return std_cxx14::make_unique<FE_Q_DG0<3>>(quad);
+    return std::make_unique<FE_Q_DG0<3>>(quad);
   }
 
   // Specializations for FE_Q_Bubbles.
@@ -1079,21 +1079,21 @@ namespace FETools
   std::unique_ptr<FiniteElement<1, 1>>
   FEFactory<FE_Q_Bubbles<1, 1>>::get(const Quadrature<1> &quad) const
   {
-    return std_cxx14::make_unique<FE_Q_Bubbles<1>>(quad);
+    return std::make_unique<FE_Q_Bubbles<1>>(quad);
   }
 
   template <>
   std::unique_ptr<FiniteElement<2, 2>>
   FEFactory<FE_Q_Bubbles<2, 2>>::get(const Quadrature<1> &quad) const
   {
-    return std_cxx14::make_unique<FE_Q_Bubbles<2>>(quad);
+    return std::make_unique<FE_Q_Bubbles<2>>(quad);
   }
 
   template <>
   std::unique_ptr<FiniteElement<3, 3>>
   FEFactory<FE_Q_Bubbles<3, 3>>::get(const Quadrature<1> &quad) const
   {
-    return std_cxx14::make_unique<FE_Q_Bubbles<3>>(quad);
+    return std::make_unique<FE_Q_Bubbles<3>>(quad);
   }
 
   // Specializations for FE_DGQArbitraryNodes.
@@ -1101,42 +1101,42 @@ namespace FETools
   std::unique_ptr<FiniteElement<1, 1>>
   FEFactory<FE_DGQ<1>>::get(const Quadrature<1> &quad) const
   {
-    return std_cxx14::make_unique<FE_DGQArbitraryNodes<1>>(quad);
+    return std::make_unique<FE_DGQArbitraryNodes<1>>(quad);
   }
 
   template <>
   std::unique_ptr<FiniteElement<1, 2>>
   FEFactory<FE_DGQ<1, 2>>::get(const Quadrature<1> &quad) const
   {
-    return std_cxx14::make_unique<FE_DGQArbitraryNodes<1, 2>>(quad);
+    return std::make_unique<FE_DGQArbitraryNodes<1, 2>>(quad);
   }
 
   template <>
   std::unique_ptr<FiniteElement<1, 3>>
   FEFactory<FE_DGQ<1, 3>>::get(const Quadrature<1> &quad) const
   {
-    return std_cxx14::make_unique<FE_DGQArbitraryNodes<1, 3>>(quad);
+    return std::make_unique<FE_DGQArbitraryNodes<1, 3>>(quad);
   }
 
   template <>
   std::unique_ptr<FiniteElement<2, 2>>
   FEFactory<FE_DGQ<2>>::get(const Quadrature<1> &quad) const
   {
-    return std_cxx14::make_unique<FE_DGQArbitraryNodes<2>>(quad);
+    return std::make_unique<FE_DGQArbitraryNodes<2>>(quad);
   }
 
   template <>
   std::unique_ptr<FiniteElement<2, 3>>
   FEFactory<FE_DGQ<2, 3>>::get(const Quadrature<1> &quad) const
   {
-    return std_cxx14::make_unique<FE_DGQArbitraryNodes<2, 3>>(quad);
+    return std::make_unique<FE_DGQArbitraryNodes<2, 3>>(quad);
   }
 
   template <>
   std::unique_ptr<FiniteElement<3, 3>>
   FEFactory<FE_DGQ<3>>::get(const Quadrature<1> &quad) const
   {
-    return std_cxx14::make_unique<FE_DGQArbitraryNodes<3>>(quad);
+    return std::make_unique<FE_DGQArbitraryNodes<3>>(quad);
   }
 
 
@@ -1156,57 +1156,52 @@ namespace FETools
         std::map<std::string, std::unique_ptr<const Subscriptor>> &result)
       {
         result["FE_Q_Hierarchical"] =
-          std_cxx14::make_unique<FETools::FEFactory<FE_Q_Hierarchical<dim>>>();
-        result["FE_ABF"] =
-          std_cxx14::make_unique<FETools::FEFactory<FE_ABF<dim>>>();
+          std::make_unique<FETools::FEFactory<FE_Q_Hierarchical<dim>>>();
+        result["FE_ABF"] = std::make_unique<FETools::FEFactory<FE_ABF<dim>>>();
         result["FE_Bernstein"] =
-          std_cxx14::make_unique<FETools::FEFactory<FE_Bernstein<dim>>>();
-        result["FE_BDM"] =
-          std_cxx14::make_unique<FETools::FEFactory<FE_BDM<dim>>>();
+          std::make_unique<FETools::FEFactory<FE_Bernstein<dim>>>();
+        result["FE_BDM"] = std::make_unique<FETools::FEFactory<FE_BDM<dim>>>();
         result["FE_DGBDM"] =
-          std_cxx14::make_unique<FETools::FEFactory<FE_DGBDM<dim>>>();
+          std::make_unique<FETools::FEFactory<FE_DGBDM<dim>>>();
         result["FE_DGNedelec"] =
-          std_cxx14::make_unique<FETools::FEFactory<FE_DGNedelec<dim>>>();
+          std::make_unique<FETools::FEFactory<FE_DGNedelec<dim>>>();
         result["FE_DGRaviartThomas"] =
-          std_cxx14::make_unique<FETools::FEFactory<FE_DGRaviartThomas<dim>>>();
+          std::make_unique<FETools::FEFactory<FE_DGRaviartThomas<dim>>>();
         result["FE_RaviartThomas"] =
-          std_cxx14::make_unique<FETools::FEFactory<FE_RaviartThomas<dim>>>();
-        result["FE_RaviartThomasNodal"] = std_cxx14::make_unique<
-          FETools::FEFactory<FE_RaviartThomasNodal<dim>>>();
+          std::make_unique<FETools::FEFactory<FE_RaviartThomas<dim>>>();
+        result["FE_RaviartThomasNodal"] =
+          std::make_unique<FETools::FEFactory<FE_RaviartThomasNodal<dim>>>();
         result["FE_RT_Bubbles"] =
-          std_cxx14::make_unique<FETools::FEFactory<FE_RT_Bubbles<dim>>>();
+          std::make_unique<FETools::FEFactory<FE_RT_Bubbles<dim>>>();
         result["FE_Nedelec"] =
-          std_cxx14::make_unique<FETools::FEFactory<FE_Nedelec<dim>>>();
-        result["FE_DGPNonparametric"] = std_cxx14::make_unique<
-          FETools::FEFactory<FE_DGPNonparametric<dim>>>();
-        result["FE_DGP"] =
-          std_cxx14::make_unique<FETools::FEFactory<FE_DGP<dim>>>();
+          std::make_unique<FETools::FEFactory<FE_Nedelec<dim>>>();
+        result["FE_DGPNonparametric"] =
+          std::make_unique<FETools::FEFactory<FE_DGPNonparametric<dim>>>();
+        result["FE_DGP"] = std::make_unique<FETools::FEFactory<FE_DGP<dim>>>();
         result["FE_DGPMonomial"] =
-          std_cxx14::make_unique<FETools::FEFactory<FE_DGPMonomial<dim>>>();
-        result["FE_DGQ"] =
-          std_cxx14::make_unique<FETools::FEFactory<FE_DGQ<dim>>>();
+          std::make_unique<FETools::FEFactory<FE_DGPMonomial<dim>>>();
+        result["FE_DGQ"] = std::make_unique<FETools::FEFactory<FE_DGQ<dim>>>();
         result["FE_DGQArbitraryNodes"] =
-          std_cxx14::make_unique<FETools::FEFactory<FE_DGQ<dim>>>();
+          std::make_unique<FETools::FEFactory<FE_DGQ<dim>>>();
         result["FE_DGQLegendre"] =
-          std_cxx14::make_unique<FETools::FEFactory<FE_DGQLegendre<dim>>>();
+          std::make_unique<FETools::FEFactory<FE_DGQLegendre<dim>>>();
         result["FE_DGQHermite"] =
-          std_cxx14::make_unique<FETools::FEFactory<FE_DGQHermite<dim>>>();
+          std::make_unique<FETools::FEFactory<FE_DGQHermite<dim>>>();
         result["FE_FaceQ"] =
-          std_cxx14::make_unique<FETools::FEFactory<FE_FaceQ<dim>>>();
+          std::make_unique<FETools::FEFactory<FE_FaceQ<dim>>>();
         result["FE_FaceP"] =
-          std_cxx14::make_unique<FETools::FEFactory<FE_FaceP<dim>>>();
-        result["FE_Q"] =
-          std_cxx14::make_unique<FETools::FEFactory<FE_Q<dim>>>();
+          std::make_unique<FETools::FEFactory<FE_FaceP<dim>>>();
+        result["FE_Q"] = std::make_unique<FETools::FEFactory<FE_Q<dim>>>();
         result["FE_Q_DG0"] =
-          std_cxx14::make_unique<FETools::FEFactory<FE_Q_DG0<dim>>>();
+          std::make_unique<FETools::FEFactory<FE_Q_DG0<dim>>>();
         result["FE_Q_Bubbles"] =
-          std_cxx14::make_unique<FETools::FEFactory<FE_Q_Bubbles<dim>>>();
+          std::make_unique<FETools::FEFactory<FE_Q_Bubbles<dim>>>();
         result["FE_Q_iso_Q1"] =
-          std_cxx14::make_unique<FETools::FEFactory<FE_Q_iso_Q1<dim>>>();
+          std::make_unique<FETools::FEFactory<FE_Q_iso_Q1<dim>>>();
         result["FE_Nothing"] =
-          std_cxx14::make_unique<FETools::FEFactory<FE_Nothing<dim>>>();
+          std::make_unique<FETools::FEFactory<FE_Nothing<dim>>>();
         result["FE_RannacherTurek"] =
-          std_cxx14::make_unique<FETools::FEFactory<FE_RannacherTurek<dim>>>();
+          std::make_unique<FETools::FEFactory<FE_RannacherTurek<dim>>>();
       }
 
 
@@ -1219,30 +1214,30 @@ namespace FETools
       fill_codim_fe_names(
         std::map<std::string, std::unique_ptr<const Subscriptor>> &result)
       {
-        result["FE_Bernstein"] = std_cxx14::make_unique<
-          FETools::FEFactory<FE_Bernstein<dim, spacedim>>>();
+        result["FE_Bernstein"] =
+          std::make_unique<FETools::FEFactory<FE_Bernstein<dim, spacedim>>>();
         result["FE_DGP"] =
-          std_cxx14::make_unique<FETools::FEFactory<FE_DGP<dim, spacedim>>>();
+          std::make_unique<FETools::FEFactory<FE_DGP<dim, spacedim>>>();
         result["FE_DGQ"] =
-          std_cxx14::make_unique<FETools::FEFactory<FE_DGQ<dim, spacedim>>>();
-        result["FE_Nothing"] = std_cxx14::make_unique<
-          FETools::FEFactory<FE_Nothing<dim, spacedim>>>();
+          std::make_unique<FETools::FEFactory<FE_DGQ<dim, spacedim>>>();
+        result["FE_Nothing"] =
+          std::make_unique<FETools::FEFactory<FE_Nothing<dim, spacedim>>>();
         result["FE_DGQArbitraryNodes"] =
-          std_cxx14::make_unique<FETools::FEFactory<FE_DGQ<dim, spacedim>>>();
-        result["FE_DGQLegendre"] = std_cxx14::make_unique<
-          FETools::FEFactory<FE_DGQLegendre<dim, spacedim>>>();
-        result["FE_DGQHermite"] = std_cxx14::make_unique<
-          FETools::FEFactory<FE_DGQHermite<dim, spacedim>>>();
-        result["FE_Q_Bubbles"] = std_cxx14::make_unique<
-          FETools::FEFactory<FE_Q_Bubbles<dim, spacedim>>>();
+          std::make_unique<FETools::FEFactory<FE_DGQ<dim, spacedim>>>();
+        result["FE_DGQLegendre"] =
+          std::make_unique<FETools::FEFactory<FE_DGQLegendre<dim, spacedim>>>();
+        result["FE_DGQHermite"] =
+          std::make_unique<FETools::FEFactory<FE_DGQHermite<dim, spacedim>>>();
+        result["FE_Q_Bubbles"] =
+          std::make_unique<FETools::FEFactory<FE_Q_Bubbles<dim, spacedim>>>();
         result["FE_Q_DG0"] =
-          std_cxx14::make_unique<FETools::FEFactory<FE_Q_DG0<dim, spacedim>>>();
-        result["FE_Q_iso_Q1"] = std_cxx14::make_unique<
-          FETools::FEFactory<FE_Q_iso_Q1<dim, spacedim>>>();
+          std::make_unique<FETools::FEFactory<FE_Q_DG0<dim, spacedim>>>();
+        result["FE_Q_iso_Q1"] =
+          std::make_unique<FETools::FEFactory<FE_Q_iso_Q1<dim, spacedim>>>();
         result["FE_Q"] =
-          std_cxx14::make_unique<FETools::FEFactory<FE_Q<dim, spacedim>>>();
-        result["FE_Bernstein"] = std_cxx14::make_unique<
-          FETools::FEFactory<FE_Bernstein<dim, spacedim>>>();
+          std::make_unique<FETools::FEFactory<FE_Q<dim, spacedim>>>();
+        result["FE_Bernstein"] =
+          std::make_unique<FETools::FEFactory<FE_Bernstein<dim, spacedim>>>();
       }
 
       // The function filling the vector fe_name_map below. It iterates
@@ -2508,7 +2503,7 @@ namespace FETools
 
             // ok, apparently everything went ok. so generate the composed
             // element. and return it.
-            return std_cxx14::make_unique<FESystem<dim, spacedim>>(
+            return std::make_unique<FESystem<dim, spacedim>>(
               raw_base_fes, base_multiplicities);
           }
         else if (name_part == "FE_Nothing")
index b108dd5e4e42a6190be3d4c8a0ca6d5517684e03..e0181c8fd98e67de6b95b923cd4848307467f52c 100644 (file)
@@ -192,8 +192,8 @@ namespace FETools
                 .get() == nullptr)
             {
               auto interpolation_matrix =
-                std_cxx14::make_unique<FullMatrix<double>>(dofs_per_cell2,
-                                                           dofs_per_cell1);
+                std::make_unique<FullMatrix<double>>(dofs_per_cell2,
+                                                     dofs_per_cell1);
 
               get_interpolation_matrix(cell1->get_fe(),
                                        cell2->get_fe(),
@@ -342,8 +342,8 @@ namespace FETools
           if (interpolation_matrices[&cell->get_fe()] == nullptr)
             {
               interpolation_matrices[&cell->get_fe()] =
-                std_cxx14::make_unique<FullMatrix<double>>(dofs_per_cell1,
-                                                           dofs_per_cell1);
+                std::make_unique<FullMatrix<double>>(dofs_per_cell1,
+                                                     dofs_per_cell1);
               get_back_interpolation_matrix(
                 cell->get_fe(), fe2, *interpolation_matrices[&cell->get_fe()]);
             }
index eab1e6386baff475715fc3d8fe04e899f1b7c95d..b60f198d814efb4f9ab99e360e417398831f5a08 100644 (file)
@@ -161,7 +161,7 @@ std::unique_ptr<Manifold<dim, spacedim>>
 CompositionManifold<dim, spacedim, chartdim, intermediate_dim, dim1, dim2>::
   clone() const
 {
-  return std_cxx14::make_unique<
+  return std::make_unique<
     CompositionManifold<dim, spacedim, chartdim, intermediate_dim, dim1, dim2>>(
     *F, *G);
 }
index 982e97b01eee83f8b3d3c89bc8fe720d25e3b24f..d27e870f7080150f488da30d49f6742384e43041 100644 (file)
@@ -1152,7 +1152,7 @@ template <typename Predicate>
 std::unique_ptr<typename FilteredIterator<BaseIterator>::PredicateBase>
 FilteredIterator<BaseIterator>::PredicateTemplate<Predicate>::clone() const
 {
-  return std_cxx14::make_unique<PredicateTemplate>(predicate);
+  return std::make_unique<PredicateTemplate>(predicate);
 }
 
 
index eaa7ce15431839f5ad8dd3ce123e3b026c8e74cf..7016135be2558258ff471a2e72c5cf99fe0347fd 100644 (file)
@@ -620,8 +620,8 @@ public:
    * This constructor is useful because it allows creating function objects at
    * the place of calling the constructor without having to name and later
    * delete these objects. This allows the following idiom:
-   * FunctionManifold<dim> manifold(std_cxx14::make_unique<MyPushForward>(...),
-   *                                std_cxx14::make_unique<MyPullBack>(...));
+   * FunctionManifold<dim> manifold(std::make_unique<MyPushForward>(...),
+   *                                std::make_unique<MyPullBack>(...));
    */
   FunctionManifold(
     std::unique_ptr<Function<chartdim>> push_forward,
index 5f371c3437f041d7fd93138ba442acdd2f3ac0c7..c222a2faa52156a2904f6599a1c7cdb95547c9b4 100644 (file)
@@ -216,14 +216,14 @@ TensorProductManifold<dim,
                       spacedim_B,
                       chartdim_B>::clone() const
 {
-  return std_cxx14::make_unique<TensorProductManifold<dim,
-                                                      dim_A,
-                                                      spacedim_A,
-                                                      chartdim_A,
-                                                      dim_B,
-                                                      spacedim_B,
-                                                      chartdim_B>>(*manifold_A,
-                                                                   *manifold_B);
+  return std::make_unique<TensorProductManifold<dim,
+                                                dim_A,
+                                                spacedim_A,
+                                                chartdim_A,
+                                                dim_B,
+                                                spacedim_B,
+                                                chartdim_B>>(*manifold_A,
+                                                             *manifold_B);
 }
 
 template <int dim,
index 5b0ace4293e3b27ae6cbdb2bad4ca5030ee640eb..cf6c4dc944583a584110279f424b9b192df6de9f 100644 (file)
@@ -450,7 +450,7 @@ ChunkSparseMatrix<number>::reinit(const ChunkSparsityPattern &sparsity)
     cols->sparsity_pattern.n_nonzero_elements() * chunk_size * chunk_size;
   if (N > max_len || max_len == 0)
     {
-      val     = std_cxx14::make_unique<number[]>(N);
+      val     = std::make_unique<number[]>(N);
       max_len = N;
     }
 
@@ -1598,7 +1598,7 @@ ChunkSparseMatrix<number>::block_read(std::istream &in)
   AssertThrow(c == '[', ExcIO());
 
   // reallocate space
-  val = std_cxx14::make_unique<number[]>(max_len);
+  val = std::make_unique<number[]>(max_len);
 
   // then read data
   in.read(reinterpret_cast<char *>(val.get()),
index 343038c482f8882c3f4a337b66fecb28c9fe56d5..95501984d45eee5ff476de6dcbac6b15d32f66de 100644 (file)
@@ -597,7 +597,7 @@ ImplicitQR<VectorType>::append_column(const VectorType &column)
   if (this->current_size == 0)
     {
       this->R.grow_or_shrink(this->current_size + 1);
-      this->columns.push_back(std_cxx14::make_unique<VectorType>(column));
+      this->columns.push_back(std::make_unique<VectorType>(column));
       this->R(0, 0) = column.l2_norm();
       ++this->current_size;
     }
@@ -630,7 +630,7 @@ ImplicitQR<VectorType>::append_column(const VectorType &column)
 
       // at this point we update is successful and we can enlarge R
       // and store the column:
-      this->columns.push_back(std_cxx14::make_unique<VectorType>(column));
+      this->columns.push_back(std::make_unique<VectorType>(column));
       this->R.grow_or_shrink(this->current_size + 1);
       this->R(this->current_size, this->current_size) = std::sqrt(rho2);
       for (unsigned int i = 0; i < this->current_size; ++i)
@@ -756,7 +756,7 @@ QR<VectorType>::append_column(const VectorType &column)
 {
   // resize R:
   this->R.grow_or_shrink(this->current_size + 1);
-  this->columns.push_back(std_cxx14::make_unique<VectorType>(column));
+  this->columns.push_back(std::make_unique<VectorType>(column));
 
   // now a Gram-Schmidt part: orthonormalize the new column
   // against everything we have so far:
index 45af42ad6ee5f65628112e90abe0e050fcacd312..7cbc765f8a4d3e4092b479682b3f2a8dc9e2bdbd 100644 (file)
@@ -869,7 +869,7 @@ SolverGMRES<VectorType>::solve(const MatrixType &        A,
       r->reinit(x);
       x_->reinit(x);
 
-      gamma_ = std_cxx14::make_unique<dealii::Vector<double>>(gamma.size());
+      gamma_ = std::make_unique<dealii::Vector<double>>(gamma.size());
     }
 
   bool re_orthogonalize = additional_data.force_re_orthogonalization;
index 77d8798ecfab98ce4b475c17c45a7a051e3b74ea..64790c30c815cf39ea5b109c3206b946faeca299 100644 (file)
@@ -269,7 +269,7 @@ SparseMatrix<number>::reinit(const SparsityPattern &sparsity)
   const std::size_t N = cols->n_nonzero_elements();
   if (N > max_len || max_len == 0)
     {
-      val     = std_cxx14::make_unique<number[]>(N);
+      val     = std::make_unique<number[]>(N);
       max_len = N;
     }
 
@@ -2056,7 +2056,7 @@ SparseMatrix<number>::block_read(std::istream &in)
   AssertThrow(c == '[', ExcIO());
 
   // reallocate space
-  val = std_cxx14::make_unique<number[]>(max_len);
+  val = std::make_unique<number[]>(max_len);
 
   // then read data
   in.read(reinterpret_cast<char *>(val.get()),
index 35801674c26c430ff0adfa28dcc12913729bceef..d615c603aa8e2e1a5d876c70af22b155a6c0f968 100644 (file)
@@ -1595,8 +1595,8 @@ SparsityPatternBase::load(Archive &ar, const unsigned int)
 
   ar &max_dim &rows &cols &max_vec_len &max_row_length &compressed;
 
-  rowstart = std_cxx14::make_unique<std::size_t[]>(max_dim + 1);
-  colnums  = std_cxx14::make_unique<size_type[]>(max_vec_len);
+  rowstart = std::make_unique<std::size_t[]>(max_dim + 1);
+  colnums  = std::make_unique<size_type[]>(max_vec_len);
 
   ar &boost::serialization::make_array(rowstart.get(), max_dim + 1);
   ar &boost::serialization::make_array(colnums.get(), max_vec_len);
index 3fa8caef5867754eb31e43c70ebf3665f2ed9641..a88d2506e20731bb13448c56b02431ab89f2698d 100644 (file)
@@ -88,7 +88,7 @@ namespace LinearAlgebra
       Tpetra::Map<int, types::global_dof_index> input_map =
         parallel_partitioner.make_tpetra_map(communicator, false);
       if (vector->getMap()->isSameAs(input_map) == false)
-        vector = std_cxx14::make_unique<
+        vector = std::make_unique<
           Tpetra::Vector<Number, int, types::global_dof_index>>(Teuchos::rcp(
           new Tpetra::Map<int, types::global_dof_index>(input_map)));
       else if (omit_zeroing_entries == false)
@@ -140,7 +140,7 @@ namespace LinearAlgebra
                                Tpetra::REPLACE);
             }
           else
-            vector = std_cxx14::make_unique<
+            vector = std::make_unique<
               Tpetra::Vector<Number, int, types::global_dof_index>>(
               V.trilinos_vector());
         }
index 8378d6bcce727f2e6d55684e47e1ac714a83f2dc..4b9c6df9ded0d05b09f64505b5904bdc9f547b12 100644 (file)
@@ -76,7 +76,7 @@ GrowingVectorMemory<VectorType>::Pool::initialize(const size_type size)
            ++i)
         {
           i->first  = false;
-          i->second = std_cxx14::make_unique<VectorType>();
+          i->second = std::make_unique<VectorType>();
         }
     }
 }
@@ -134,7 +134,7 @@ GrowingVectorMemory<VectorType>::alloc()
     }
 
   // no free vector found, so let's just allocate a new one
-  get_pool().data->emplace_back(true, std_cxx14::make_unique<VectorType>());
+  get_pool().data->emplace_back(true, std::make_unique<VectorType>());
 
   return get_pool().data->back().second.get();
 }
index b2a6e26ed1f5a33074771b507e2aa979e541a7b2..55c81fdc5f16989762cd5447b29eaf299d53cb8f 100644 (file)
@@ -1415,7 +1415,7 @@ DataOut_DoFData<DoFHandlerType, patch_dim, patch_space_dim>::add_data_vector(
            dof_handler.get_triangulation().n_active_cells()));
 
 
-  auto new_entry = std_cxx14::make_unique<
+  auto new_entry = std::make_unique<
     internal::DataOutImplementation::DataEntry<DoFHandlerType, VectorType>>(
     &dof_handler, &vec, &data_postprocessor);
   dof_data.emplace_back(std::move(new_entry));
@@ -1537,7 +1537,7 @@ DataOut_DoFData<DoFHandlerType, patch_dim, patch_space_dim>::
          DataComponentInterpretation::component_is_scalar));
 
   // finally, add the data vector:
-  auto new_entry = std_cxx14::make_unique<
+  auto new_entry = std::make_unique<
     internal::DataOutImplementation::DataEntry<DoFHandlerType, VectorType>>(
     dof_handler, &data_vector, deduced_names, data_component_interpretation);
 
@@ -1610,7 +1610,7 @@ DataOut_DoFData<DoFHandlerType, patch_dim, patch_space_dim>::add_mg_data_vector(
          ExcMessage(
            "Invalid number of entries in data_component_interpretation."));
 
-  auto new_entry = std_cxx14::make_unique<
+  auto new_entry = std::make_unique<
     internal::DataOutImplementation::MGDataEntry<DoFHandlerType, VectorType>>(
     &dof_handler, &data, deduced_names, data_component_interpretation);
   dof_data.emplace_back(std::move(new_entry));
index 45f361d822721ff6815fe874c7f5df0d8906cbbc..27aee75eff042f579c295db760a28878b6222b42 100644 (file)
@@ -172,7 +172,7 @@ FiniteSizeHistory<T>::add(const T &element)
       if (cache.size() == 0)
         // nothing is cached, just copy a given element
         {
-          new_el = std_cxx14::make_unique<T>(element);
+          new_el = std::make_unique<T>(element);
         }
       else
         // something is cached, take one element and copy
index c7752454935066ed6aa4d74af4c94e1e8f22d6c1..5e04a20cca0bdb1da3ae4484c21f4ea963f991b9 100644 (file)
@@ -297,7 +297,7 @@ namespace Patterns
       static std::unique_ptr<Patterns::PatternBase>
       to_pattern()
       {
-        return std_cxx14::make_unique<Patterns::Selection>(
+        return std::make_unique<Patterns::Selection>(
           "mean|L1_norm|L2_norm|Lp_norm|"
           "Linfty_norm|H1_seminorm|Hdiv_seminorm|"
           "H1_norm|W1p_seminorm|W1p_norm|"
index ded8832382807082671a071924301040d5e990d2..1226cab8b64a51e6c9b57e6f5f25f32e7e388d68 100644 (file)
@@ -64,12 +64,12 @@ FunctionParser<dim>::FunctionParser(const std::string &expression,
 {
   auto constants_map = Patterns::Tools::Convert<ConstMap>::to_value(
     constants,
-    std_cxx14::make_unique<Patterns::Map>(Patterns::Anything(),
-                                          Patterns::Double(),
-                                          0,
-                                          Patterns::Map::max_int_value,
-                                          ",",
-                                          "="));
+    std::make_unique<Patterns::Map>(Patterns::Anything(),
+                                    Patterns::Double(),
+                                    0,
+                                    Patterns::Map::max_int_value,
+                                    ",",
+                                    "="));
   initialize(variable_names,
              expression,
              constants_map,
index b8e3cb3080d0430689f677a0a805c7711b898fc0..fd93db41230c60c4a0e47f6bda6ce279d0a69014 100644 (file)
@@ -774,7 +774,7 @@ ParameterHandler::parse_input_from_json(std::istream &in,
 void
 ParameterHandler::clear()
 {
-  entries = std_cxx14::make_unique<boost::property_tree::ptree>();
+  entries = std::make_unique<boost::property_tree::ptree>();
   entries_set_status.clear();
 }
 
index c48451c6453ade53c6fd1d91bd6e752b58be2ceb..765506a5856c05729ce1d99b77e012ba3fcc5ed8 100644 (file)
@@ -326,17 +326,17 @@ namespace Patterns
             is.ignore(strlen(description_init) + strlen(" range "));
 
             if (!(is >> lower_bound))
-              return std_cxx14::make_unique<Integer>();
+              return std::make_unique<Integer>();
 
             is.ignore(strlen("..."));
 
             if (!(is >> upper_bound))
-              return std_cxx14::make_unique<Integer>();
+              return std::make_unique<Integer>();
 
-            return std_cxx14::make_unique<Integer>(lower_bound, upper_bound);
+            return std::make_unique<Integer>(lower_bound, upper_bound);
           }
         else
-          return std_cxx14::make_unique<Integer>();
+          return std::make_unique<Integer>();
       }
     else
       return std::unique_ptr<Integer>();
@@ -500,8 +500,8 @@ namespace Patterns
 
     std::string temp = description.substr(description_init_str.size());
     if (temp == "]")
-      return std_cxx14::make_unique<Double>(1.0,
-                                            -1.0); // return an invalid range
+      return std::make_unique<Double>(1.0,
+                                      -1.0); // return an invalid range
 
     if (temp.find("...") != std::string::npos)
       temp.replace(temp.find("..."), 3, " ");
@@ -523,7 +523,7 @@ namespace Patterns
     if (is.fail())
       upper_bound = max_double_value;
 
-    return std_cxx14::make_unique<Double>(lower_bound, upper_bound);
+    return std::make_unique<Double>(lower_bound, upper_bound);
   }
 
 
@@ -637,7 +637,7 @@ namespace Patterns
         sequence.erase(0, std::strlen(description_init) + 1);
         sequence.erase(sequence.length() - 2, 2);
 
-        return std_cxx14::make_unique<Selection>(sequence);
+        return std::make_unique<Selection>(sequence);
       }
     else
       return std::unique_ptr<Selection>();
@@ -792,11 +792,11 @@ namespace Patterns
 
         is.ignore(strlen(" of length "));
         if (!(is >> min_elements))
-          return std_cxx14::make_unique<List>(*base_pattern);
+          return std::make_unique<List>(*base_pattern);
 
         is.ignore(strlen("..."));
         if (!(is >> max_elements))
-          return std_cxx14::make_unique<List>(*base_pattern, min_elements);
+          return std::make_unique<List>(*base_pattern, min_elements);
 
         is.ignore(strlen(" (inclusive) separated by <"));
         std::string separator;
@@ -805,10 +805,10 @@ namespace Patterns
         else
           separator = ",";
 
-        return std_cxx14::make_unique<List>(*base_pattern,
-                                            min_elements,
-                                            max_elements,
-                                            separator);
+        return std::make_unique<List>(*base_pattern,
+                                      min_elements,
+                                      max_elements,
+                                      separator);
       }
     else
       return std::unique_ptr<List>();
@@ -992,13 +992,13 @@ namespace Patterns
 
         is.ignore(strlen(" of length "));
         if (!(is >> min_elements))
-          return std_cxx14::make_unique<Map>(*key_pattern, *value_pattern);
+          return std::make_unique<Map>(*key_pattern, *value_pattern);
 
         is.ignore(strlen("..."));
         if (!(is >> max_elements))
-          return std_cxx14::make_unique<Map>(*key_pattern,
-                                             *value_pattern,
-                                             min_elements);
+          return std::make_unique<Map>(*key_pattern,
+                                       *value_pattern,
+                                       min_elements);
 
         is.ignore(strlen(" (inclusive) separated by <"));
         std::string separator;
@@ -1007,12 +1007,12 @@ namespace Patterns
         else
           separator = ",";
 
-        return std_cxx14::make_unique<Map>(*key_pattern,
-                                           *value_pattern,
-                                           min_elements,
-                                           max_elements,
-                                           separator,
-                                           key_value_separator);
+        return std::make_unique<Map>(*key_pattern,
+                                     *value_pattern,
+                                     min_elements,
+                                     max_elements,
+                                     separator,
+                                     key_value_separator);
       }
     else
       return std::unique_ptr<Map>();
@@ -1211,7 +1211,7 @@ namespace Patterns
         else
           separator = ":";
 
-        return std_cxx14::make_unique<Tuple>(patterns, separator);
+        return std::make_unique<Tuple>(patterns, separator);
       }
     else
       return std::unique_ptr<Tuple>();
@@ -1378,7 +1378,7 @@ namespace Patterns
         sequence.erase(0, std::strlen(description_init) + 1);
         sequence.erase(sequence.length() - 2, 2);
 
-        return std_cxx14::make_unique<MultipleSelection>(sequence);
+        return std::make_unique<MultipleSelection>(sequence);
       }
     else
       return std::unique_ptr<MultipleSelection>();
@@ -1437,7 +1437,7 @@ namespace Patterns
     if (description.compare(0,
                             std::strlen(description_init),
                             description_init) == 0)
-      return std_cxx14::make_unique<Bool>();
+      return std::make_unique<Bool>();
     else
       return std::unique_ptr<Bool>();
   }
@@ -1498,7 +1498,7 @@ namespace Patterns
     if (description.compare(0,
                             std::strlen(description_init),
                             description_init) == 0)
-      return std_cxx14::make_unique<Anything>();
+      return std::make_unique<Anything>();
     else
       return std::unique_ptr<Anything>();
   }
@@ -1586,7 +1586,7 @@ namespace Patterns
         else
           type = output;
 
-        return std_cxx14::make_unique<FileName>(type);
+        return std::make_unique<FileName>(type);
       }
     else
       return std::unique_ptr<FileName>();
@@ -1648,7 +1648,7 @@ namespace Patterns
     if (description.compare(0,
                             std::strlen(description_init),
                             description_init) == 0)
-      return std_cxx14::make_unique<DirectoryName>();
+      return std::make_unique<DirectoryName>();
     else
       return std::unique_ptr<DirectoryName>();
   }
index 2539fb41a4516126258f58c65141da611bf62b7f..c83a04900cf0e667369ac185a6f4d587f6dfb068 100644 (file)
@@ -374,7 +374,7 @@ namespace Polynomials
     const Polynomial<number> *          q = nullptr;
     if (p.in_lagrange_product_form == true)
       {
-        q_data = std_cxx14::make_unique<Polynomial<number>>(p);
+        q_data = std::make_unique<Polynomial<number>>(p);
         q_data->transform_into_standard_form();
         q = q_data.get();
       }
@@ -418,7 +418,7 @@ namespace Polynomials
     const Polynomial<number> *          q = nullptr;
     if (p.in_lagrange_product_form == true)
       {
-        q_data = std_cxx14::make_unique<Polynomial<number>>(p);
+        q_data = std::make_unique<Polynomial<number>>(p);
         q_data->transform_into_standard_form();
         q = q_data.get();
       }
@@ -454,7 +454,7 @@ namespace Polynomials
     const Polynomial<number> *          q = nullptr;
     if (p.in_lagrange_product_form == true)
       {
-        q_data = std_cxx14::make_unique<Polynomial<number>>(p);
+        q_data = std::make_unique<Polynomial<number>>(p);
         q_data->transform_into_standard_form();
         q = q_data.get();
       }
@@ -599,7 +599,7 @@ namespace Polynomials
     const Polynomial<number> *          q = nullptr;
     if (in_lagrange_product_form == true)
       {
-        q_data = std_cxx14::make_unique<Polynomial<number>>(*this);
+        q_data = std::make_unique<Polynomial<number>>(*this);
         q_data->transform_into_standard_form();
         q = q_data.get();
       }
@@ -625,7 +625,7 @@ namespace Polynomials
     const Polynomial<number> *          q = nullptr;
     if (in_lagrange_product_form == true)
       {
-        q_data = std_cxx14::make_unique<Polynomial<number>>(*this);
+        q_data = std::make_unique<Polynomial<number>>(*this);
         q_data->transform_into_standard_form();
         q = q_data.get();
       }
@@ -1071,9 +1071,9 @@ namespace Polynomials
             // now make these arrays
             // const
             recursive_coefficients[0] =
-              std_cxx14::make_unique<const std::vector<double>>(std::move(c0));
+              std::make_unique<const std::vector<double>>(std::move(c0));
             recursive_coefficients[1] =
-              std_cxx14::make_unique<const std::vector<double>>(std::move(c1));
+              std::make_unique<const std::vector<double>>(std::move(c1));
           }
         else if (k == 2)
           {
@@ -1090,7 +1090,7 @@ namespace Polynomials
             c2[2] = 4. * a;
 
             recursive_coefficients[2] =
-              std_cxx14::make_unique<const std::vector<double>>(std::move(c2));
+              std::make_unique<const std::vector<double>>(std::move(c2));
           }
         else
           {
@@ -1134,7 +1134,7 @@ namespace Polynomials
             // const pointer in the
             // coefficients array
             recursive_coefficients[k] =
-              std_cxx14::make_unique<const std::vector<double>>(std::move(ck));
+              std::make_unique<const std::vector<double>>(std::move(ck));
           }
       }
   }
index 3305f0d116e42362697ad9946eb0d3c2774aeb50..8b7e705e1aa3d685eb295aa22e127a6c04b1455c 100644 (file)
@@ -403,7 +403,7 @@ template <int dim>
 std::unique_ptr<ScalarPolynomialsBase<dim>>
 PolynomialSpace<dim>::clone() const
 {
-  return std_cxx14::make_unique<PolynomialSpace<dim>>(*this);
+  return std::make_unique<PolynomialSpace<dim>>(*this);
 }
 
 
index 3ade2f546d6d7933d8155c261179c9bb2364bc5c..3792bc67e6d0cc6f6713e8eb862bbb9fc797714d 100644 (file)
@@ -185,7 +185,7 @@ template <int dim>
 std::unique_ptr<TensorPolynomialsBase<dim>>
 PolynomialsABF<dim>::clone() const
 {
-  return std_cxx14::make_unique<PolynomialsABF<dim>>(*this);
+  return std::make_unique<PolynomialsABF<dim>>(*this);
 }
 
 
index 9eae6504c891ccc2bbbc345771182023987dc742..2625de0728e32a6259bd335ba0c009473b4f7d04 100644 (file)
@@ -260,7 +260,7 @@ template <int dim>
 std::unique_ptr<ScalarPolynomialsBase<dim>>
 PolynomialsAdini<dim>::clone() const
 {
-  return std_cxx14::make_unique<PolynomialsAdini<dim>>(*this);
+  return std::make_unique<PolynomialsAdini<dim>>(*this);
 }
 
 
index 2f7aaabf80ce9cd78315b09652d829919c491ea9..678dec0b3f93abe9c645ea2b0ab97b9202b84fde 100644 (file)
@@ -447,7 +447,7 @@ template <int dim>
 std::unique_ptr<TensorPolynomialsBase<dim>>
 PolynomialsBDM<dim>::clone() const
 {
-  return std_cxx14::make_unique<PolynomialsBDM<dim>>(*this);
+  return std::make_unique<PolynomialsBDM<dim>>(*this);
 }
 
 
index a9ab446d2b3bde910ce97de11e0b9a37e5637652..51f6e635c2711cd52988d887ef170c7e0cd036a7 100644 (file)
@@ -254,7 +254,7 @@ template <int dim>
 std::unique_ptr<TensorPolynomialsBase<dim>>
 PolynomialsBernardiRaugel<dim>::clone() const
 {
-  return std_cxx14::make_unique<PolynomialsBernardiRaugel<dim>>(*this);
+  return std::make_unique<PolynomialsBernardiRaugel<dim>>(*this);
 }
 
 template class PolynomialsBernardiRaugel<1>; // to prevent errors
index 8650c4374030a8cf641cec0cfe1e67ec0cf3c4f9..950f37bb93ad94e732dfb24f8697e74494a2a58d 100644 (file)
@@ -1512,7 +1512,7 @@ template <int dim>
 std::unique_ptr<TensorPolynomialsBase<dim>>
 PolynomialsNedelec<dim>::clone() const
 {
-  return std_cxx14::make_unique<PolynomialsNedelec<dim>>(*this);
+  return std::make_unique<PolynomialsNedelec<dim>>(*this);
 }
 
 
index 947514ea2c7d8bff92ce1890bdaacc942ee599ce..c0ed061b4176cfe38761f3db6efb6afedf7f8dab 100644 (file)
@@ -194,7 +194,7 @@ template <int dim>
 std::unique_ptr<ScalarPolynomialsBase<dim>>
 PolynomialsRannacherTurek<dim>::clone() const
 {
-  return std_cxx14::make_unique<PolynomialsRannacherTurek<dim>>(*this);
+  return std::make_unique<PolynomialsRannacherTurek<dim>>(*this);
 }
 
 
index f62dbe37a553b046c3b88ec7a136e18d79637478..36e600e20d08d6533ebfd223dbeab0acded5b615 100644 (file)
@@ -188,7 +188,7 @@ template <int dim>
 std::unique_ptr<TensorPolynomialsBase<dim>>
 PolynomialsRaviartThomas<dim>::clone() const
 {
-  return std_cxx14::make_unique<PolynomialsRaviartThomas<dim>>(*this);
+  return std::make_unique<PolynomialsRaviartThomas<dim>>(*this);
 }
 
 
index 8a318be6af2e8e6e22a28111f0e0c25ae4581970..f28337f635b80060de03f7462b190b52277b2d74 100644 (file)
@@ -849,7 +849,7 @@ template <int dim>
 std::unique_ptr<TensorPolynomialsBase<dim>>
 PolynomialsRT_Bubbles<dim>::clone() const
 {
-  return std_cxx14::make_unique<PolynomialsRT_Bubbles<dim>>(*this);
+  return std::make_unique<PolynomialsRT_Bubbles<dim>>(*this);
 }
 
 
index 85fe2462970bb97340a7554f6f604c817475fe81..15787716c2c0b4d9045cee39c7097514c09a5032 100644 (file)
@@ -153,7 +153,7 @@ Quadrature<dim>::Quadrature(const SubQuadrature &q1, const Quadrature<1> &q2)
 
   if (is_tensor_product_flag)
     {
-      tensor_basis = std_cxx14::make_unique<std::array<Quadrature<1>, dim>>();
+      tensor_basis = std::make_unique<std::array<Quadrature<1>, dim>>();
       for (unsigned int i = 0; i < dim - 1; ++i)
         (*tensor_basis)[i] = q1.get_tensor_basis()[i];
       (*tensor_basis)[dim - 1] = q2;
@@ -251,7 +251,7 @@ Quadrature<dim>::Quadrature(const Quadrature<dim != 1 ? 1 : 0> &q)
           ++k;
         }
 
-  tensor_basis = std_cxx14::make_unique<std::array<Quadrature<1>, dim>>();
+  tensor_basis = std::make_unique<std::array<Quadrature<1>, dim>>();
   for (unsigned int i = 0; i < dim; ++i)
     (*tensor_basis)[i] = q;
 }
@@ -267,7 +267,7 @@ Quadrature<dim>::Quadrature(const Quadrature<dim> &q)
 {
   if (dim > 1 && is_tensor_product_flag)
     tensor_basis =
-      std_cxx14::make_unique<std::array<Quadrature<1>, dim>>(*q.tensor_basis);
+      std::make_unique<std::array<Quadrature<1>, dim>>(*q.tensor_basis);
 }
 
 
@@ -282,8 +282,8 @@ Quadrature<dim>::operator=(const Quadrature<dim> &q)
   if (dim > 1 && is_tensor_product_flag)
     {
       if (tensor_basis == nullptr)
-        tensor_basis = std_cxx14::make_unique<std::array<Quadrature<1>, dim>>(
-          *q.tensor_basis);
+        tensor_basis =
+          std::make_unique<std::array<Quadrature<1>, dim>>(*q.tensor_basis);
       else
         *tensor_basis = *q.tensor_basis;
     }
@@ -384,8 +384,7 @@ QAnisotropic<2>::QAnisotropic(const Quadrature<1> &qx, const Quadrature<1> &qy)
   Assert(k == this->size(), ExcInternalError());
   this->is_tensor_product_flag = true;
   const std::array<Quadrature<1>, 2> q_array{{qx, qy}};
-  this->tensor_basis =
-    std_cxx14::make_unique<std::array<Quadrature<1>, 2>>(q_array);
+  this->tensor_basis = std::make_unique<std::array<Quadrature<1>, 2>>(q_array);
 }
 
 
@@ -420,8 +419,7 @@ QAnisotropic<3>::QAnisotropic(const Quadrature<1> &qx,
   Assert(k == this->size(), ExcInternalError());
   this->is_tensor_product_flag = true;
   const std::array<Quadrature<1>, 3> q_array{{qx, qy, qz}};
-  this->tensor_basis =
-    std_cxx14::make_unique<std::array<Quadrature<1>, 3>>(q_array);
+  this->tensor_basis = std::make_unique<std::array<Quadrature<1>, 3>>(q_array);
 }
 
 
index 969385448c98cf39c79b25df4669373f8a06eb85..69acd512c36d5f9fadf343fae6e9d91e64e16236 100644 (file)
@@ -63,12 +63,12 @@ TensorFunctionParser<rank, dim, Number>::TensorFunctionParser(
 {
   auto constants_map = Patterns::Tools::Convert<ConstMap>::to_value(
     constants,
-    std_cxx14::make_unique<Patterns::Map>(Patterns::Anything(),
-                                          Patterns::Double(),
-                                          0,
-                                          Patterns::Map::max_int_value,
-                                          ",",
-                                          "="));
+    std::make_unique<Patterns::Map>(Patterns::Anything(),
+                                    Patterns::Double(),
+                                    0,
+                                    Patterns::Map::max_int_value,
+                                    ",",
+                                    "="));
   initialize(variable_names,
              expression,
              constants_map,
index c086b52ec06e4736e18b60086b26a2f43661e958..46f7177ad845e139860e5681a004af170e887930 100644 (file)
@@ -430,8 +430,7 @@ template <int dim, typename PolynomialType>
 std::unique_ptr<ScalarPolynomialsBase<dim>>
 TensorProductPolynomials<dim, PolynomialType>::clone() const
 {
-  return std_cxx14::make_unique<TensorProductPolynomials<dim, PolynomialType>>(
-    *this);
+  return std::make_unique<TensorProductPolynomials<dim, PolynomialType>>(*this);
 }
 
 
@@ -738,7 +737,7 @@ template <int dim>
 std::unique_ptr<ScalarPolynomialsBase<dim>>
 AnisotropicPolynomials<dim>::clone() const
 {
-  return std_cxx14::make_unique<AnisotropicPolynomials<dim>>(*this);
+  return std::make_unique<AnisotropicPolynomials<dim>>(*this);
 }
 
 
index dafc94047858c21c566ba3a6faf51d4fd93f216d..802cca256b92e536447851ced5c6dc652296479d 100644 (file)
@@ -336,7 +336,7 @@ template <int dim>
 std::unique_ptr<ScalarPolynomialsBase<dim>>
 TensorProductPolynomialsBubbles<dim>::clone() const
 {
-  return std_cxx14::make_unique<TensorProductPolynomialsBubbles<dim>>(*this);
+  return std::make_unique<TensorProductPolynomialsBubbles<dim>>(*this);
 }
 
 
index a2fcb95ce5dc055d5d9b5285195b94030e21e0d8..002d6c270499cdfceccc6636b2d887aae0dd43c2 100644 (file)
@@ -203,7 +203,7 @@ template <int dim>
 std::unique_ptr<ScalarPolynomialsBase<dim>>
 TensorProductPolynomialsConst<dim>::clone() const
 {
-  return std_cxx14::make_unique<TensorProductPolynomialsConst<dim>>(*this);
+  return std::make_unique<TensorProductPolynomialsConst<dim>>(*this);
 }
 
 
index c7bbf5a6568ad365de06f47d3b97259a8073b330..2d76ff040ca6757b70dc042c248580ae8d39f2ec 100644 (file)
@@ -251,7 +251,7 @@ namespace parallel
                          *>(&other_tria) == nullptr)
         {
           serial_tria =
-            std_cxx14::make_unique<dealii::Triangulation<dim, spacedim>>();
+            std::make_unique<dealii::Triangulation<dim, spacedim>>();
 
           // actually copy the serial triangulation
           serial_tria->copy_triangulation(other_tria);
index 5372d6872b5d280f9ee587af82634ced6c7d3173..aea54f9db331dba59fa39b508abf2750bec77ce2 100644 (file)
@@ -336,8 +336,8 @@ namespace internal
               numbers::invalid_dof_index);
           }
 
-        dof_handler.faces = std_cxx14::make_unique<
-          internal::DoFHandlerImplementation::DoFFaces<2>>();
+        dof_handler.faces =
+          std::make_unique<internal::DoFHandlerImplementation::DoFFaces<2>>();
         // avoid access to n_raw_lines when there are no cells
         if (dof_handler.tria->n_cells() > 0)
           {
@@ -371,8 +371,8 @@ namespace internal
                 dof_handler.get_fe().dofs_per_cell,
               numbers::invalid_dof_index);
           }
-        dof_handler.faces = std_cxx14::make_unique<
-          internal::DoFHandlerImplementation::DoFFaces<3>>();
+        dof_handler.faces =
+          std::make_unique<internal::DoFHandlerImplementation::DoFFaces<3>>();
 
         // avoid access to n_raw_lines when there are no cells
         if (dof_handler.tria->n_cells() > 0)
@@ -471,7 +471,7 @@ namespace internal
         for (unsigned int i = 0; i < n_levels; ++i)
           {
             dof_handler.mg_levels.emplace_back(
-              std_cxx14::make_unique<
+              std::make_unique<
                 internal::DoFHandlerImplementation::DoFLevel<2>>());
             dof_handler.mg_levels.back()->dof_object.dofs =
               std::vector<types::global_dof_index>(tria.n_raw_quads(i) *
@@ -479,8 +479,8 @@ namespace internal
                                                    numbers::invalid_dof_index);
           }
 
-        dof_handler.mg_faces = std_cxx14::make_unique<
-          internal::DoFHandlerImplementation::DoFFaces<2>>();
+        dof_handler.mg_faces =
+          std::make_unique<internal::DoFHandlerImplementation::DoFFaces<2>>();
         dof_handler.mg_faces->lines.dofs = std::vector<types::global_dof_index>(
           tria.n_raw_lines() * fe.dofs_per_line, numbers::invalid_dof_index);
 
@@ -544,7 +544,7 @@ namespace internal
         for (unsigned int i = 0; i < n_levels; ++i)
           {
             dof_handler.mg_levels.emplace_back(
-              std_cxx14::make_unique<
+              std::make_unique<
                 internal::DoFHandlerImplementation::DoFLevel<3>>());
             dof_handler.mg_levels.back()->dof_object.dofs =
               std::vector<types::global_dof_index>(tria.n_raw_hexs(i) *
@@ -552,8 +552,8 @@ namespace internal
                                                    numbers::invalid_dof_index);
           }
 
-        dof_handler.mg_faces = std_cxx14::make_unique<
-          internal::DoFHandlerImplementation::DoFFaces<3>>();
+        dof_handler.mg_faces =
+          std::make_unique<internal::DoFHandlerImplementation::DoFFaces<3>>();
         dof_handler.mg_faces->lines.dofs = std::vector<types::global_dof_index>(
           tria.n_raw_lines() * fe.dofs_per_line, numbers::invalid_dof_index);
         dof_handler.mg_faces->quads.dofs = std::vector<types::global_dof_index>(
@@ -843,20 +843,18 @@ DoFHandler<dim, spacedim>::DoFHandler(const Triangulation<dim, spacedim> &tria)
   if (dynamic_cast<const parallel::shared::Triangulation<dim, spacedim> *>(
         &tria) != nullptr)
     policy =
-      std_cxx14::make_unique<internal::DoFHandlerImplementation::Policy::
-                               ParallelShared<DoFHandler<dim, spacedim>>>(
-        *this);
+      std::make_unique<internal::DoFHandlerImplementation::Policy::
+                         ParallelShared<DoFHandler<dim, spacedim>>>(*this);
   else if (dynamic_cast<
              const parallel::DistributedTriangulationBase<dim, spacedim> *>(
              &tria) == nullptr)
     policy =
-      std_cxx14::make_unique<internal::DoFHandlerImplementation::Policy::
-                               Sequential<DoFHandler<dim, spacedim>>>(*this);
+      std::make_unique<internal::DoFHandlerImplementation::Policy::Sequential<
+        DoFHandler<dim, spacedim>>>(*this);
   else
     policy =
-      std_cxx14::make_unique<internal::DoFHandlerImplementation::Policy::
-                               ParallelDistributed<DoFHandler<dim, spacedim>>>(
-        *this);
+      std::make_unique<internal::DoFHandlerImplementation::Policy::
+                         ParallelDistributed<DoFHandler<dim, spacedim>>>(*this);
 }
 
 
@@ -895,20 +893,18 @@ DoFHandler<dim, spacedim>::initialize(const Triangulation<dim, spacedim> &t,
   if (dynamic_cast<const parallel::shared::Triangulation<dim, spacedim> *>(
         &t) != nullptr)
     policy =
-      std_cxx14::make_unique<internal::DoFHandlerImplementation::Policy::
-                               ParallelShared<DoFHandler<dim, spacedim>>>(
-        *this);
+      std::make_unique<internal::DoFHandlerImplementation::Policy::
+                         ParallelShared<DoFHandler<dim, spacedim>>>(*this);
   else if (dynamic_cast<
              const parallel::DistributedTriangulationBase<dim, spacedim> *>(
              &t) != nullptr)
     policy =
-      std_cxx14::make_unique<internal::DoFHandlerImplementation::Policy::
-                               ParallelDistributed<DoFHandler<dim, spacedim>>>(
-        *this);
+      std::make_unique<internal::DoFHandlerImplementation::Policy::
+                         ParallelDistributed<DoFHandler<dim, spacedim>>>(*this);
   else
     policy =
-      std_cxx14::make_unique<internal::DoFHandlerImplementation::Policy::
-                               Sequential<DoFHandler<dim, spacedim>>>(*this);
+      std::make_unique<internal::DoFHandlerImplementation::Policy::Sequential<
+        DoFHandler<dim, spacedim>>>(*this);
 
   distribute_dofs(fe);
 }
@@ -1581,7 +1577,7 @@ DoFHandler<dim, spacedim>::MGVertexDoFs::init(
       const unsigned int n_levels  = finest_level - coarsest_level + 1;
       const unsigned int n_indices = n_levels * dofs_per_vertex;
 
-      indices = std_cxx14::make_unique<types::global_dof_index[]>(n_indices);
+      indices = std::make_unique<types::global_dof_index[]>(n_indices);
       std::fill(indices.get(),
                 indices.get() + n_indices,
                 numbers::invalid_dof_index);
index 272afee9c72a07242e25a42a25479fbe6f2fb33f..1ff9c22043cbe33b7a80161177fb6405b1b95b5d 100644 (file)
@@ -175,21 +175,21 @@ namespace internal
                 {
                   case 0:
                     {
-                      identities = std_cxx14::make_unique<DoFIdentities>(
+                      identities = std::make_unique<DoFIdentities>(
                         fe1.hp_vertex_dof_identities(fe2));
                       break;
                     }
 
                   case 1:
                     {
-                      identities = std_cxx14::make_unique<DoFIdentities>(
+                      identities = std::make_unique<DoFIdentities>(
                         fe1.hp_line_dof_identities(fe2));
                       break;
                     }
 
                   case 2:
                     {
-                      identities = std_cxx14::make_unique<DoFIdentities>(
+                      identities = std::make_unique<DoFIdentities>(
                         fe1.hp_quad_dof_identities(fe2));
                       break;
                     }
index b2835c83f3b9325e5e9ec1dbb5918bfa6571c9f3..54e3df06acf5e287eb010390215d2e9385549ab9 100644 (file)
@@ -309,7 +309,7 @@ namespace DoFTools
         if (master_dof_mask == nullptr)
           {
             master_dof_mask =
-              std_cxx14::make_unique<std::vector<bool>>(fe1.dofs_per_face);
+              std::make_unique<std::vector<bool>>(fe1.dofs_per_face);
             select_master_dofs_for_face_restriction(fe1,
                                                     fe2,
                                                     face_interpolation_matrix,
@@ -333,9 +333,8 @@ namespace DoFTools
       {
         if (matrix == nullptr)
           {
-            matrix =
-              std_cxx14::make_unique<FullMatrix<double>>(fe2.dofs_per_face,
-                                                         fe1.dofs_per_face);
+            matrix = std::make_unique<FullMatrix<double>>(fe2.dofs_per_face,
+                                                          fe1.dofs_per_face);
             fe1.get_face_interpolation_matrix(fe2, *matrix);
           }
       }
@@ -355,9 +354,8 @@ namespace DoFTools
       {
         if (matrix == nullptr)
           {
-            matrix =
-              std_cxx14::make_unique<FullMatrix<double>>(fe2.dofs_per_face,
-                                                         fe1.dofs_per_face);
+            matrix = std::make_unique<FullMatrix<double>>(fe2.dofs_per_face,
+                                                          fe1.dofs_per_face);
             fe1.get_subface_interpolation_matrix(fe2, subface, *matrix);
           }
       }
@@ -385,7 +383,7 @@ namespace DoFTools
 
         if (split_matrix == nullptr)
           {
-            split_matrix = std_cxx14::make_unique<
+            split_matrix = std::make_unique<
               std::pair<FullMatrix<double>, FullMatrix<double>>>();
 
             const unsigned int n_master_dofs = face_interpolation_matrix.n();
index e2fc86f4ef15fcdaa582a0b88403b58bd2267127..cfb693bc8138b03be6fa6dd02de3e28a4311f68b 100644 (file)
@@ -135,7 +135,7 @@ template <int dim>
 std::unique_ptr<FiniteElement<dim, dim>>
 FE_ABF<dim>::clone() const
 {
-  return std_cxx14::make_unique<FE_ABF<dim>>(rt_order);
+  return std::make_unique<FE_ABF<dim>>(rt_order);
 }
 
 
index 97988fb0810abbc42db5020e0a502c883379525e..93588bf04a40d604a2a2349390533efb554e3e38 100644 (file)
@@ -124,7 +124,7 @@ template <int dim>
 std::unique_ptr<FiniteElement<dim, dim>>
 FE_BDM<dim>::clone() const
 {
-  return std_cxx14::make_unique<FE_BDM<dim>>(*this);
+  return std::make_unique<FE_BDM<dim>>(*this);
 }
 
 
index ffdb3cc9565c7d82bca98c428d3224de03950e3b..60ea30e96cc9ed326c4ab660ac0bda5ccc4db72f 100644 (file)
@@ -82,7 +82,7 @@ template <int dim>
 std::unique_ptr<FiniteElement<dim, dim>>
 FE_BernardiRaugel<dim>::clone() const
 {
-  return std_cxx14::make_unique<FE_BernardiRaugel<dim>>(*this);
+  return std::make_unique<FE_BernardiRaugel<dim>>(*this);
 }
 
 
index 60fe4045d8ca17cea17ba6d939731c32946232fe..245f8c6846e10b7df880bb02b4bb6e228edaa258 100644 (file)
@@ -342,7 +342,7 @@ template <int dim, int spacedim>
 std::unique_ptr<FiniteElement<dim, spacedim>>
 FE_Bernstein<dim, spacedim>::clone() const
 {
-  return std_cxx14::make_unique<FE_Bernstein<dim, spacedim>>(*this);
+  return std::make_unique<FE_Bernstein<dim, spacedim>>(*this);
 }
 
 
index 04fe320a739561ab86c56982d6efb7935004e72b..f11b4fbb629b36600efb808ab33abcb9e63a8ac0 100644 (file)
@@ -75,7 +75,7 @@ template <int dim, int spacedim>
 std::unique_ptr<FiniteElement<dim, spacedim>>
 FE_DGP<dim, spacedim>::clone() const
 {
-  return std_cxx14::make_unique<FE_DGP<dim, spacedim>>(*this);
+  return std::make_unique<FE_DGP<dim, spacedim>>(*this);
 }
 
 
index 61477873f3f8a5012ebb369e5b7f5e7e6bcbff6d..e1d2eadd7dc535cf76f46fbe18e8f5c57a1417e0 100644 (file)
@@ -184,7 +184,7 @@ template <int dim>
 std::unique_ptr<FiniteElement<dim, dim>>
 FE_DGPMonomial<dim>::clone() const
 {
-  return std_cxx14::make_unique<FE_DGPMonomial<dim>>(*this);
+  return std::make_unique<FE_DGPMonomial<dim>>(*this);
 }
 
 
index 6b534e1612dc2c3183a4cc13bc29fecbe7e5303d..c915a44f7a49d208c46a8b1d8c37e5f5da18dce9 100644 (file)
@@ -127,7 +127,7 @@ template <int dim, int spacedim>
 std::unique_ptr<FiniteElement<dim, spacedim>>
 FE_DGPNonparametric<dim, spacedim>::clone() const
 {
-  return std_cxx14::make_unique<FE_DGPNonparametric<dim, spacedim>>(*this);
+  return std::make_unique<FE_DGPNonparametric<dim, spacedim>>(*this);
 }
 
 
@@ -283,8 +283,8 @@ FE_DGPNonparametric<dim, spacedim>::get_data(
     & /*output_data*/) const
 {
   // generate a new data object
-  auto data_ptr = std_cxx14::make_unique<
-    typename FiniteElement<dim, spacedim>::InternalDataBase>();
+  auto data_ptr =
+    std::make_unique<typename FiniteElement<dim, spacedim>::InternalDataBase>();
   data_ptr->update_each = requires_update_flags(update_flags);
 
   // other than that, there is nothing we can add here as discussed
index c9deeb1ed5b66241be92054425d9a1c60646c833..14b0f9cad629d6b4e74cc1a9fe0d046108c50d09 100644 (file)
@@ -163,7 +163,7 @@ template <int dim, int spacedim>
 std::unique_ptr<FiniteElement<dim, spacedim>>
 FE_DGQ<dim, spacedim>::clone() const
 {
-  return std_cxx14::make_unique<FE_DGQ<dim, spacedim>>(*this);
+  return std::make_unique<FE_DGQ<dim, spacedim>>(*this);
 }
 
 
@@ -958,8 +958,7 @@ FE_DGQArbitraryNodes<dim, spacedim>::clone() const
     qpoints[i] = Point<1>(this->unit_support_points[lexicographic[i]][0]);
   Quadrature<1> pquadrature(qpoints);
 
-  return std_cxx14::make_unique<FE_DGQArbitraryNodes<dim, spacedim>>(
-    pquadrature);
+  return std::make_unique<FE_DGQArbitraryNodes<dim, spacedim>>(pquadrature);
 }
 
 
@@ -1002,7 +1001,7 @@ template <int dim, int spacedim>
 std::unique_ptr<FiniteElement<dim, spacedim>>
 FE_DGQLegendre<dim, spacedim>::clone() const
 {
-  return std_cxx14::make_unique<FE_DGQLegendre<dim, spacedim>>(this->degree);
+  return std::make_unique<FE_DGQLegendre<dim, spacedim>>(this->degree);
 }
 
 
@@ -1031,7 +1030,7 @@ template <int dim, int spacedim>
 std::unique_ptr<FiniteElement<dim, spacedim>>
 FE_DGQHermite<dim, spacedim>::clone() const
 {
-  return std_cxx14::make_unique<FE_DGQHermite<dim, spacedim>>(this->degree);
+  return std::make_unique<FE_DGQHermite<dim, spacedim>>(this->degree);
 }
 
 
index f958d3b41f6458ebe7e28b151be724bc40aad85e..d62b4ebf56ff7fa561e1bd9ca4ccfc9d361209f1 100644 (file)
@@ -190,8 +190,7 @@ FE_Enriched<dim, spacedim>::FE_Enriched(
                                                        false))
   , enrichments(functions)
   , is_enriched(internal::FE_Enriched::check_if_enriched(fes))
-  , fe_system(
-      std_cxx14::make_unique<FESystem<dim, spacedim>>(fes, multiplicities))
+  , fe_system(std::make_unique<FESystem<dim, spacedim>>(fes, multiplicities))
 {
   // descriptive error are thrown within the function.
   Assert(internal::FE_Enriched::consistency_check(fes,
@@ -332,7 +331,7 @@ FE_Enriched<dim, spacedim>::setup_data(
   // that fes_data points to, to the new InternalData object.
   auto update_each_flags = fes_data->update_each;
   std::unique_ptr<typename FiniteElement<dim, spacedim>::InternalDataBase>
-        data_ptr = std_cxx14::make_unique<InternalData>(std::move(fes_data));
+        data_ptr = std::make_unique<InternalData>(std::move(fes_data));
   auto &data     = dynamic_cast<InternalData &>(*data_ptr);
 
   // copy update_each from FESystem data:
index 5c1506b4b0fa48847d87db6d8de2329d14e613a2..08b5409881ff55c98202120f8f52e60431a6eed9 100644 (file)
@@ -121,7 +121,7 @@ template <int dim, int spacedim>
 std::unique_ptr<FiniteElement<dim, spacedim>>
 FE_FaceQ<dim, spacedim>::clone() const
 {
-  return std_cxx14::make_unique<FE_FaceQ<dim, spacedim>>(this->degree);
+  return std::make_unique<FE_FaceQ<dim, spacedim>>(this->degree);
 }
 
 
@@ -527,7 +527,7 @@ template <int spacedim>
 std::unique_ptr<FiniteElement<1, spacedim>>
 FE_FaceQ<1, spacedim>::clone() const
 {
-  return std_cxx14::make_unique<FE_FaceQ<1, spacedim>>(this->degree);
+  return std::make_unique<FE_FaceQ<1, spacedim>>(this->degree);
 }
 
 
@@ -761,7 +761,7 @@ template <int dim, int spacedim>
 std::unique_ptr<FiniteElement<dim, spacedim>>
 FE_FaceP<dim, spacedim>::clone() const
 {
-  return std_cxx14::make_unique<FE_FaceP<dim, spacedim>>(this->degree);
+  return std::make_unique<FE_FaceP<dim, spacedim>>(this->degree);
 }
 
 
index dc77242fecc0e4819f03451ecefefe7a043ed805..b9e57456f4417d2e2ebeb1a478072d0683037215 100644 (file)
@@ -224,7 +224,7 @@ template <int dim>
 std::unique_ptr<FiniteElement<dim, dim>>
 FE_Nedelec<dim>::clone() const
 {
-  return std_cxx14::make_unique<FE_Nedelec<dim>>(*this);
+  return std::make_unique<FE_Nedelec<dim>>(*this);
 }
 
 //---------------------------------------------------------------------------
index 4ca5a952e504170060eff5b9386ad7e33c11d46d..de789f16fb63d91c21fc87586b306bdda80aa7fc 100644 (file)
@@ -134,7 +134,7 @@ FE_NedelecSZ<dim, spacedim>::get_data(
 {
   std::unique_ptr<
     typename dealii::FiniteElement<dim, spacedim>::InternalDataBase>
-        data_ptr   = std_cxx14::make_unique<InternalData>();
+        data_ptr   = std::make_unique<InternalData>();
   auto &data       = dynamic_cast<InternalData &>(*data_ptr);
   data.update_each = requires_update_flags(update_flags);
 
@@ -2221,7 +2221,7 @@ template <int dim, int spacedim>
 std::unique_ptr<FiniteElement<dim, dim>>
 FE_NedelecSZ<dim, spacedim>::clone() const
 {
-  return std_cxx14::make_unique<FE_NedelecSZ<dim, spacedim>>(*this);
+  return std::make_unique<FE_NedelecSZ<dim, spacedim>>(*this);
 }
 
 
index 1777528ed6ef382fd19347626cd6e603717775cc..c436565cf21bc887fd96b58030faca166887eea9 100644 (file)
@@ -45,7 +45,7 @@ template <int dim, int spacedim>
 std::unique_ptr<FiniteElement<dim, spacedim>>
 FE_Nothing<dim, spacedim>::clone() const
 {
-  return std_cxx14::make_unique<FE_Nothing<dim, spacedim>>(*this);
+  return std::make_unique<FE_Nothing<dim, spacedim>>(*this);
 }
 
 
@@ -103,7 +103,7 @@ FE_Nothing<dim, spacedim>::get_data(
   // Create a default data object.  Normally we would then
   // need to resize things to hold the appropriate numbers
   // of dofs, but in this case all data fields are empty.
-  return std_cxx14::make_unique<
+  return std::make_unique<
     typename FiniteElement<dim, spacedim>::InternalDataBase>();
 }
 
index 0c6f85d7f0d635651aeaaf6e2d22ac42689312a6..9ecdd170c176e2625c8d484a85c1b2549c9bc72f 100644 (file)
@@ -68,7 +68,7 @@ FE_P1NC::requires_update_flags(const UpdateFlags flags) const
 std::unique_ptr<FiniteElement<2, 2>>
 FE_P1NC::clone() const
 {
-  return std_cxx14::make_unique<FE_P1NC>(*this);
+  return std::make_unique<FE_P1NC>(*this);
 }
 
 
@@ -140,8 +140,7 @@ FE_P1NC::get_data(
   dealii::internal::FEValuesImplementation::FiniteElementRelatedData<2, 2>
     &output_data) const
 {
-  auto data_ptr =
-    std_cxx14::make_unique<FiniteElement<2, 2>::InternalDataBase>();
+  auto data_ptr = std::make_unique<FiniteElement<2, 2>::InternalDataBase>();
 
   data_ptr->update_each = requires_update_flags(update_flags);
 
@@ -165,8 +164,7 @@ FE_P1NC::get_face_data(
   dealii::internal::FEValuesImplementation::FiniteElementRelatedData<2, 2>
     &output_data) const
 {
-  auto data_ptr =
-    std_cxx14::make_unique<FiniteElement<2, 2>::InternalDataBase>();
+  auto data_ptr = std::make_unique<FiniteElement<2, 2>::InternalDataBase>();
 
   data_ptr->update_each = requires_update_flags(update_flags);
 
@@ -190,8 +188,7 @@ FE_P1NC::get_subface_data(
   dealii::internal::FEValuesImplementation::FiniteElementRelatedData<2, 2>
     &output_data) const
 {
-  auto data_ptr =
-    std_cxx14::make_unique<FiniteElement<2, 2>::InternalDataBase>();
+  auto data_ptr = std::make_unique<FiniteElement<2, 2>::InternalDataBase>();
 
   data_ptr->update_each = requires_update_flags(update_flags);
 
index db825ba22da7b3eebd7f2e101ecd473acf5582a8..13345b26c6efa7a0091c65244d166242f6327163 100644 (file)
@@ -171,7 +171,7 @@ template <int dim, int spacedim>
 std::unique_ptr<FiniteElement<dim, spacedim>>
 FE_Q<dim, spacedim>::clone() const
 {
-  return std_cxx14::make_unique<FE_Q<dim, spacedim>>(*this);
+  return std::make_unique<FE_Q<dim, spacedim>>(*this);
 }
 
 
index 8d28cce37d02fa8a18159debf8839b892c4fe945..f7f9438b7e06ee8ce2eeff72d4182fc5e6f044f4 100644 (file)
@@ -64,23 +64,28 @@ namespace internal
           {
             case 1:
               if (spacedim == 1)
-                q_fine = std_cxx14::make_unique<QGauss<dim>>(degree + 1);
+                q_fine = std::make_unique<QGauss<dim>>(degree + 1);
               else if (spacedim == 2)
-                q_fine = std_cxx14::make_unique<QAnisotropic<dim>>(
-                  QGauss<1>(degree + 1), q_dummy);
+                q_fine =
+                  std::make_unique<QAnisotropic<dim>>(QGauss<1>(degree + 1),
+                                                      q_dummy);
               else
-                q_fine = std_cxx14::make_unique<QAnisotropic<dim>>(
-                  QGauss<1>(degree + 1), q_dummy, q_dummy);
+                q_fine =
+                  std::make_unique<QAnisotropic<dim>>(QGauss<1>(degree + 1),
+                                                      q_dummy,
+                                                      q_dummy);
               break;
             case 2:
               if (spacedim == 2)
-                q_fine = std_cxx14::make_unique<QGauss<dim>>(degree + 1);
+                q_fine = std::make_unique<QGauss<dim>>(degree + 1);
               else
-                q_fine = std_cxx14::make_unique<QAnisotropic<dim>>(
-                  QGauss<1>(degree + 1), QGauss<1>(degree + 1), q_dummy);
+                q_fine =
+                  std::make_unique<QAnisotropic<dim>>(QGauss<1>(degree + 1),
+                                                      QGauss<1>(degree + 1),
+                                                      q_dummy);
               break;
             case 3:
-              q_fine = std_cxx14::make_unique<QGauss<dim>>(degree + 1);
+              q_fine = std::make_unique<QGauss<dim>>(degree + 1);
               break;
             default:
               Assert(false, ExcInternalError());
@@ -343,7 +348,7 @@ template <int dim, int spacedim>
 std::unique_ptr<FiniteElement<dim, spacedim>>
 FE_Q_Bubbles<dim, spacedim>::clone() const
 {
-  return std_cxx14::make_unique<FE_Q_Bubbles<dim, spacedim>>(*this);
+  return std::make_unique<FE_Q_Bubbles<dim, spacedim>>(*this);
 }
 
 
index be261bedc2a2248dcc9761fb3e878c77f7eefe14..e8c6fabea71a7c4d16ffc323ce510fef4df3117c 100644 (file)
@@ -173,7 +173,7 @@ template <int dim, int spacedim>
 std::unique_ptr<FiniteElement<dim, spacedim>>
 FE_Q_DG0<dim, spacedim>::clone() const
 {
-  return std_cxx14::make_unique<FE_Q_DG0<dim, spacedim>>(*this);
+  return std::make_unique<FE_Q_DG0<dim, spacedim>>(*this);
 }
 
 
index 4a385705eb2b4904676a4c4136bc2f3747771a49..8b7da34c2e4c7f7713e89805f6c1f0db20e2f539 100644 (file)
@@ -141,7 +141,7 @@ template <int dim>
 std::unique_ptr<FiniteElement<dim, dim>>
 FE_Q_Hierarchical<dim>::clone() const
 {
-  return std_cxx14::make_unique<FE_Q_Hierarchical<dim>>(*this);
+  return std::make_unique<FE_Q_Hierarchical<dim>>(*this);
 }
 
 
index 654968a91717e3451f932d3d29bef571d378b64b..a8b7f40c1f1172cfd53157c7f61c78b254f34620 100644 (file)
@@ -100,7 +100,7 @@ template <int dim, int spacedim>
 std::unique_ptr<FiniteElement<dim, spacedim>>
 FE_Q_iso_Q1<dim, spacedim>::clone() const
 {
-  return std_cxx14::make_unique<FE_Q_iso_Q1<dim, spacedim>>(*this);
+  return std::make_unique<FE_Q_iso_Q1<dim, spacedim>>(*this);
 }
 
 
index 78186941fb8a785a713e26981a3e96d33d768286..e2a34f7e5ccf6d54cfca90676a539bb3a0ed9c0b 100644 (file)
@@ -78,8 +78,8 @@ template <int dim>
 std::unique_ptr<FiniteElement<dim, dim>>
 FE_RannacherTurek<dim>::clone() const
 {
-  return std_cxx14::make_unique<FE_RannacherTurek<dim>>(
-    this->order, this->n_face_support_points);
+  return std::make_unique<FE_RannacherTurek<dim>>(this->order,
+                                                  this->n_face_support_points);
 }
 
 
index 5d085016e932a2832bf8faa2f1f5936cfbe10702..ce0790ffed0f17e9c83594189aee9a6ddbcb24eb 100644 (file)
@@ -136,7 +136,7 @@ template <int dim>
 std::unique_ptr<FiniteElement<dim, dim>>
 FE_RaviartThomas<dim>::clone() const
 {
-  return std_cxx14::make_unique<FE_RaviartThomas<dim>>(*this);
+  return std::make_unique<FE_RaviartThomas<dim>>(*this);
 }
 
 
@@ -215,8 +215,7 @@ FE_RaviartThomas<dim>::initialize_support_points(const unsigned int deg)
         poly[d] = Polynomials::Legendre::generate_complete_basis(deg);
       poly[dd] = Polynomials::Legendre::generate_complete_basis(deg - 1);
 
-      polynomials[dd] =
-        std_cxx14::make_unique<AnisotropicPolynomials<dim>>(poly);
+      polynomials[dd] = std::make_unique<AnisotropicPolynomials<dim>>(poly);
     }
 
   interior_weights.reinit(
@@ -351,8 +350,7 @@ FE_RaviartThomas<dim>::initialize_restriction()
       poly[dd] =
         Polynomials::Legendre::generate_complete_basis(this->degree - 2);
 
-      polynomials[dd] =
-        std_cxx14::make_unique<AnisotropicPolynomials<dim>>(poly);
+      polynomials[dd] = std::make_unique<AnisotropicPolynomials<dim>>(poly);
     }
 
   QGauss<dim>        q_cell(this->degree);
index 344207af959d7d0b8d86cd4b150c46be0f02cebd..f5c170e56c99e1dfd6805a9f65fce32ac90ed5bc 100644 (file)
@@ -133,7 +133,7 @@ template <int dim>
 std::unique_ptr<FiniteElement<dim, dim>>
 FE_RaviartThomasNodal<dim>::clone() const
 {
-  return std_cxx14::make_unique<FE_RaviartThomasNodal<dim>>(*this);
+  return std::make_unique<FE_RaviartThomasNodal<dim>>(*this);
 }
 
 
@@ -191,18 +191,18 @@ FE_RaviartThomasNodal<dim>::initialize_support_points(const unsigned int deg)
       switch (dim)
         {
           case 1:
-            quadrature = std_cxx14::make_unique<QAnisotropic<dim>>(high);
+            quadrature = std::make_unique<QAnisotropic<dim>>(high);
             break;
           case 2:
-            quadrature = std_cxx14::make_unique<QAnisotropic<dim>>(
-              ((d == 0) ? low : high), ((d == 1) ? low : high));
+            quadrature =
+              std::make_unique<QAnisotropic<dim>>(((d == 0) ? low : high),
+                                                  ((d == 1) ? low : high));
             break;
           case 3:
             quadrature =
-              std_cxx14::make_unique<QAnisotropic<dim>>(((d == 0) ? low : high),
-                                                        ((d == 1) ? low : high),
-                                                        ((d == 2) ? low :
-                                                                    high));
+              std::make_unique<QAnisotropic<dim>>(((d == 0) ? low : high),
+                                                  ((d == 1) ? low : high),
+                                                  ((d == 2) ? low : high));
             break;
           default:
             Assert(false, ExcNotImplemented());
index ec657d0a6c01a7eed728a326117c74d4fd481c35..86f4727951e0c1526850ac6c569a96d61c43fe41 100644 (file)
@@ -117,7 +117,7 @@ template <int dim>
 std::unique_ptr<FiniteElement<dim, dim>>
 FE_RT_Bubbles<dim>::clone() const
 {
-  return std_cxx14::make_unique<FE_RT_Bubbles<dim>>(*this);
+  return std::make_unique<FE_RT_Bubbles<dim>>(*this);
 }
 
 
@@ -177,18 +177,18 @@ FE_RT_Bubbles<dim>::initialize_support_points(const unsigned int deg)
       switch (dim)
         {
           case 1:
-            quadrature = std_cxx14::make_unique<QAnisotropic<dim>>(high);
+            quadrature = std::make_unique<QAnisotropic<dim>>(high);
             break;
           case 2:
-            quadrature = std_cxx14::make_unique<QAnisotropic<dim>>(
-              ((d == 0) ? low : high), ((d == 1) ? low : high));
+            quadrature =
+              std::make_unique<QAnisotropic<dim>>(((d == 0) ? low : high),
+                                                  ((d == 1) ? low : high));
             break;
           case 3:
             quadrature =
-              std_cxx14::make_unique<QAnisotropic<dim>>(((d == 0) ? low : high),
-                                                        ((d == 1) ? low : high),
-                                                        ((d == 2) ? low :
-                                                                    high));
+              std::make_unique<QAnisotropic<dim>>(((d == 0) ? low : high),
+                                                  ((d == 1) ? low : high),
+                                                  ((d == 2) ? low : high));
             break;
           default:
             Assert(false, ExcNotImplemented());
index a26233678f384fbc548685a2e4f988d4c35da3c7..77a61770ffc24c913431aa11083784447ca175a1 100644 (file)
@@ -347,7 +347,7 @@ FESystem<dim, spacedim>::clone() const
       fes.push_back(&base_element(i));
       multiplicities.push_back(this->element_multiplicity(i));
     }
-  return std_cxx14::make_unique<FESystem<dim, spacedim>>(fes, multiplicities);
+  return std::make_unique<FESystem<dim, spacedim>>(fes, multiplicities);
 }
 
 
@@ -923,8 +923,8 @@ FESystem<dim, spacedim>::get_data(
   // correct in case the current FESystem is a base element for another,
   // higher-level FESystem itself.
   std::unique_ptr<typename FiniteElement<dim, spacedim>::InternalDataBase>
-        data_ptr = std_cxx14::make_unique<InternalData>(this->n_base_elements());
-  auto &data     = dynamic_cast<InternalData &>(*data_ptr);
+        data_ptr   = std::make_unique<InternalData>(this->n_base_elements());
+  auto &data       = dynamic_cast<InternalData &>(*data_ptr);
   data.update_each = requires_update_flags(flags);
 
   // get data objects from each of the base elements and store
@@ -986,8 +986,8 @@ FESystem<dim, spacedim>::get_face_data(
   // correct in case the current FESystem is a base element for another,
   // higher-level FESystem itself.
   std::unique_ptr<typename FiniteElement<dim, spacedim>::InternalDataBase>
-        data_ptr = std_cxx14::make_unique<InternalData>(this->n_base_elements());
-  auto &data     = dynamic_cast<InternalData &>(*data_ptr);
+        data_ptr   = std::make_unique<InternalData>(this->n_base_elements());
+  auto &data       = dynamic_cast<InternalData &>(*data_ptr);
   data.update_each = requires_update_flags(flags);
 
   // get data objects from each of the base elements and store
@@ -1049,7 +1049,7 @@ FESystem<dim, spacedim>::get_subface_data(
   // correct in case the current FESystem is a base element for another,
   // higher-level FESystem itself.
   std::unique_ptr<typename FiniteElement<dim, spacedim>::InternalDataBase>
-        data_ptr = std_cxx14::make_unique<InternalData>(this->n_base_elements());
+        data_ptr = std::make_unique<InternalData>(this->n_base_elements());
   auto &data     = dynamic_cast<InternalData &>(*data_ptr);
 
   data.update_each = requires_update_flags(flags);
index 23e88178e8bbf6261fdb43e5a89a8d3f4dfb3d04..c1145ebde25a93acc0d1377bbafb6fd45027ad06 100644 (file)
@@ -73,7 +73,7 @@ template <int dim, int spacedim>
 std::unique_ptr<FiniteElement<dim, spacedim>>
 FE_TraceQ<dim, spacedim>::clone() const
 {
-  return std_cxx14::make_unique<FE_TraceQ<dim, spacedim>>(this->degree);
+  return std::make_unique<FE_TraceQ<dim, spacedim>>(this->degree);
 }
 
 
index a677e6b7f2819ff93fcdae3fe8b5beb9c4be636a..f002d3ddda1a4f53e87d1f29e0e9e4d8436ab586 100644 (file)
@@ -4468,8 +4468,8 @@ FEValues<dim, spacedim>::initialize(const UpdateFlags update_flags)
   if (flags & update_mapping)
     this->mapping_data = std::move(mapping_get_data.return_value());
   else
-    this->mapping_data = std_cxx14::make_unique<
-      typename Mapping<dim, spacedim>::InternalDataBase>();
+    this->mapping_data =
+      std::make_unique<typename Mapping<dim, spacedim>::InternalDataBase>();
 }
 
 
@@ -4499,7 +4499,7 @@ namespace
       }
     else
       // if the types don't match, there is nothing we can do here
-      present_cell = std_cxx14::make_unique<Type>(new_cell);
+      present_cell = std::make_unique<Type>(new_cell);
   }
 } // namespace
 
@@ -4728,8 +4728,8 @@ FEFaceValues<dim, spacedim>::initialize(const UpdateFlags update_flags)
   if (flags & update_mapping)
     this->mapping_data = std::move(mapping_get_data.return_value());
   else
-    this->mapping_data = std_cxx14::make_unique<
-      typename Mapping<dim, spacedim>::InternalDataBase>();
+    this->mapping_data =
+      std::make_unique<typename Mapping<dim, spacedim>::InternalDataBase>();
 }
 
 
@@ -4929,8 +4929,8 @@ FESubfaceValues<dim, spacedim>::initialize(const UpdateFlags update_flags)
   if (flags & update_mapping)
     this->mapping_data = std::move(mapping_get_data.return_value());
   else
-    this->mapping_data = std_cxx14::make_unique<
-      typename Mapping<dim, spacedim>::InternalDataBase>();
+    this->mapping_data =
+      std::make_unique<typename Mapping<dim, spacedim>::InternalDataBase>();
 }
 
 
index 5d185b034c816fe43dcdeb2956324977be7b2480..8493ab4d6bc7ee37ff5d51ff582829dcc6017447 100644 (file)
@@ -222,7 +222,7 @@ template <int dim, int spacedim>
 std::unique_ptr<Mapping<dim, spacedim>>
 MappingC1<dim, spacedim>::clone() const
 {
-  return std_cxx14::make_unique<MappingC1<dim, spacedim>>();
+  return std::make_unique<MappingC1<dim, spacedim>>();
 }
 
 
index f26f1b1aff6926fc242c085ec54d5e989764adcc..504023b7ee8b2b954f7042c3c0e86f592bb9dc87 100644 (file)
@@ -95,7 +95,7 @@ MappingCartesian<dim, spacedim>::get_data(const UpdateFlags      update_flags,
                                           const Quadrature<dim> &q) const
 {
   std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
-    std_cxx14::make_unique<InternalData>(q);
+    std::make_unique<InternalData>(q);
   auto &data = dynamic_cast<InternalData &>(*data_ptr);
 
   // store the flags in the internal data object so we can access them
@@ -115,7 +115,7 @@ MappingCartesian<dim, spacedim>::get_face_data(
   const Quadrature<dim - 1> &quadrature) const
 {
   std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
-    std_cxx14::make_unique<InternalData>(
+    std::make_unique<InternalData>(
       QProjector<dim>::project_to_all_faces(quadrature));
   auto &data = dynamic_cast<InternalData &>(*data_ptr);
 
@@ -140,7 +140,7 @@ MappingCartesian<dim, spacedim>::get_subface_data(
   const Quadrature<dim - 1> &quadrature) const
 {
   std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
-    std_cxx14::make_unique<InternalData>(
+    std::make_unique<InternalData>(
       QProjector<dim>::project_to_all_subfaces(quadrature));
   auto &data = dynamic_cast<InternalData &>(*data_ptr);
 
@@ -1061,7 +1061,7 @@ template <int dim, int spacedim>
 std::unique_ptr<Mapping<dim, spacedim>>
 MappingCartesian<dim, spacedim>::clone() const
 {
-  return std_cxx14::make_unique<MappingCartesian<dim, spacedim>>(*this);
+  return std::make_unique<MappingCartesian<dim, spacedim>>(*this);
 }
 
 
index 7949dd065afcb6efbe48ff2384799275d4cadaa2..20773943a6e09c0c6d967503810ed5e3f41ede1f 100644 (file)
@@ -610,7 +610,7 @@ MappingFEField<dim, spacedim, VectorType, DoFHandlerType>::get_data(
   const Quadrature<dim> &quadrature) const
 {
   std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
-    std_cxx14::make_unique<InternalData>(euler_dof_handler->get_fe(), fe_mask);
+    std::make_unique<InternalData>(euler_dof_handler->get_fe(), fe_mask);
   auto &data = dynamic_cast<InternalData &>(*data_ptr);
   this->compute_data(update_flags, quadrature, quadrature.size(), data);
 
@@ -626,7 +626,7 @@ MappingFEField<dim, spacedim, VectorType, DoFHandlerType>::get_face_data(
   const Quadrature<dim - 1> &quadrature) const
 {
   std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
-    std_cxx14::make_unique<InternalData>(euler_dof_handler->get_fe(), fe_mask);
+    std::make_unique<InternalData>(euler_dof_handler->get_fe(), fe_mask);
   auto &                data = dynamic_cast<InternalData &>(*data_ptr);
   const Quadrature<dim> q(QProjector<dim>::project_to_all_faces(quadrature));
   this->compute_face_data(update_flags, q, quadrature.size(), data);
@@ -642,7 +642,7 @@ MappingFEField<dim, spacedim, VectorType, DoFHandlerType>::get_subface_data(
   const Quadrature<dim - 1> &quadrature) const
 {
   std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
-    std_cxx14::make_unique<InternalData>(euler_dof_handler->get_fe(), fe_mask);
+    std::make_unique<InternalData>(euler_dof_handler->get_fe(), fe_mask);
   auto &                data = dynamic_cast<InternalData &>(*data_ptr);
   const Quadrature<dim> q(QProjector<dim>::project_to_all_subfaces(quadrature));
   this->compute_face_data(update_flags, q, quadrature.size(), data);
@@ -2308,7 +2308,7 @@ template <int dim, int spacedim, typename VectorType, typename DoFHandlerType>
 std::unique_ptr<Mapping<dim, spacedim>>
 MappingFEField<dim, spacedim, VectorType, DoFHandlerType>::clone() const
 {
-  return std_cxx14::make_unique<
+  return std::make_unique<
     MappingFEField<dim, spacedim, VectorType, DoFHandlerType>>(*this);
 }
 
index a11ee168ed68ea2ec032f7a3ad9e8499c9bda7df..e1223e134393ee1949c9c46e54eda8ef1153e21e 100644 (file)
@@ -152,7 +152,7 @@ template <int dim, int spacedim>
 std::unique_ptr<Mapping<dim, spacedim>>
 MappingManifold<dim, spacedim>::clone() const
 {
-  return std_cxx14::make_unique<MappingManifold<dim, spacedim>>(*this);
+  return std::make_unique<MappingManifold<dim, spacedim>>(*this);
 }
 
 
@@ -271,7 +271,7 @@ MappingManifold<dim, spacedim>::get_data(const UpdateFlags      update_flags,
                                          const Quadrature<dim> &q) const
 {
   std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
-    std_cxx14::make_unique<InternalData>();
+    std::make_unique<InternalData>();
   auto &data = dynamic_cast<InternalData &>(*data_ptr);
   data.initialize(this->requires_update_flags(update_flags), q, q.size());
 
@@ -287,7 +287,7 @@ MappingManifold<dim, spacedim>::get_face_data(
   const Quadrature<dim - 1> &quadrature) const
 {
   std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
-    std_cxx14::make_unique<InternalData>();
+    std::make_unique<InternalData>();
   auto &data = dynamic_cast<InternalData &>(*data_ptr);
   data.initialize_face(this->requires_update_flags(update_flags),
                        QProjector<dim>::project_to_all_faces(quadrature),
@@ -305,7 +305,7 @@ MappingManifold<dim, spacedim>::get_subface_data(
   const Quadrature<dim - 1> &quadrature) const
 {
   std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
-    std_cxx14::make_unique<InternalData>();
+    std::make_unique<InternalData>();
   auto &data = dynamic_cast<InternalData &>(*data_ptr);
   data.initialize_face(this->requires_update_flags(update_flags),
                        QProjector<dim>::project_to_all_subfaces(quadrature),
index 1cc552679a775241a79fbfd8a2f03d3da9988094..a685222489bf92ed097c18d3e2774d16b0577034 100644 (file)
@@ -152,7 +152,7 @@ MappingQ<dim, spacedim>::get_data(const UpdateFlags      update_flags,
                                   const Quadrature<dim> &quadrature) const
 {
   std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
-    std_cxx14::make_unique<InternalData>();
+    std::make_unique<InternalData>();
   auto &data = dynamic_cast<InternalData &>(*data_ptr);
 
   // build the Q1 and Qp internal data objects in parallel
@@ -184,7 +184,7 @@ MappingQ<dim, spacedim>::get_face_data(
   const Quadrature<dim - 1> &quadrature) const
 {
   std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
-    std_cxx14::make_unique<InternalData>();
+    std::make_unique<InternalData>();
   auto &data = dynamic_cast<InternalData &>(*data_ptr);
 
   // build the Q1 and Qp internal data objects in parallel
@@ -217,7 +217,7 @@ MappingQ<dim, spacedim>::get_subface_data(
   const Quadrature<dim - 1> &quadrature) const
 {
   std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
-    std_cxx14::make_unique<InternalData>();
+    std::make_unique<InternalData>();
   auto &data = dynamic_cast<InternalData &>(*data_ptr);
 
   // build the Q1 and Qp internal data objects in parallel
@@ -535,7 +535,7 @@ template <int dim, int spacedim>
 std::unique_ptr<Mapping<dim, spacedim>>
 MappingQ<dim, spacedim>::clone() const
 {
-  return std_cxx14::make_unique<MappingQ<dim, spacedim>>(
+  return std::make_unique<MappingQ<dim, spacedim>>(
     this->polynomial_degree, this->use_mapping_q_on_all_cells);
 }
 
index 698bfcfafc4817bf453278366d6d85c58e7300e6..0a1f22f81c5c66c4cb9077b687f2e89db122c666 100644 (file)
@@ -55,7 +55,7 @@ template <int dim, int spacedim>
 std::unique_ptr<Mapping<dim, spacedim>>
 MappingQ1<dim, spacedim>::clone() const
 {
-  return std_cxx14::make_unique<MappingQ1<dim, spacedim>>(*this);
+  return std::make_unique<MappingQ1<dim, spacedim>>(*this);
 }
 
 //---------------------------------------------------------------------------
index 4dee93228becfe6fb7ef69cd10b6a6356800939b..057923f07c1ee96c23ea3009427b66a80c5468e1 100644 (file)
@@ -121,8 +121,7 @@ template <int dim, class VectorType, int spacedim>
 std::unique_ptr<Mapping<dim, spacedim>>
 MappingQ1Eulerian<dim, VectorType, spacedim>::clone() const
 {
-  return std_cxx14::make_unique<MappingQ1Eulerian<dim, VectorType, spacedim>>(
-    *this);
+  return std::make_unique<MappingQ1Eulerian<dim, VectorType, spacedim>>(*this);
 }
 
 
index 9f95efb1c6defe361682b2543692d7abbbf45d92..8af4eb2b07b32dd635bdd829e0f79a27968ad1d1 100644 (file)
@@ -56,7 +56,7 @@ template <int dim, int spacedim>
 std::unique_ptr<Mapping<dim, spacedim>>
 MappingQCache<dim, spacedim>::clone() const
 {
-  return std_cxx14::make_unique<MappingQCache<dim, spacedim>>(*this);
+  return std::make_unique<MappingQCache<dim, spacedim>>(*this);
 }
 
 
index fc3cd6448616b4b34ad5cc8e1c2dc8bc48ef1832..e8fae5a85026957025d23f869e4e82b984c14b71 100644 (file)
@@ -86,7 +86,7 @@ template <int dim, class VectorType, int spacedim>
 std::unique_ptr<Mapping<dim, spacedim>>
 MappingQEulerian<dim, VectorType, spacedim>::clone() const
 {
-  return std_cxx14::make_unique<MappingQEulerian<dim, VectorType, spacedim>>(
+  return std::make_unique<MappingQEulerian<dim, VectorType, spacedim>>(
     this->get_degree(), *euler_dof_handler, *euler_vector);
 }
 
index 83e77c57529b61c7b0f1bc44b3d513a81b9896d1..5130c9d986a70172d69927356053cd8f786fb7c4 100644 (file)
@@ -2248,7 +2248,7 @@ template <int dim, int spacedim>
 std::unique_ptr<Mapping<dim, spacedim>>
 MappingQGeneric<dim, spacedim>::clone() const
 {
-  return std_cxx14::make_unique<MappingQGeneric<dim, spacedim>>(*this);
+  return std::make_unique<MappingQGeneric<dim, spacedim>>(*this);
 }
 
 
@@ -2675,7 +2675,7 @@ MappingQGeneric<dim, spacedim>::get_data(const UpdateFlags      update_flags,
                                          const Quadrature<dim> &q) const
 {
   std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
-    std_cxx14::make_unique<InternalData>(polynomial_degree);
+    std::make_unique<InternalData>(polynomial_degree);
   auto &data = dynamic_cast<InternalData &>(*data_ptr);
   data.initialize(this->requires_update_flags(update_flags), q, q.size());
 
@@ -2691,7 +2691,7 @@ MappingQGeneric<dim, spacedim>::get_face_data(
   const Quadrature<dim - 1> &quadrature) const
 {
   std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
-    std_cxx14::make_unique<InternalData>(polynomial_degree);
+    std::make_unique<InternalData>(polynomial_degree);
   auto &data = dynamic_cast<InternalData &>(*data_ptr);
   data.initialize_face(this->requires_update_flags(update_flags),
                        QProjector<dim>::project_to_all_faces(quadrature),
@@ -2709,7 +2709,7 @@ MappingQGeneric<dim, spacedim>::get_subface_data(
   const Quadrature<dim - 1> &quadrature) const
 {
   std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
-    std_cxx14::make_unique<InternalData>(polynomial_degree);
+    std::make_unique<InternalData>(polynomial_degree);
   auto &data = dynamic_cast<InternalData &>(*data_ptr);
   data.initialize_face(this->requires_update_flags(update_flags),
                        QProjector<dim>::project_to_all_subfaces(quadrature),
index f3876fa67b8f87f2f4321521ee60474578e5ab22..4d59dc6c3a575761985e41db458543a465a973d9 100644 (file)
@@ -527,8 +527,7 @@ template <int dim, int spacedim>
 std::unique_ptr<Manifold<dim, spacedim>>
 FlatManifold<dim, spacedim>::clone() const
 {
-  return std_cxx14::make_unique<FlatManifold<dim, spacedim>>(periodicity,
-                                                             tolerance);
+  return std::make_unique<FlatManifold<dim, spacedim>>(periodicity, tolerance);
 }
 
 
index aeda26cef09a87b4857e28a4d3700321190ae02a..50762588598477e6db1a33001c154329406c404a 100644 (file)
@@ -131,7 +131,7 @@ template <int dim, int spacedim>
 std::unique_ptr<Manifold<dim, spacedim>>
 PolarManifold<dim, spacedim>::clone() const
 {
-  return std_cxx14::make_unique<PolarManifold<dim, spacedim>>(center);
+  return std::make_unique<PolarManifold<dim, spacedim>>(center);
 }
 
 
@@ -362,7 +362,7 @@ template <int dim, int spacedim>
 std::unique_ptr<Manifold<dim, spacedim>>
 SphericalManifold<dim, spacedim>::clone() const
 {
-  return std_cxx14::make_unique<SphericalManifold<dim, spacedim>>(center);
+  return std::make_unique<SphericalManifold<dim, spacedim>>(center);
 }
 
 
@@ -1072,8 +1072,9 @@ template <int dim, int spacedim>
 std::unique_ptr<Manifold<dim, spacedim>>
 CylindricalManifold<dim, spacedim>::clone() const
 {
-  return std_cxx14::make_unique<CylindricalManifold<dim, spacedim>>(
-    direction, point_on_axis, tolerance);
+  return std::make_unique<CylindricalManifold<dim, spacedim>>(direction,
+                                                              point_on_axis,
+                                                              tolerance);
 }
 
 
@@ -1231,8 +1232,9 @@ std::unique_ptr<Manifold<dim, spacedim>>
 EllipticalManifold<dim, spacedim>::clone() const
 {
   const double eccentricity = 1.0 / cosh_u;
-  return std_cxx14::make_unique<EllipticalManifold<dim, spacedim>>(
-    center, direction, eccentricity);
+  return std::make_unique<EllipticalManifold<dim, spacedim>>(center,
+                                                             direction,
+                                                             eccentricity);
 }
 
 
@@ -1461,7 +1463,7 @@ FunctionManifold<dim, spacedim, chartdim>::clone() const
   // used to construct this class.
   if (!(push_forward_expression.empty() && pull_back_expression.empty()))
     {
-      return std_cxx14::make_unique<FunctionManifold<dim, spacedim, chartdim>>(
+      return std::make_unique<FunctionManifold<dim, spacedim, chartdim>>(
         push_forward_expression,
         pull_back_expression,
         this->get_periodicity(),
@@ -1473,7 +1475,7 @@ FunctionManifold<dim, spacedim, chartdim>::clone() const
     }
   else
     {
-      return std_cxx14::make_unique<FunctionManifold<dim, spacedim, chartdim>>(
+      return std::make_unique<FunctionManifold<dim, spacedim, chartdim>>(
         *push_forward_function,
         *pull_back_function,
         this->get_periodicity(),
@@ -1596,7 +1598,7 @@ template <int dim>
 std::unique_ptr<Manifold<dim, 3>>
 TorusManifold<dim>::clone() const
 {
-  return std_cxx14::make_unique<TorusManifold<dim>>(R, r);
+  return std::make_unique<TorusManifold<dim>>(R, r);
 }
 
 
index fcd430def4f6760f14b4a15baa4c50ab3a7ac842..bdb18e7535e2f8fc40f9b9d8e01c9ec7bdd94495 100644 (file)
@@ -1765,7 +1765,7 @@ namespace internal
 
         // reserve enough space
         triangulation.levels.push_back(
-          std_cxx14::make_unique<
+          std::make_unique<
             internal::TriangulationImplementation::TriaLevel<dim>>());
         triangulation.levels[0]->reserve_space(cells.size(), dim, spacedim);
         triangulation.levels[0]->cells.reserve_space(0, cells.size());
@@ -2035,9 +2035,9 @@ namespace internal
 
         // reserve enough space
         triangulation.levels.push_back(
-          std_cxx14::make_unique<
+          std::make_unique<
             internal::TriangulationImplementation::TriaLevel<dim>>());
-        triangulation.faces = std_cxx14::make_unique<
+        triangulation.faces = std::make_unique<
           internal::TriangulationImplementation::TriaFaces<dim>>();
         triangulation.levels[0]->reserve_space(cells.size(), dim, spacedim);
         triangulation.faces->lines.reserve_space(0, needed_lines.size());
@@ -2415,9 +2415,9 @@ namespace internal
         // for the lines
         // reserve enough space
         triangulation.levels.push_back(
-          std_cxx14::make_unique<
+          std::make_unique<
             internal::TriangulationImplementation::TriaLevel<dim>>());
-        triangulation.faces = std_cxx14::make_unique<
+        triangulation.faces = std::make_unique<
           internal::TriangulationImplementation::TriaFaces<dim>>();
         triangulation.levels[0]->reserve_space(cells.size(), dim, spacedim);
         triangulation.faces->lines.reserve_space(0, needed_lines.size());
@@ -4652,7 +4652,7 @@ namespace internal
               if (cell->refine_flag_set())
                 {
                   triangulation.levels.push_back(
-                    std_cxx14::make_unique<
+                    std::make_unique<
                       internal::TriangulationImplementation::TriaLevel<dim>>());
                   break;
                 }
@@ -4896,7 +4896,7 @@ namespace internal
               if (cell->refine_flag_set())
                 {
                   triangulation.levels.push_back(
-                    std_cxx14::make_unique<
+                    std::make_unique<
                       internal::TriangulationImplementation::TriaLevel<dim>>());
                   break;
                 }
@@ -5227,7 +5227,7 @@ namespace internal
               if (cell->refine_flag_set())
                 {
                   triangulation.levels.push_back(
-                    std_cxx14::make_unique<
+                    std::make_unique<
                       internal::TriangulationImplementation::TriaLevel<dim>>());
                   break;
                 }
@@ -10065,9 +10065,9 @@ Triangulation<dim, spacedim>::Triangulation(
   if (dim == 1)
     {
       vertex_to_boundary_id_map_1d =
-        std_cxx14::make_unique<std::map<unsigned int, types::boundary_id>>();
+        std::make_unique<std::map<unsigned int, types::boundary_id>>();
       vertex_to_manifold_id_map_1d =
-        std_cxx14::make_unique<std::map<unsigned int, types::manifold_id>>();
+        std::make_unique<std::map<unsigned int, types::manifold_id>>();
     }
 
   // connect the any_change signal to the other top level signals
@@ -10409,8 +10409,9 @@ Triangulation<dim, spacedim>::copy_triangulation(
   smooth_grid            = other_tria.smooth_grid;
 
   if (dim > 1)
-    faces = std_cxx14::make_unique<
-      internal::TriangulationImplementation::TriaFaces<dim>>(*other_tria.faces);
+    faces =
+      std::make_unique<internal::TriangulationImplementation::TriaFaces<dim>>(
+        *other_tria.faces);
 
   auto bdry_iterator = other_tria.manifold.begin();
   for (; bdry_iterator != other_tria.manifold.end(); ++bdry_iterator)
@@ -10419,20 +10420,20 @@ Triangulation<dim, spacedim>::copy_triangulation(
 
   levels.reserve(other_tria.levels.size());
   for (unsigned int level = 0; level < other_tria.levels.size(); ++level)
-    levels.push_back(std_cxx14::make_unique<
-                     internal::TriangulationImplementation::TriaLevel<dim>>(
-      *other_tria.levels[level]));
+    levels.push_back(
+      std::make_unique<internal::TriangulationImplementation::TriaLevel<dim>>(
+        *other_tria.levels[level]));
 
   number_cache = other_tria.number_cache;
 
   if (dim == 1)
     {
       vertex_to_boundary_id_map_1d =
-        std_cxx14::make_unique<std::map<unsigned int, types::boundary_id>>(
+        std::make_unique<std::map<unsigned int, types::boundary_id>>(
           *other_tria.vertex_to_boundary_id_map_1d);
 
       vertex_to_manifold_id_map_1d =
-        std_cxx14::make_unique<std::map<unsigned int, types::manifold_id>>(
+        std::make_unique<std::map<unsigned int, types::manifold_id>>(
           *other_tria.vertex_to_manifold_id_map_1d);
     }
 
index 16046cb174edbe741ce451eb59b0445aa775208a..b39f72195fd980d8301210848e9eeda836f7c171 100644 (file)
@@ -145,7 +145,7 @@ namespace internal
 
             if (dim > 1)
               dof_handler.faces =
-                std_cxx14::make_unique<internal::hp::DoFIndicesOnFaces<dim>>();
+                std::make_unique<internal::hp::DoFIndicesOnFaces<dim>>();
           }
         }
 
@@ -1721,9 +1721,10 @@ namespace hp
     if (dynamic_cast<const parallel::DistributedTriangulationBase<dim, spacedim>
                        *>(&this->get_triangulation()))
       {
-        policy = std_cxx14::make_unique<
-          internal::DoFHandlerImplementation::Policy::ParallelDistributed<
-            DoFHandler<dim, spacedim>>>(*this);
+        policy =
+          std::make_unique<internal::DoFHandlerImplementation::Policy::
+                             ParallelDistributed<DoFHandler<dim, spacedim>>>(
+            *this);
 
         // repartitioning signals
         tria_listeners.push_back(
@@ -1756,9 +1757,8 @@ namespace hp
                             *>(&this->get_triangulation()) != nullptr)
       {
         policy =
-          std_cxx14::make_unique<internal::DoFHandlerImplementation::Policy::
-                                   ParallelShared<DoFHandler<dim, spacedim>>>(
-            *this);
+          std::make_unique<internal::DoFHandlerImplementation::Policy::
+                             ParallelShared<DoFHandler<dim, spacedim>>>(*this);
 
         // partitioning signals
         tria_listeners.push_back(
@@ -1776,9 +1776,8 @@ namespace hp
     else
       {
         policy =
-          std_cxx14::make_unique<internal::DoFHandlerImplementation::Policy::
-                                   Sequential<DoFHandler<dim, spacedim>>>(
-            *this);
+          std::make_unique<internal::DoFHandlerImplementation::Policy::
+                             Sequential<DoFHandler<dim, spacedim>>>(*this);
 
         // refinement signals
         tria_listeners.push_back(this->tria->signals.pre_refinement.connect(
@@ -2011,8 +2010,7 @@ namespace hp
       {
         Assert(active_fe_index_transfer == nullptr, ExcInternalError());
 
-        active_fe_index_transfer =
-          std_cxx14::make_unique<ActiveFEIndexTransfer>();
+        active_fe_index_transfer = std::make_unique<ActiveFEIndexTransfer>();
 
         dealii::internal::hp::DoFHandlerImplementation::Implementation::
           collect_fe_indices_on_cells_to_be_refined(*this);
@@ -2044,8 +2042,7 @@ namespace hp
       {
         Assert(active_fe_index_transfer == nullptr, ExcInternalError());
 
-        active_fe_index_transfer =
-          std_cxx14::make_unique<ActiveFEIndexTransfer>();
+        active_fe_index_transfer = std::make_unique<ActiveFEIndexTransfer>();
 
         // If we work on a p::d::Triangulation, we have to transfer all
         // active_fe_indices since ownership of cells may change. We will
@@ -2068,7 +2065,7 @@ namespace hp
           const parallel::distributed::Triangulation<dim, spacedim> *>(
           &this->get_triangulation());
 
-        active_fe_index_transfer->cell_data_transfer = std_cxx14::make_unique<
+        active_fe_index_transfer->cell_data_transfer = std::make_unique<
           parallel::distributed::
             CellDataTransfer<dim, spacedim, std::vector<unsigned int>>>(
           *distributed_tria,
@@ -2188,15 +2185,14 @@ namespace hp
       {
         Assert(active_fe_index_transfer == nullptr, ExcInternalError());
 
-        active_fe_index_transfer =
-          std_cxx14::make_unique<ActiveFEIndexTransfer>();
+        active_fe_index_transfer = std::make_unique<ActiveFEIndexTransfer>();
 
         // Create transfer object and attach to it.
         const auto *distributed_tria = dynamic_cast<
           const parallel::distributed::Triangulation<dim, spacedim> *>(
           &this->get_triangulation());
 
-        active_fe_index_transfer->cell_data_transfer = std_cxx14::make_unique<
+        active_fe_index_transfer->cell_data_transfer = std::make_unique<
           parallel::distributed::
             CellDataTransfer<dim, spacedim, std::vector<unsigned int>>>(
           *distributed_tria,
@@ -2281,15 +2277,14 @@ namespace hp
       {
         Assert(active_fe_index_transfer == nullptr, ExcInternalError());
 
-        active_fe_index_transfer =
-          std_cxx14::make_unique<ActiveFEIndexTransfer>();
+        active_fe_index_transfer = std::make_unique<ActiveFEIndexTransfer>();
 
         // Create transfer object and attach to it.
         const auto *distributed_tria = dynamic_cast<
           const parallel::distributed::Triangulation<dim, spacedim> *>(
           &this->get_triangulation());
 
-        active_fe_index_transfer->cell_data_transfer = std_cxx14::make_unique<
+        active_fe_index_transfer->cell_data_transfer = std::make_unique<
           parallel::distributed::
             CellDataTransfer<dim, spacedim, std::vector<unsigned int>>>(
           *distributed_tria,
index ec227e87b0f7128c30c2ea090a4a8e33feca7177..edf8241c37660ccd00c21b63959ab2ab03367b2c 100644 (file)
@@ -90,11 +90,10 @@ namespace hp
               nullptr)
             task_group += Threads::new_task([&, fe_index, m_index, q_index]() {
               fe_values_table[fe_index][m_index][q_index] =
-                std_cxx14::make_unique<FEValuesType>(
-                  (*mapping_collection)[m_index],
-                  (*fe_collection)[fe_index],
-                  q_collection[q_index],
-                  update_flags);
+                std::make_unique<FEValuesType>((*mapping_collection)[m_index],
+                                               (*fe_collection)[fe_index],
+                                               q_collection[q_index],
+                                               update_flags);
             });
 
     task_group.join_all();
@@ -124,11 +123,10 @@ namespace hp
     // of indices
     if (fe_values_table(present_fe_values_index).get() == nullptr)
       fe_values_table(present_fe_values_index) =
-        std_cxx14::make_unique<FEValuesType>(
-          (*mapping_collection)[mapping_index],
-          (*fe_collection)[fe_index],
-          q_collection[q_index],
-          update_flags);
+        std::make_unique<FEValuesType>((*mapping_collection)[mapping_index],
+                                       (*fe_collection)[fe_index],
+                                       q_collection[q_index],
+                                       update_flags);
 
     // now there definitely is one!
     return *fe_values_table(present_fe_values_index);
@@ -160,7 +158,7 @@ namespace hp
         task_group +=
           Threads::new_task([&, fe_index, mapping_index, q_index]() {
             fe_values_table(TableIndices<3>(fe_index, mapping_index, q_index)) =
-              std_cxx14::make_unique<FEValuesType>(
+              std::make_unique<FEValuesType>(
                 (*mapping_collection)[mapping_index],
                 (*fe_collection)[fe_index],
                 q_collection[q_index],
index 0b0f5ec82801bd437b920800a495730a52ed542e..19f2a6982e58780b0280c31c397f599ca7c23c56 100644 (file)
@@ -1584,8 +1584,8 @@ LAPACKFullMatrix<number>::compute_svd()
   std::fill(wr.begin(), wr.end(), 0.);
   ipiv.resize(8 * mm);
 
-  svd_u  = std_cxx14::make_unique<LAPACKFullMatrix<number>>(mm, mm);
-  svd_vt = std_cxx14::make_unique<LAPACKFullMatrix<number>>(nn, nn);
+  svd_u                = std::make_unique<LAPACKFullMatrix<number>>(mm, mm);
+  svd_vt               = std::make_unique<LAPACKFullMatrix<number>>(nn, nn);
   types::blas_int info = 0;
 
   // First determine optimal workspace size
index 8ef6624eeb61191026859dabea2137e8fd98ebc7..f154976e40e0604b898a5fcd1b38d4e4b06b1de2 100644 (file)
@@ -72,7 +72,7 @@ namespace PETScWrappers
     // is necessary
     if (solver_data.get() == nullptr)
       {
-        solver_data = std_cxx14::make_unique<SolverData>();
+        solver_data = std::make_unique<SolverData>();
 
         PetscErrorCode ierr = KSPCreate(mpi_communicator, &solver_data->ksp);
         AssertThrow(ierr == 0, ExcPETScError(ierr));
@@ -214,7 +214,7 @@ namespace PETScWrappers
   {
     PetscErrorCode ierr;
 
-    solver_data = std_cxx14::make_unique<SolverData>();
+    solver_data = std::make_unique<SolverData>();
 
     ierr = KSPCreate(mpi_communicator, &solver_data->ksp);
     AssertThrow(ierr == 0, ExcPETScError(ierr));
@@ -698,7 +698,7 @@ namespace PETScWrappers
      */
     if (solver_data == nullptr)
       {
-        solver_data = std_cxx14::make_unique<SolverDataMUMPS>();
+        solver_data = std::make_unique<SolverDataMUMPS>();
 
         /**
          * creates the default KSP context and puts it in the location
index 4b729718a011c87c9bbf5db3a2f1543cf4fc78a9..dabab61574ef6312748461f41663614068864b74 100644 (file)
@@ -1501,10 +1501,10 @@ ScaLAPACKMatrix<NumberType>::eigenpairs_symmetric(
   // distributed matrix
   std::unique_ptr<ScaLAPACKMatrix<NumberType>> eigenvectors =
     compute_eigenvectors ?
-      std_cxx14::make_unique<ScaLAPACKMatrix<NumberType>>(n_rows,
-                                                          grid,
-                                                          row_block_size) :
-      std_cxx14::make_unique<ScaLAPACKMatrix<NumberType>>(
+      std::make_unique<ScaLAPACKMatrix<NumberType>>(n_rows,
+                                                    grid,
+                                                    row_block_size) :
+      std::make_unique<ScaLAPACKMatrix<NumberType>>(
         grid->n_process_rows, grid->n_process_columns, grid, 1, 1);
 
   eigenvectors->property = property;
@@ -1832,10 +1832,10 @@ ScaLAPACKMatrix<NumberType>::eigenpairs_symmetric_MRRR(
   // distributed matrix.
   std::unique_ptr<ScaLAPACKMatrix<NumberType>> eigenvectors =
     compute_eigenvectors ?
-      std_cxx14::make_unique<ScaLAPACKMatrix<NumberType>>(n_rows,
-                                                          grid,
-                                                          row_block_size) :
-      std_cxx14::make_unique<ScaLAPACKMatrix<NumberType>>(
+      std::make_unique<ScaLAPACKMatrix<NumberType>>(n_rows,
+                                                    grid,
+                                                    row_block_size) :
+      std::make_unique<ScaLAPACKMatrix<NumberType>>(
         grid->n_process_rows, grid->n_process_columns, grid, 1, 1);
 
   eigenvectors->property = property;
index 4e4d148655efd7183c5b68050cacdfb420f0afe1..e86646d201d3d0835a8d1ae3f9779c7dead4ec17 100644 (file)
@@ -275,7 +275,7 @@ SparsityPattern::reinit(const size_type                      m,
     {
       vec_len     = 1;
       max_vec_len = vec_len;
-      colnums     = std_cxx14::make_unique<size_type[]>(max_vec_len);
+      colnums     = std::make_unique<size_type[]>(max_vec_len);
     }
 
   max_row_length =
@@ -297,14 +297,14 @@ SparsityPattern::reinit(const size_type                      m,
   if (rows > max_dim)
     {
       max_dim  = rows;
-      rowstart = std_cxx14::make_unique<std::size_t[]>(max_dim + 1);
+      rowstart = std::make_unique<std::size_t[]>(max_dim + 1);
     }
 
   // allocate memory for the column numbers if necessary
   if (vec_len > max_vec_len)
     {
       max_vec_len = vec_len;
-      colnums     = std_cxx14::make_unique<size_type[]>(max_vec_len);
+      colnums     = std::make_unique<size_type[]>(max_vec_len);
     }
 
   // set the rowstart array
@@ -1007,8 +1007,8 @@ SparsityPattern::block_read(std::istream &in)
   AssertThrow(c == '[', ExcIO());
 
   // reallocate space
-  rowstart = std_cxx14::make_unique<std::size_t[]>(max_dim + 1);
-  colnums  = std_cxx14::make_unique<size_type[]>(max_vec_len);
+  rowstart = std::make_unique<std::size_t[]>(max_dim + 1);
+  colnums  = std::make_unique<size_type[]>(max_vec_len);
 
   // then read data
   in.read(reinterpret_cast<char *>(rowstart.get()),
index a9ec4270bd7d41ef0fcd729618aa2bbf53b5bf60..646a61f7bf91049d08d9fe4c1fe088262690d3f7 100644 (file)
@@ -311,8 +311,7 @@ namespace SparsityTools
       (void)cell_weights;
 
       // MPI environment must have been initialized by this point.
-      std::unique_ptr<Zoltan> zz =
-        std_cxx14::make_unique<Zoltan>(MPI_COMM_SELF);
+      std::unique_ptr<Zoltan> zz = std::make_unique<Zoltan>(MPI_COMM_SELF);
 
       // General parameters
       // DEBUG_LEVEL call must precede the call to LB_METHOD
@@ -465,7 +464,7 @@ namespace SparsityTools
     return 0;
 #else
     // coloring algorithm is run in serial by each processor.
-    std::unique_ptr<Zoltan> zz = std_cxx14::make_unique<Zoltan>(MPI_COMM_SELF);
+    std::unique_ptr<Zoltan> zz = std::make_unique<Zoltan>(MPI_COMM_SELF);
 
     // Coloring parameters
     // DEBUG_LEVEL must precede all other calls
index e24e1fe5e2ecfdd012a1c6a42021a769df7f53d6..ac160b08b17cd795884eb9c9b24fb0aabc00ad54 100644 (file)
@@ -63,8 +63,8 @@ namespace LinearAlgebra
       // Target map is read_write_vector_map
       // Source map is vector_space_vector_map. This map must have uniquely
       // owned GID.
-      import = std_cxx14::make_unique<Epetra_Import>(read_write_vector_map,
-                                                     vector_space_vector_map);
+      import = std::make_unique<Epetra_Import>(read_write_vector_map,
+                                               vector_space_vector_map);
     }
 
 
index d786c08aecd2794de7f1b4815a45b3e741ae3b3f..580c7e9d3c7570dcb79a1d96cfaa4636627f8074 100644 (file)
@@ -72,7 +72,7 @@ namespace LinearAlgebra
       Epetra_Map input_map =
         parallel_partitioner.make_trilinos_map(communicator, false);
       if (vector->Map().SameAs(input_map) == false)
-        vector = std_cxx14::make_unique<Epetra_FEVector>(input_map);
+        vector = std::make_unique<Epetra_FEVector>(input_map);
       else if (omit_zeroing_entries == false)
         {
           const int ierr = vector->PutScalar(0.);
@@ -123,8 +123,7 @@ namespace LinearAlgebra
               (void)ierr;
             }
           else
-            vector =
-              std_cxx14::make_unique<Epetra_FEVector>(V.trilinos_vector());
+            vector = std::make_unique<Epetra_FEVector>(V.trilinos_vector());
         }
 
       return *this;
index 80d5fa436804826d0b4eff85150dbba51b586e5a..9020a44208c0d0ef8d6ec5d53d0328b4ad4a5cb0 100644 (file)
@@ -132,7 +132,7 @@ namespace TrilinosWrappers
     const Epetra_Map &domain_map = matrix.OperatorDomainMap();
 
     const size_type constant_modes_dimension = constant_modes.size();
-    ptr_distributed_constant_modes = std_cxx14::make_unique<Epetra_MultiVector>(
+    ptr_distributed_constant_modes = std::make_unique<Epetra_MultiVector>(
       domain_map, constant_modes_dimension > 0 ? constant_modes_dimension : 1);
     Assert(ptr_distributed_constant_modes, ExcNotInitialized());
     Epetra_MultiVector &distributed_constant_modes =
index b04542484f3ba6b57de0ea6d25675591718c5121..990841cf8682c4525699a02a7d4bf20801d817fc 100644 (file)
@@ -80,7 +80,7 @@ namespace TrilinosWrappers
   {
     // We need an Epetra_LinearProblem object to let the AztecOO solver know
     // about the matrix and vectors.
-    linear_problem = std_cxx14::make_unique<Epetra_LinearProblem>(
+    linear_problem = std::make_unique<Epetra_LinearProblem>(
       const_cast<Epetra_CrsMatrix *>(&A.trilinos_matrix()),
       &x.trilinos_vector(),
       const_cast<Epetra_MultiVector *>(&b.trilinos_vector()));
@@ -100,10 +100,11 @@ namespace TrilinosWrappers
   {
     // We need an Epetra_LinearProblem object to let the AztecOO solver know
     // about the matrix and vectors.
-    linear_problem = std_cxx14::make_unique<Epetra_LinearProblem>(
-      const_cast<Epetra_Operator *>(&A),
-      &x.trilinos_vector(),
-      const_cast<Epetra_MultiVector *>(&b.trilinos_vector()));
+    linear_problem =
+      std::make_unique<Epetra_LinearProblem>(const_cast<Epetra_Operator *>(&A),
+                                             &x.trilinos_vector(),
+                                             const_cast<Epetra_MultiVector *>(
+                                               &b.trilinos_vector()));
 
     do_solve(preconditioner);
   }
@@ -120,10 +121,11 @@ namespace TrilinosWrappers
   {
     // We need an Epetra_LinearProblem object to let the AztecOO solver know
     // about the matrix and vectors.
-    linear_problem = std_cxx14::make_unique<Epetra_LinearProblem>(
-      const_cast<Epetra_Operator *>(&A),
-      &x.trilinos_vector(),
-      const_cast<Epetra_MultiVector *>(&b.trilinos_vector()));
+    linear_problem =
+      std::make_unique<Epetra_LinearProblem>(const_cast<Epetra_Operator *>(&A),
+                                             &x.trilinos_vector(),
+                                             const_cast<Epetra_MultiVector *>(
+                                               &b.trilinos_vector()));
 
     do_solve(preconditioner);
   }
@@ -140,10 +142,11 @@ namespace TrilinosWrappers
   {
     // We need an Epetra_LinearProblem object to let the AztecOO solver know
     // about the matrix and vectors.
-    linear_problem = std_cxx14::make_unique<Epetra_LinearProblem>(
-      const_cast<Epetra_Operator *>(&A),
-      &x,
-      const_cast<Epetra_MultiVector *>(&b));
+    linear_problem =
+      std::make_unique<Epetra_LinearProblem>(const_cast<Epetra_Operator *>(&A),
+                                             &x,
+                                             const_cast<Epetra_MultiVector *>(
+                                               &b));
 
     do_solve(preconditioner);
   }
@@ -160,10 +163,11 @@ namespace TrilinosWrappers
   {
     // We need an Epetra_LinearProblem object to let the AztecOO solver know
     // about the matrix and vectors.
-    linear_problem = std_cxx14::make_unique<Epetra_LinearProblem>(
-      const_cast<Epetra_Operator *>(&A),
-      &x,
-      const_cast<Epetra_MultiVector *>(&b));
+    linear_problem =
+      std::make_unique<Epetra_LinearProblem>(const_cast<Epetra_Operator *>(&A),
+                                             &x,
+                                             const_cast<Epetra_MultiVector *>(
+                                               &b));
 
     do_solve(preconditioner);
   }
@@ -192,7 +196,7 @@ namespace TrilinosWrappers
 
     // We need an Epetra_LinearProblem object to let the AztecOO solver know
     // about the matrix and vectors.
-    linear_problem = std_cxx14::make_unique<Epetra_LinearProblem>(
+    linear_problem = std::make_unique<Epetra_LinearProblem>(
       const_cast<Epetra_CrsMatrix *>(&A.trilinos_matrix()), &ep_x, &ep_b);
 
     do_solve(preconditioner);
@@ -213,8 +217,7 @@ namespace TrilinosWrappers
 
     // We need an Epetra_LinearProblem object to let the AztecOO solver know
     // about the matrix and vectors.
-    linear_problem =
-      std_cxx14::make_unique<Epetra_LinearProblem>(&A, &ep_x, &ep_b);
+    linear_problem = std::make_unique<Epetra_LinearProblem>(&A, &ep_x, &ep_b);
 
     do_solve(preconditioner);
   }
@@ -241,7 +244,7 @@ namespace TrilinosWrappers
 
     // We need an Epetra_LinearProblem object to let the AztecOO solver know
     // about the matrix and vectors.
-    linear_problem = std_cxx14::make_unique<Epetra_LinearProblem>(
+    linear_problem = std::make_unique<Epetra_LinearProblem>(
       const_cast<Epetra_CrsMatrix *>(&A.trilinos_matrix()), &ep_x, &ep_b);
 
     do_solve(preconditioner);
@@ -265,8 +268,7 @@ namespace TrilinosWrappers
 
     // We need an Epetra_LinearProblem object to let the AztecOO solver know
     // about the matrix and vectors.
-    linear_problem =
-      std_cxx14::make_unique<Epetra_LinearProblem>(&A, &ep_x, &ep_b);
+    linear_problem = std::make_unique<Epetra_LinearProblem>(&A, &ep_x, &ep_b);
 
     do_solve(preconditioner);
   }
@@ -366,21 +368,20 @@ namespace TrilinosWrappers
         , current_residual(std::numeric_limits<double>::max())
         // Consider linear problem converged if any of the collection of
         // criterion are met
-        , status_test_collection(
-            std_cxx14::make_unique<AztecOO_StatusTestCombo>(
-              AztecOO_StatusTestCombo::OR))
+        , status_test_collection(std::make_unique<AztecOO_StatusTestCombo>(
+            AztecOO_StatusTestCombo::OR))
       {
         // Maximum number of iterations
         Assert(max_steps >= 0, ExcInternalError());
         status_test_max_steps =
-          std_cxx14::make_unique<AztecOO_StatusTestMaxIters>(max_steps);
+          std::make_unique<AztecOO_StatusTestMaxIters>(max_steps);
         status_test_collection->AddStatusTest(*status_test_max_steps);
 
         Assert(linear_problem.GetRHS()->NumVectors() == 1,
                ExcMessage("RHS multivector holds more than one vector"));
 
         // Residual norm is below some absolute value
-        status_test_abs_tol = std_cxx14::make_unique<AztecOO_StatusTestResNorm>(
+        status_test_abs_tol = std::make_unique<AztecOO_StatusTestResNorm>(
           *linear_problem.GetOperator(),
           *(linear_problem.GetLHS()->operator()(0)),
           *(linear_problem.GetRHS()->operator()(0)),
@@ -392,7 +393,7 @@ namespace TrilinosWrappers
         status_test_collection->AddStatusTest(*status_test_abs_tol);
 
         // Residual norm, scaled by some initial value, is below some threshold
-        status_test_rel_tol = std_cxx14::make_unique<AztecOO_StatusTestResNorm>(
+        status_test_rel_tol = std::make_unique<AztecOO_StatusTestResNorm>(
           *linear_problem.GetOperator(),
           *(linear_problem.GetLHS()->operator()(0)),
           *(linear_problem.GetRHS()->operator()(0)),
@@ -469,12 +470,11 @@ namespace TrilinosWrappers
         if (const ReductionControl *const reduction_control =
               dynamic_cast<const ReductionControl *const>(&solver_control))
           {
-            status_test =
-              std_cxx14::make_unique<internal::TrilinosReductionControl>(
-                reduction_control->max_steps(),
-                reduction_control->tolerance(),
-                reduction_control->reduction(),
-                *linear_problem);
+            status_test = std::make_unique<internal::TrilinosReductionControl>(
+              reduction_control->max_steps(),
+              reduction_control->tolerance(),
+              reduction_control->reduction(),
+              *linear_problem);
             solver.SetStatusTest(status_test.get());
           }
       }
@@ -703,7 +703,7 @@ namespace TrilinosWrappers
   {
     // We need an Epetra_LinearProblem object to let the Amesos solver know
     // about the matrix and vectors.
-    linear_problem = std_cxx14::make_unique<Epetra_LinearProblem>();
+    linear_problem = std::make_unique<Epetra_LinearProblem>();
 
     // Assign the matrix operator to the Epetra_LinearProblem object
     linear_problem->SetOperator(
@@ -864,7 +864,7 @@ namespace TrilinosWrappers
   {
     // We need an Epetra_LinearProblem object to let the Amesos solver know
     // about the matrix and vectors.
-    linear_problem = std_cxx14::make_unique<Epetra_LinearProblem>(
+    linear_problem = std::make_unique<Epetra_LinearProblem>(
       const_cast<Epetra_CrsMatrix *>(&A.trilinos_matrix()),
       &x.trilinos_vector(),
       const_cast<Epetra_MultiVector *>(&b.trilinos_vector()));
@@ -892,7 +892,7 @@ namespace TrilinosWrappers
 
     // We need an Epetra_LinearProblem object to let the Amesos solver know
     // about the matrix and vectors.
-    linear_problem = std_cxx14::make_unique<Epetra_LinearProblem>(
+    linear_problem = std::make_unique<Epetra_LinearProblem>(
       const_cast<Epetra_CrsMatrix *>(&A.trilinos_matrix()), &ep_x, &ep_b);
 
     do_solve();
@@ -917,7 +917,7 @@ namespace TrilinosWrappers
 
     // We need an Epetra_LinearProblem object to let the Amesos solver know
     // about the matrix and vectors.
-    linear_problem = std_cxx14::make_unique<Epetra_LinearProblem>(
+    linear_problem = std::make_unique<Epetra_LinearProblem>(
       const_cast<Epetra_CrsMatrix *>(&A.trilinos_matrix()), &ep_x, &ep_b);
 
     do_solve();
index f8592dce67bdd3e123e5b62aa4b24aac8a31cbd8..e4b3d3279e37311498d7ef5361c3e79b6a79f264 100644 (file)
@@ -429,18 +429,17 @@ namespace TrilinosWrappers
     if (needs_deep_copy)
       {
         column_space_map =
-          std_cxx14::make_unique<Epetra_Map>(rhs.trilinos_matrix().DomainMap());
+          std::make_unique<Epetra_Map>(rhs.trilinos_matrix().DomainMap());
 
         // release memory before reallocation
-        matrix = std_cxx14::make_unique<Epetra_FECrsMatrix>(*rhs.matrix);
+        matrix = std::make_unique<Epetra_FECrsMatrix>(*rhs.matrix);
 
         matrix->FillComplete(*column_space_map, matrix->RowMap());
       }
 
     if (rhs.nonlocal_matrix.get() != nullptr)
       nonlocal_matrix =
-        std_cxx14::make_unique<Epetra_CrsMatrix>(Copy,
-                                                 rhs.nonlocal_matrix->Graph());
+        std::make_unique<Epetra_CrsMatrix>(Copy, rhs.nonlocal_matrix->Graph());
   }
 
 
@@ -466,7 +465,7 @@ namespace TrilinosWrappers
       nonlocal_matrix.reset();
       nonlocal_matrix_exporter.reset();
 
-      column_space_map = std_cxx14::make_unique<Epetra_Map>(
+      column_space_map = std::make_unique<Epetra_Map>(
         column_parallel_partitioning.make_trilinos_map(communicator, false));
 
       if (column_space_map->Comm().MyPID() == 0)
@@ -492,7 +491,7 @@ namespace TrilinosWrappers
                                    sparsity_pattern,
                                    communicator,
                                    exchange_data);
-          matrix = std_cxx14::make_unique<Epetra_FECrsMatrix>(
+          matrix = std::make_unique<Epetra_FECrsMatrix>(
             Copy, trilinos_sparsity.trilinos_sparsity_pattern(), false);
 
           return;
@@ -522,11 +521,12 @@ namespace TrilinosWrappers
       // columns as well. Compare this with bug # 4123 in the Sandia Bugzilla.
       std::unique_ptr<Epetra_CrsGraph> graph;
       if (row_space_map.Comm().NumProc() > 1)
-        graph = std_cxx14::make_unique<Epetra_CrsGraph>(
-          Copy, row_space_map, n_entries_per_row.data(), true);
+        graph = std::make_unique<Epetra_CrsGraph>(Copy,
+                                                  row_space_map,
+                                                  n_entries_per_row.data(),
+                                                  true);
       else
-        graph =
-          std_cxx14::make_unique<Epetra_CrsGraph>(Copy,
+        graph = std::make_unique<Epetra_CrsGraph>(Copy,
                                                   row_space_map,
                                                   *column_space_map,
                                                   n_entries_per_row.data(),
@@ -570,7 +570,7 @@ namespace TrilinosWrappers
       (void)n_global_cols;
 
       // And now finally generate the matrix.
-      matrix = std_cxx14::make_unique<Epetra_FECrsMatrix>(Copy, *graph, false);
+      matrix = std::make_unique<Epetra_FECrsMatrix>(Copy, *graph, false);
     }
 
 
@@ -617,7 +617,7 @@ namespace TrilinosWrappers
       nonlocal_matrix.reset();
       nonlocal_matrix_exporter.reset();
 
-      column_space_map = std_cxx14::make_unique<Epetra_Map>(
+      column_space_map = std::make_unique<Epetra_Map>(
         column_parallel_partitioning.make_trilinos_map(communicator, false));
 
       AssertDimension(sparsity_pattern.n_rows(),
@@ -692,23 +692,26 @@ namespace TrilinosWrappers
       std::unique_ptr<Epetra_CrsGraphMod> nonlocal_graph;
       if (row_space_map.Comm().NumProc() > 1)
         {
-          graph = std_cxx14::make_unique<Epetra_CrsGraph>(
-            Copy,
-            row_space_map,
-            (n_entries_per_row.size() > 0) ? (n_entries_per_row.data()) :
-                                             nullptr,
-            exchange_data ? false : true);
+          graph =
+            std::make_unique<Epetra_CrsGraph>(Copy,
+                                              row_space_map,
+                                              (n_entries_per_row.size() > 0) ?
+                                                (n_entries_per_row.data()) :
+                                                nullptr,
+                                              exchange_data ? false : true);
           if (have_ghost_rows == true)
-            nonlocal_graph = std_cxx14::make_unique<Epetra_CrsGraphMod>(
+            nonlocal_graph = std::make_unique<Epetra_CrsGraphMod>(
               off_processor_map, n_entries_per_ghost_row.data());
         }
       else
-        graph = std_cxx14::make_unique<Epetra_CrsGraph>(
-          Copy,
-          row_space_map,
-          *column_space_map,
-          (n_entries_per_row.size() > 0) ? (n_entries_per_row.data()) : nullptr,
-          true);
+        graph =
+          std::make_unique<Epetra_CrsGraph>(Copy,
+                                            row_space_map,
+                                            *column_space_map,
+                                            (n_entries_per_row.size() > 0) ?
+                                              (n_entries_per_row.data()) :
+                                              nullptr,
+                                            true);
 
       // now insert the indices, select between the right matrix
       std::vector<TrilinosWrappers::types::int_type> row_indices;
@@ -761,7 +764,7 @@ namespace TrilinosWrappers
             }
 
           nonlocal_matrix =
-            std_cxx14::make_unique<Epetra_CrsMatrix>(Copy, *nonlocal_graph);
+            std::make_unique<Epetra_CrsMatrix>(Copy, *nonlocal_graph);
         }
 
       graph->FillComplete(*column_space_map, row_space_map);
@@ -770,7 +773,7 @@ namespace TrilinosWrappers
       AssertDimension(sparsity_pattern.n_cols(),
                       TrilinosWrappers::n_global_cols(*graph));
 
-      matrix = std_cxx14::make_unique<Epetra_FECrsMatrix>(Copy, *graph, false);
+      matrix = std::make_unique<Epetra_FECrsMatrix>(Copy, *graph, false);
     }
   } // namespace
 
@@ -829,13 +832,14 @@ namespace TrilinosWrappers
 
     // reinit with a (parallel) Trilinos sparsity pattern.
     column_space_map =
-      std_cxx14::make_unique<Epetra_Map>(sparsity_pattern.domain_partitioner());
-    matrix = std_cxx14::make_unique<Epetra_FECrsMatrix>(
+      std::make_unique<Epetra_Map>(sparsity_pattern.domain_partitioner());
+    matrix = std::make_unique<Epetra_FECrsMatrix>(
       Copy, sparsity_pattern.trilinos_sparsity_pattern(), false);
 
     if (sparsity_pattern.nonlocal_graph.get() != nullptr)
-      nonlocal_matrix = std_cxx14::make_unique<Epetra_CrsMatrix>(
-        Copy, *sparsity_pattern.nonlocal_graph);
+      nonlocal_matrix =
+        std::make_unique<Epetra_CrsMatrix>(Copy,
+                                           *sparsity_pattern.nonlocal_graph);
     else
       nonlocal_matrix.reset();
 
@@ -851,15 +855,15 @@ namespace TrilinosWrappers
     if (this == &sparse_matrix)
       return;
 
-    column_space_map = std_cxx14::make_unique<Epetra_Map>(
-      sparse_matrix.trilinos_matrix().DomainMap());
+    column_space_map =
+      std::make_unique<Epetra_Map>(sparse_matrix.trilinos_matrix().DomainMap());
     matrix.reset();
     nonlocal_matrix_exporter.reset();
-    matrix = std_cxx14::make_unique<Epetra_FECrsMatrix>(
+    matrix = std::make_unique<Epetra_FECrsMatrix>(
       Copy, sparse_matrix.trilinos_sparsity_pattern(), false);
 
     if (sparse_matrix.nonlocal_matrix != nullptr)
-      nonlocal_matrix = std_cxx14::make_unique<Epetra_CrsMatrix>(
+      nonlocal_matrix = std::make_unique<Epetra_CrsMatrix>(
         Copy, sparse_matrix.nonlocal_matrix->Graph());
     else
       nonlocal_matrix.reset();
@@ -1008,15 +1012,14 @@ namespace TrilinosWrappers
     Assert(input_matrix.Filled() == true,
            ExcMessage("Input CrsMatrix has not called FillComplete()!"));
 
-    column_space_map =
-      std_cxx14::make_unique<Epetra_Map>(input_matrix.DomainMap());
+    column_space_map = std::make_unique<Epetra_Map>(input_matrix.DomainMap());
 
     const Epetra_CrsGraph *graph = &input_matrix.Graph();
 
     nonlocal_matrix.reset();
     nonlocal_matrix_exporter.reset();
     matrix.reset();
-    matrix = std_cxx14::make_unique<Epetra_FECrsMatrix>(Copy, *graph, false);
+    matrix = std::make_unique<Epetra_FECrsMatrix>(Copy, *graph, false);
 
     matrix->FillComplete(*column_space_map, input_matrix.RangeMap(), true);
 
@@ -1071,8 +1074,8 @@ namespace TrilinosWrappers
         nonlocal_matrix->FillComplete(*column_space_map, matrix->RowMap());
         if (nonlocal_matrix_exporter.get() == nullptr)
           nonlocal_matrix_exporter =
-            std_cxx14::make_unique<Epetra_Export>(nonlocal_matrix->RowMap(),
-                                                  matrix->RowMap());
+            std::make_unique<Epetra_Export>(nonlocal_matrix->RowMap(),
+                                            matrix->RowMap());
         ierr =
           matrix->Export(*nonlocal_matrix, *nonlocal_matrix_exporter, mode);
         AssertThrow(ierr == 0, ExcTrilinosError(ierr));
@@ -1102,11 +1105,8 @@ namespace TrilinosWrappers
     // the pointer and generate an
     // empty matrix.
     column_space_map =
-      std_cxx14::make_unique<Epetra_Map>(0,
-                                         0,
-                                         Utilities::Trilinos::comm_self());
-    matrix =
-      std_cxx14::make_unique<Epetra_FECrsMatrix>(View, *column_space_map, 0);
+      std::make_unique<Epetra_Map>(0, 0, Utilities::Trilinos::comm_self());
+    matrix = std::make_unique<Epetra_FECrsMatrix>(View, *column_space_map, 0);
     nonlocal_matrix.reset();
     nonlocal_matrix_exporter.reset();
 
index f1faa15f15001e15369cbc66a72820194c6f0a77..719978f904b333172ad9c4c3d5e7b1f7ae6c6f0e 100644 (file)
@@ -83,13 +83,13 @@ namespace TrilinosWrappers
   SparsityPattern::SparsityPattern()
   {
     column_space_map =
-      std_cxx14::make_unique<Epetra_Map>(TrilinosWrappers::types::int_type(0),
-                                         TrilinosWrappers::types::int_type(0),
-                                         Utilities::Trilinos::comm_self());
-    graph = std_cxx14::make_unique<Epetra_FECrsGraph>(View,
-                                                      *column_space_map,
-                                                      *column_space_map,
-                                                      0);
+      std::make_unique<Epetra_Map>(TrilinosWrappers::types::int_type(0),
+                                   TrilinosWrappers::types::int_type(0),
+                                   Utilities::Trilinos::comm_self());
+    graph = std::make_unique<Epetra_FECrsGraph>(View,
+                                                *column_space_map,
+                                                *column_space_map,
+                                                0);
     graph->FillComplete();
   }
 
@@ -255,7 +255,7 @@ namespace TrilinosWrappers
 
       nonlocal_graph.reset();
       graph.reset();
-      column_space_map = std_cxx14::make_unique<Epetra_Map>(col_map);
+      column_space_map = std::make_unique<Epetra_Map>(col_map);
 
       // for more than one processor, need to specify only row map first and
       // let the matrix entries decide about the column map (which says which
@@ -266,7 +266,7 @@ namespace TrilinosWrappers
       // require building a non-local graph which gives us thread-safe
       // initialization.
       if (row_map.Comm().NumProc() > 1)
-        graph = std_cxx14::make_unique<Epetra_FECrsGraph>(
+        graph = std::make_unique<Epetra_FECrsGraph>(
           Copy, row_map, n_entries_per_row, false
           // TODO: Check which new Trilinos version supports this...
           // Remember to change tests/trilinos/assemble_matrix_parallel_07, too.
@@ -275,7 +275,7 @@ namespace TrilinosWrappers
           //#endif
         );
       else
-        graph = std_cxx14::make_unique<Epetra_FECrsGraph>(
+        graph = std::make_unique<Epetra_FECrsGraph>(
           Copy, row_map, col_map, n_entries_per_row, false);
     }
 
@@ -302,7 +302,7 @@ namespace TrilinosWrappers
       AssertDimension(n_entries_per_row.size(),
                       TrilinosWrappers::n_global_elements(row_map));
 
-      column_space_map = std_cxx14::make_unique<Epetra_Map>(col_map);
+      column_space_map = std::make_unique<Epetra_Map>(col_map);
       std::vector<int> local_entries_per_row(
         TrilinosWrappers::max_my_gid(row_map) -
         TrilinosWrappers::min_my_gid(row_map));
@@ -311,7 +311,7 @@ namespace TrilinosWrappers
           n_entries_per_row[TrilinosWrappers::min_my_gid(row_map) + i];
 
       if (row_map.Comm().NumProc() > 1)
-        graph = std_cxx14::make_unique<Epetra_FECrsGraph>(
+        graph = std::make_unique<Epetra_FECrsGraph>(
           Copy, row_map, local_entries_per_row.data(), false
           // TODO: Check which new Trilinos version supports this...
           // Remember to change tests/trilinos/assemble_matrix_parallel_07, too.
@@ -320,7 +320,7 @@ namespace TrilinosWrappers
           //#endif
         );
       else
-        graph = std_cxx14::make_unique<Epetra_FECrsGraph>(
+        graph = std::make_unique<Epetra_FECrsGraph>(
           Copy, row_map, col_map, local_entries_per_row.data(), false);
     }
 
@@ -344,7 +344,7 @@ namespace TrilinosWrappers
       AssertDimension(sp.n_cols(),
                       TrilinosWrappers::n_global_elements(col_map));
 
-      column_space_map = std_cxx14::make_unique<Epetra_Map>(col_map);
+      column_space_map = std::make_unique<Epetra_Map>(col_map);
 
       Assert(row_map.LinearMap() == true,
              ExcMessage(
@@ -361,10 +361,12 @@ namespace TrilinosWrappers
           static_cast<int>(sp.row_length(row));
 
       if (row_map.Comm().NumProc() > 1)
-        graph = std_cxx14::make_unique<Epetra_FECrsGraph>(
-          Copy, row_map, n_entries_per_row.data(), false);
+        graph = std::make_unique<Epetra_FECrsGraph>(Copy,
+                                                    row_map,
+                                                    n_entries_per_row.data(),
+                                                    false);
       else
-        graph = std_cxx14::make_unique<Epetra_FECrsGraph>(
+        graph = std::make_unique<Epetra_FECrsGraph>(
           Copy, row_map, col_map, n_entries_per_row.data(), false);
 
       AssertDimension(sp.n_rows(), n_global_rows(*graph));
@@ -539,7 +541,7 @@ namespace TrilinosWrappers
         Epetra_Map nonlocal_map =
           nonlocal_partitioner.make_trilinos_map(communicator, true);
         nonlocal_graph =
-          std_cxx14::make_unique<Epetra_CrsGraph>(Copy, nonlocal_map, 0);
+          std::make_unique<Epetra_CrsGraph>(Copy, nonlocal_map, 0);
       }
     else
       Assert(nonlocal_partitioner.n_elements() == 0, ExcInternalError());
@@ -604,12 +606,11 @@ namespace TrilinosWrappers
   void
   SparsityPattern::copy_from(const SparsityPattern &sp)
   {
-    column_space_map = std_cxx14::make_unique<Epetra_Map>(*sp.column_space_map);
-    graph            = std_cxx14::make_unique<Epetra_FECrsGraph>(*sp.graph);
+    column_space_map = std::make_unique<Epetra_Map>(*sp.column_space_map);
+    graph            = std::make_unique<Epetra_FECrsGraph>(*sp.graph);
 
     if (sp.nonlocal_graph.get() != nullptr)
-      nonlocal_graph =
-        std_cxx14::make_unique<Epetra_CrsGraph>(*sp.nonlocal_graph);
+      nonlocal_graph = std::make_unique<Epetra_CrsGraph>(*sp.nonlocal_graph);
     else
       nonlocal_graph.reset();
   }
@@ -640,13 +641,13 @@ namespace TrilinosWrappers
     // the pointer and generate an
     // empty sparsity pattern.
     column_space_map =
-      std_cxx14::make_unique<Epetra_Map>(TrilinosWrappers::types::int_type(0),
-                                         TrilinosWrappers::types::int_type(0),
-                                         Utilities::Trilinos::comm_self());
-    graph = std_cxx14::make_unique<Epetra_FECrsGraph>(View,
-                                                      *column_space_map,
-                                                      *column_space_map,
-                                                      0);
+      std::make_unique<Epetra_Map>(TrilinosWrappers::types::int_type(0),
+                                   TrilinosWrappers::types::int_type(0),
+                                   Utilities::Trilinos::comm_self());
+    graph = std::make_unique<Epetra_FECrsGraph>(View,
+                                                *column_space_map,
+                                                *column_space_map,
+                                                0);
     graph->FillComplete();
 
     nonlocal_graph.reset();
index 8f9b498acaaa8550292f47b7e24f790f0880e925..042a93145e9a0201cbcc68561aa54bc7aaa5a4b2 100644 (file)
@@ -66,10 +66,10 @@ namespace LinearAlgebra
       // Source map is vector_space_vector_map. This map must have uniquely
       // owned GID.
       tpetra_import =
-        std_cxx14::make_unique<Tpetra::Import<int, types::global_dof_index>>(
+        std::make_unique<Tpetra::Import<int, types::global_dof_index>>(
           read_write_vector_map, vector_space_vector_map);
       tpetra_export =
-        std_cxx14::make_unique<Tpetra::Export<int, types::global_dof_index>>(
+        std::make_unique<Tpetra::Export<int, types::global_dof_index>>(
           read_write_vector_map, vector_space_vector_map);
     }
 
index 83e7133891d23c0b0530cbf499d4cdef81865478..7db15b70fa9978426339fb8789bf222c8e02f7b1 100644 (file)
@@ -91,7 +91,7 @@ namespace TrilinosWrappers
       : Vector()
     {
       has_ghosts     = v.has_ghosts;
-      vector         = std_cxx14::make_unique<Epetra_FEVector>(*v.vector);
+      vector         = std::make_unique<Epetra_FEVector>(*v.vector);
       owned_elements = v.owned_elements;
     }
 
@@ -118,7 +118,7 @@ namespace TrilinosWrappers
                                        TrilinosWrappers::n_global_elements(
                                          v.vector->Map())));
 
-      vector = std_cxx14::make_unique<Epetra_FEVector>(
+      vector = std::make_unique<Epetra_FEVector>(
         parallel_partitioner.make_trilinos_map(communicator, true));
       reinit(v, false, true);
     }
@@ -147,7 +147,7 @@ namespace TrilinosWrappers
 #  endif
 
       has_ghosts  = false;
-      vector      = std_cxx14::make_unique<Epetra_FEVector>(map);
+      vector      = std::make_unique<Epetra_FEVector>(map);
       last_action = Zero;
     }
 
@@ -166,7 +166,7 @@ namespace TrilinosWrappers
       Epetra_Map map =
         parallel_partitioner.make_trilinos_map(communicator, overlapping);
 
-      vector = std_cxx14::make_unique<Epetra_FEVector>(map);
+      vector = std::make_unique<Epetra_FEVector>(map);
 
       has_ghosts = vector->Map().UniqueGIDs() == false;
 
@@ -224,9 +224,9 @@ namespace TrilinosWrappers
           if (!same_communicators ||
               vector->Map().SameAs(v.vector->Map()) == false)
             {
-              vector = std_cxx14::make_unique<Epetra_FEVector>(v.vector->Map());
-              has_ghosts     = v.has_ghosts;
-              last_action    = Zero;
+              vector      = std::make_unique<Epetra_FEVector>(v.vector->Map());
+              has_ghosts  = v.has_ghosts;
+              last_action = Zero;
               owned_elements = v.owned_elements;
             }
           else if (omit_zeroing_entries == false)
@@ -317,7 +317,7 @@ namespace TrilinosWrappers
                          0,
                          v.block(0).trilinos_partitioner().Comm());
 
-      auto actual_vec = std_cxx14::make_unique<Epetra_FEVector>(new_map);
+      auto actual_vec = std::make_unique<Epetra_FEVector>(new_map);
 
       TrilinosScalar *entries = (*actual_vec)[0];
       for (size_type block = 0; block < v.n_blocks(); ++block)
@@ -370,7 +370,7 @@ namespace TrilinosWrappers
           parallel_partitioner.add_indices(ghost_entries);
           Epetra_Map map =
             parallel_partitioner.make_trilinos_map(communicator, true);
-          vector = std_cxx14::make_unique<Epetra_FEVector>(map);
+          vector = std::make_unique<Epetra_FEVector>(map);
         }
       else
         {
@@ -381,7 +381,7 @@ namespace TrilinosWrappers
                             "its parallel partitioning"));
 
           if (vector->Map().SameAs(map) == false)
-            vector = std_cxx14::make_unique<Epetra_FEVector>(map);
+            vector = std::make_unique<Epetra_FEVector>(map);
           else
             {
               const int ierr = vector->PutScalar(0.);
@@ -396,7 +396,7 @@ namespace TrilinosWrappers
               Epetra_Map nonlocal_map =
                 nonlocal_entries.make_trilinos_map(communicator, true);
               nonlocal_vector =
-                std_cxx14::make_unique<Epetra_MultiVector>(nonlocal_map, 1);
+                std::make_unique<Epetra_MultiVector>(nonlocal_map, 1);
             }
         }
 
@@ -462,8 +462,8 @@ namespace TrilinosWrappers
         {
           *vector = *v.vector;
           if (v.nonlocal_vector.get() != nullptr)
-            nonlocal_vector = std_cxx14::make_unique<Epetra_MultiVector>(
-              v.nonlocal_vector->Map(), 1);
+            nonlocal_vector =
+              std::make_unique<Epetra_MultiVector>(v.nonlocal_vector->Map(), 1);
           last_action = Zero;
         }
       // Second case: vectors have the same global
@@ -479,7 +479,7 @@ namespace TrilinosWrappers
       // size.
       else
         {
-          vector         = std_cxx14::make_unique<Epetra_FEVector>(*v.vector);
+          vector         = std::make_unique<Epetra_FEVector>(*v.vector);
           last_action    = Zero;
           has_ghosts     = v.has_ghosts;
           owned_elements = v.owned_elements;
@@ -487,8 +487,7 @@ namespace TrilinosWrappers
 
       if (v.nonlocal_vector.get() != nullptr)
         nonlocal_vector =
-          std_cxx14::make_unique<Epetra_MultiVector>(v.nonlocal_vector->Map(),
-                                                     1);
+          std::make_unique<Epetra_MultiVector>(v.nonlocal_vector->Map(), 1);
 
       return *this;
     }
@@ -537,7 +536,7 @@ namespace TrilinosWrappers
 
       if (vector->Map().SameAs(m.trilinos_matrix().ColMap()) == false)
         vector =
-          std_cxx14::make_unique<Epetra_FEVector>(m.trilinos_matrix().ColMap());
+          std::make_unique<Epetra_FEVector>(m.trilinos_matrix().ColMap());
 
       Epetra_Import data_exchange(vector->Map(), v.vector->Map());
       const int     ierr = vector->Import(*v.vector, data_exchange, Insert);
index 46056b89ba48631619bafd3da39fd616396f439c..eca2d02dce71ee26eb78ea09aa74715a768b4989 100644 (file)
@@ -130,8 +130,10 @@ namespace MeshWorker
     const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell)
   {
     if (!fe_values)
-      fe_values = std_cxx14::make_unique<FEValues<dim, spacedim>>(
-        *mapping, *fe, cell_quadrature, cell_update_flags);
+      fe_values = std::make_unique<FEValues<dim, spacedim>>(*mapping,
+                                                            *fe,
+                                                            cell_quadrature,
+                                                            cell_update_flags);
 
     fe_values->reinit(cell);
     cell->get_dof_indices(local_dof_indices);
@@ -148,7 +150,7 @@ namespace MeshWorker
     const unsigned int                                              face_no)
   {
     if (!fe_face_values)
-      fe_face_values = std_cxx14::make_unique<FEFaceValues<dim, spacedim>>(
+      fe_face_values = std::make_unique<FEFaceValues<dim, spacedim>>(
         *mapping, *fe, face_quadrature, face_update_flags);
 
     fe_face_values->reinit(cell, face_no);
@@ -169,9 +171,8 @@ namespace MeshWorker
     if (subface_no != numbers::invalid_unsigned_int)
       {
         if (!fe_subface_values)
-          fe_subface_values =
-            std_cxx14::make_unique<FESubfaceValues<dim, spacedim>>(
-              *mapping, *fe, face_quadrature, face_update_flags);
+          fe_subface_values = std::make_unique<FESubfaceValues<dim, spacedim>>(
+            *mapping, *fe, face_quadrature, face_update_flags);
         fe_subface_values->reinit(cell, face_no, subface_no);
         cell->get_dof_indices(local_dof_indices);
 
@@ -190,7 +191,7 @@ namespace MeshWorker
     const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell)
   {
     if (!neighbor_fe_values)
-      neighbor_fe_values = std_cxx14::make_unique<FEValues<dim, spacedim>>(
+      neighbor_fe_values = std::make_unique<FEValues<dim, spacedim>>(
         *mapping, *fe, cell_quadrature, neighbor_cell_update_flags);
 
     neighbor_fe_values->reinit(cell);
@@ -208,9 +209,8 @@ namespace MeshWorker
     const unsigned int                                              face_no)
   {
     if (!neighbor_fe_face_values)
-      neighbor_fe_face_values =
-        std_cxx14::make_unique<FEFaceValues<dim, spacedim>>(
-          *mapping, *fe, face_quadrature, neighbor_face_update_flags);
+      neighbor_fe_face_values = std::make_unique<FEFaceValues<dim, spacedim>>(
+        *mapping, *fe, face_quadrature, neighbor_face_update_flags);
     neighbor_fe_face_values->reinit(cell, face_no);
     cell->get_dof_indices(neighbor_dof_indices);
     current_neighbor_fe_values = neighbor_fe_face_values.get();
@@ -230,7 +230,7 @@ namespace MeshWorker
       {
         if (!neighbor_fe_subface_values)
           neighbor_fe_subface_values =
-            std_cxx14::make_unique<FESubfaceValues<dim, spacedim>>(
+            std::make_unique<FESubfaceValues<dim, spacedim>>(
               *mapping, *fe, face_quadrature, neighbor_face_update_flags);
         neighbor_fe_subface_values->reinit(cell, face_no, subface_no);
         cell->get_dof_indices(neighbor_dof_indices);
index 68dcf8897bf87d2b0b5dd002a85b03a672d13019..88a1a0090ab64cf2db2fca8b03817d4e3be3c682 100644 (file)
@@ -101,8 +101,8 @@ void
 KDTree<dim>::set_points(const std::vector<Point<dim>> &pts)
 {
   Assert(pts.size() > 0, ExcMessage("Expecting a non zero set of points."));
-  adaptor = std_cxx14::make_unique<PointCloudAdaptor>(pts);
-  kdtree  = std_cxx14::make_unique<NanoFlannKDTree>(
+  adaptor = std::make_unique<PointCloudAdaptor>(pts);
+  kdtree  = std::make_unique<NanoFlannKDTree>(
     dim, *adaptor, nanoflann::KDTreeSingleIndexAdaptorParams(max_leaf_size));
   kdtree->buildIndex();
 }
index 502522e9504172b7d35fbb2023c16f063ab425cc..075925f3f42ff16170e3b6099440bf64ba18831a 100644 (file)
@@ -121,8 +121,7 @@ namespace Particles
     , handle(numbers::invalid_unsigned_int)
   {
     triangulation_cache =
-      std_cxx14::make_unique<GridTools::Cache<dim, spacedim>>(triangulation,
-                                                              mapping);
+      std::make_unique<GridTools::Cache<dim, spacedim>>(triangulation, mapping);
   }
 
 
@@ -138,13 +137,13 @@ namespace Particles
     mapping       = &new_mapping;
 
     // Create the memory pool that will store all particle properties
-    property_pool = std_cxx14::make_unique<PropertyPool>(n_properties);
+    property_pool = std::make_unique<PropertyPool>(n_properties);
 
     // Create the grid cache to cache the information about the triangulation
     // that is used to locate the particles into subdomains and cells
     triangulation_cache =
-      std_cxx14::make_unique<GridTools::Cache<dim, spacedim>>(new_triangulation,
-                                                              new_mapping);
+      std::make_unique<GridTools::Cache<dim, spacedim>>(new_triangulation,
+                                                        new_mapping);
   }
 
 
index 473a3ea1f6636c16c6585b6e2c45f301cfbf63a5..30ac72c3a9b95e754a13660b0ded8f6618e26ee9 100644 (file)
@@ -33,7 +33,7 @@ void
 test()
 {
   // Create a pointer to D
-  std::unique_ptr<D> d = std_cxx14::make_unique<D>();
+  std::unique_ptr<D> d = std::make_unique<D>();
 
   // See that we can successfully downcast to B
   std::unique_ptr<B> b = Utilities::dynamic_unique_cast<B>(std::move(d));
@@ -58,7 +58,7 @@ void
 invalid_test()
 {
   // Create a pointer to B
-  std::unique_ptr<B> b = std_cxx14::make_unique<B>();
+  std::unique_ptr<B> b = std::make_unique<B>();
 
   // Check that we can indeed not upcast to D:
   try
index b15ca2b1f63a2ca9036cb7eca1a51f6e0db6153c..5205916e22d4b0ecc469d626b3c4219404e52ad7 100644 (file)
@@ -35,14 +35,14 @@ main()
 {
   initlog();
 
-  constexpr int max_1 = std_cxx14::max(0, 1);
+  constexpr int max_1 = std::max(0, 1);
   deallog << max_1 << std::endl;
-  constexpr int max_2 = std_cxx14::max(3, 2, comp);
+  constexpr int max_2 = std::max(3, 2, comp);
   deallog << max_2 << std::endl;
 
-  constexpr int min_1 = std_cxx14::min(1, 2);
+  constexpr int min_1 = std::min(1, 2);
   deallog << min_1 << std::endl;
-  constexpr int min_2 = std_cxx14::min(1, 2, comp);
+  constexpr int min_2 = std::min(1, 2, comp);
   deallog << min_2 << std::endl;
 
   deallog << "OK" << std::endl;
index 2b16cfdd8cf8340b78a0c8b92ee40b3b2f3cb4af..c80228940d86a7158799fdd562be76ffdc3e500d 100644 (file)
@@ -141,7 +141,7 @@ Problem4<dim>::Problem4(const Function<dim> &force_function,
 
   // after the FECollection has been generated, create a corresponding legendre
   // series expansion object
-  legendre = std_cxx14::make_unique<FESeries::Legendre<dim>>(
+  legendre = std::make_unique<FESeries::Legendre<dim>>(
     SmoothnessEstimator::Legendre::default_fe_series(Laplace<dim>::fe));
 }
 
index 6fbe477f99a18f4fafde62250262bc77d3597b3a..55de1360e26b94c8599386e8219b9ae4a8788ad5 100644 (file)
@@ -155,8 +155,10 @@ namespace Step27
 
     const std::vector<unsigned int> n_coefficients_per_direction(
       fe_collection.size(), max_degree);
-    fourier = std_cxx14::make_unique<FESeries::Fourier<dim>>(
-      n_coefficients_per_direction, fe_collection, fourier_q_collection);
+    fourier =
+      std::make_unique<FESeries::Fourier<dim>>(n_coefficients_per_direction,
+                                               fe_collection,
+                                               fourier_q_collection);
   }
 
 
index e9ad11b28abcac3e4dfbc4d5af5a01b81405bae4..9188983792c260e3a75edb53efe8e2f6ba0deffd 100644 (file)
@@ -46,7 +46,7 @@ public:
   std::unique_ptr<Manifold<dim, spacedim>>
   clone() const override
   {
-    return std_cxx14::make_unique<MyManifold<dim, spacedim>>();
+    return std::make_unique<MyManifold<dim, spacedim>>();
   }
 };
 
index bb1242c9db3df64de8aff12df34d9b3b94d5730e..b410e60f149a0562c73b4fc8fa27496e66e7bdbd 100644 (file)
@@ -38,7 +38,7 @@ public:
   virtual std::unique_ptr<Manifold<dim, spacedim>>
   clone() const override
   {
-    return std_cxx14::make_unique<InnerTorusManifold>();
+    return std::make_unique<InnerTorusManifold>();
   }
 
   virtual Point<chartdim>
index 3c6950990a66f6d6a622a6417929eab4f996f314..9b7b98fb42fc6b3c29f79847fdd0a7dd21530268 100644 (file)
@@ -155,7 +155,7 @@ template <int dim>
 std::unique_ptr<Manifold<dim>>
 Geometry<dim>::clone() const
 {
-  return std_cxx14::make_unique<Geometry<dim>>();
+  return std::make_unique<Geometry<dim>>();
 }
 
 
index c9336bcb84f86a137cd6ba2db0001e8f313a525f..54691eabc78b101b4a8056551405d0ed8e4a8921 100644 (file)
@@ -106,7 +106,7 @@ template <int dim>
 std::unique_ptr<Manifold<dim>>
 Geometry<dim>::clone() const
 {
-  return std_cxx14::make_unique<Geometry<dim>>();
+  return std::make_unique<Geometry<dim>>();
 }
 
 template <int dim>
index bdfd332837a90fa223f395b85986c1b44d573cab..33627cfe17c244afe8f1e3a71242b9d67b158b79 100644 (file)
@@ -186,7 +186,7 @@ public:
   virtual std::unique_ptr<Manifold<dim, dim>>
   clone() const
   {
-    return std_cxx14::make_unique<DeformedManifold<dim>>();
+    return std::make_unique<DeformedManifold<dim>>();
   }
 
   virtual Point<dim>
index 65a093b78747bb484ff89da2737b193f83b32dac..bffa100a31230554f73ad2deb4093ddfadaee650 100644 (file)
@@ -106,7 +106,7 @@ public:
   virtual std::unique_ptr<Manifold<dim>>
   clone() const override
   {
-    return std_cxx14::make_unique<PeriodicHillManifold<dim>>();
+    return std::make_unique<PeriodicHillManifold<dim>>();
   }
 
   virtual Point<dim>
index 1cfbc1f07fbecfce5f40d7319da48afbcf112a6f..73f40b5e335e0e71a3fe05e7faaa2ee62252cf26 100644 (file)
@@ -260,7 +260,7 @@ do_test(const std::vector<const DoFHandler<dim> *> &dof)
       constraints_ptrs[i] = &constraints[i];
     }
   QGauss<1>     quad(n_q_points_1d);
-  constexpr int max_degree = std_cxx14::max(fe_degree_1, fe_degree_2);
+  constexpr int max_degree = std::max(fe_degree_1, fe_degree_2);
   MappingQ<dim> mapping(max_degree);
 
   typename MatrixFree<dim, number>::AdditionalData fine_level_additional_data;
@@ -431,7 +431,7 @@ test()
     parallel::distributed::Triangulation<dim>::construct_multigrid_hierarchy);
   GridGenerator::hyper_cube(tria);
   tria.refine_global(6 - dim);
-  constexpr int      max_degree = std_cxx14::max(fe_degree_1, fe_degree_2);
+  constexpr int      max_degree = std::max(fe_degree_1, fe_degree_2);
   const unsigned int n_runs     = max_degree == 1 ? 6 - dim : 5 - dim;
   for (unsigned int i = 0; i < n_runs; ++i)
     {
@@ -457,8 +457,7 @@ test()
 
       std::vector<const DoFHandler<dim, dim> *> dh_ptrs{&dof_1, &dof_2};
 
-      constexpr int n_q_points_1d =
-        std_cxx14::max(fe_degree_1, fe_degree_2) + 1;
+      constexpr int n_q_points_1d = std::max(fe_degree_1, fe_degree_2) + 1;
       do_test<dim, fe_degree_1, fe_degree_2, n_q_points_1d, double>(dh_ptrs);
     }
 }
index 8698ae97079f851735a99876f676004a6aadca57..5d2cd950ffa241d27852536c86db7f2ca9a7003a 100644 (file)
@@ -188,8 +188,10 @@ namespace Step27
 
     const std::vector<unsigned int> n_coefficients_per_direction(
       fe_collection.size(), max_degree);
-    fourier = std_cxx14::make_unique<FESeries::Fourier<dim>>(
-      n_coefficients_per_direction, fe_collection, fourier_q_collection);
+    fourier =
+      std::make_unique<FESeries::Fourier<dim>>(n_coefficients_per_direction,
+                                               fe_collection,
+                                               fourier_q_collection);
   }
 
 
index 555936712a24d61ebaf6eea3cef214599b00853a..dffb6ba20b91959a2d7f758a7a36d93ea82d25a7 100644 (file)
@@ -188,8 +188,10 @@ namespace Step27
 
     const std::vector<unsigned int> n_coefficients_per_direction(
       fe_collection.size(), max_degree);
-    fourier = std_cxx14::make_unique<FESeries::Fourier<dim>>(
-      n_coefficients_per_direction, fe_collection, fourier_q_collection);
+    fourier =
+      std::make_unique<FESeries::Fourier<dim>>(n_coefficients_per_direction,
+                                               fe_collection,
+                                               fourier_q_collection);
   }
 
 
index 33ddc10da37d72c976436cfb26889c904e6ca8d3..8184842e70b8d085fa38f79b700aa485a16980a8 100644 (file)
@@ -87,8 +87,8 @@ check()
  tr.execute_coarsening_and_refinement();
   */
 
-  auto fe_scalar = std_cxx14::make_unique<dealii::FE_Q<dim>>(1);
-  auto fe        = std_cxx14::make_unique<dealii::FESystem<dim>>(*fe_scalar, 1);
+  auto fe_scalar = std::make_unique<dealii::FE_Q<dim>>(1);
+  auto fe        = std::make_unique<dealii::FESystem<dim>>(*fe_scalar, 1);
 
   dealii::DoFHandler<dim> dofhandler(tria);
   dofhandler.distribute_dofs(*fe);
index 2059bcecd5176b24d0213d9c3b6937fbf6a27e51..9cc221904f2c51a5b8c7123d6bd52fef02d65226 100644 (file)
@@ -87,8 +87,8 @@ check()
  tr.execute_coarsening_and_refinement();
   */
 
-  auto fe_scalar = std_cxx14::make_unique<dealii::FE_Q<dim>>(1);
-  auto fe = std_cxx14::make_unique<dealii::FESystem<dim>>(*fe_scalar, dim);
+  auto fe_scalar = std::make_unique<dealii::FE_Q<dim>>(1);
+  auto fe        = std::make_unique<dealii::FESystem<dim>>(*fe_scalar, dim);
 
   dealii::DoFHandler<dim> dofhandler(tria);
   dofhandler.distribute_dofs(*fe);
index cd92ea47b261aff30d72fea704e9de73ac9ed523..0251faa8c8d6bedafca52390063b9a81a523a4e1 100644 (file)
@@ -29,9 +29,9 @@ main()
   // create a pattern and let it
   // output its description
   std::vector<std::unique_ptr<Patterns::PatternBase>> ps;
-  ps.push_back(std_cxx14::make_unique<Patterns::Integer>());
-  ps.push_back(std_cxx14::make_unique<Patterns::Double>());
-  ps.push_back(std_cxx14::make_unique<Patterns::Anything>());
+  ps.push_back(std::make_unique<Patterns::Integer>());
+  ps.push_back(std::make_unique<Patterns::Double>());
+  ps.push_back(std::make_unique<Patterns::Anything>());
 
   Patterns::Tuple   pattern(ps, ";");
   const std::string desc = pattern.description();
index f30d81d1bb7d3227fa5dcba08ce02e78ea453ae2..b2ecf2fda0277b090362230280836723de54c3ca 100644 (file)
@@ -28,9 +28,9 @@ main()
 
   // create a pattern and match a string
   std::vector<std::unique_ptr<Patterns::PatternBase>> ps;
-  ps.push_back(std_cxx14::make_unique<Patterns::Integer>());
-  ps.push_back(std_cxx14::make_unique<Patterns::Double>());
-  ps.push_back(std_cxx14::make_unique<Patterns::Anything>());
+  ps.push_back(std::make_unique<Patterns::Integer>());
+  ps.push_back(std::make_unique<Patterns::Double>());
+  ps.push_back(std::make_unique<Patterns::Anything>());
 
   Patterns::Tuple   pattern(ps, ";");
   const std::string desc = pattern.description();
index 3d1308cad6cf13227cfd83ac169431dd728139fe..7d1a542f53f23b37bb54ae132dbe6ba1f04c17e5 100644 (file)
@@ -75,7 +75,7 @@ public:
       {
         vec_len     = 1;
         max_vec_len = vec_len;
-        colnums     = std_cxx14::make_unique<size_type[]>(max_vec_len);
+        colnums     = std::make_unique<size_type[]>(max_vec_len);
       }
 
     max_row_length =
@@ -94,14 +94,14 @@ public:
     if (rows > max_dim)
       {
         max_dim  = rows;
-        rowstart = std_cxx14::make_unique<std::size_t[]>(max_dim + 1);
+        rowstart = std::make_unique<std::size_t[]>(max_dim + 1);
       }
 
     // allocate memory for the column numbers if necessary
     if (vec_len > max_vec_len)
       {
         max_vec_len = vec_len;
-        colnums     = std_cxx14::make_unique<size_type[]>(max_vec_len);
+        colnums     = std::make_unique<size_type[]>(max_vec_len);
       }
 
     // set the rowstart array

In the beginning the Universe was created. This has made a lot of people very angry and has been widely regarded as a bad move.

Douglas Adams


Typeset in Trocchi and Trocchi Bold Sans Serif.