Remove ZeroFunction and ConstantFunction without prefix

diff --git a/examples/step-12/step-12.cc b/examples/step-12/step-12.cc
index d3789e677df2fd29718e972aef212206396b2f57..a737c32530c3ba738da4cd64e1a7732713ed86dd 100644 (file)
--- a/examples/step-12/step-12.cc
+++ b/examples/step-12/step-12.cc
@@ -557,7 +557,7 @@ namespace Step12
       Vector<float> values(triangulation.n_active_cells());
       VectorTools::integrate_difference(dof_handler,
                                         solution,
-                                        ZeroFunction<dim>(),
+                                        Functions::ZeroFunction<dim>(),
                                         values,
                                         QGauss<dim>(fe.degree + 1),
                                         VectorTools::Linfty_norm);

diff --git a/examples/step-70/step-70.cc b/examples/step-70/step-70.cc
index a506e73536d883c0c132f4a24923d50d1cac5211..dbadf946e4f19ead3ded3e2a83f3a1844937c7b2 100644 (file)
--- a/examples/step-70/step-70.cc
+++ b/examples/step-70/step-70.cc
@@ -1292,7 +1292,7 @@ namespace Step70
       VectorTools::interpolate_boundary_values(
         fluid_dh,
         0,
-        ZeroFunction<spacedim>(spacedim + 1),
+        Functions::ZeroFunction<spacedim>(spacedim + 1),
         constraints,
         fluid_fe->component_mask(velocities));
       constraints.close();

diff --git a/include/deal.II/base/function.h b/include/deal.II/base/function.h
index 23f38930d6edddc59650616d0fa4e9afad3cea35..3fed52cf6bd187e1eb19c97e54ea419c3ca96c13 100644 (file)
--- a/include/deal.II/base/function.h
+++ b/include/deal.II/base/function.h
@@ -518,25 +518,6 @@ namespace Functions
 
 } // namespace Functions
 
-/**
- * Provide a function which always returns the constant values handed to the
- * constructor.
- *
- * @deprecated use Functions::ConstantFunction instead.
- */
-template <int dim, typename RangeNumberType = double>
-using ConstantFunction DEAL_II_DEPRECATED =
-  Functions::ConstantFunction<dim, RangeNumberType>;
-
-/**
- * Provide a function which always returns zero.
- *
- * @deprecated use Functions::ZeroFunction instead.
- */
-template <int dim, typename RangeNumberType = double>
-using ZeroFunction DEAL_II_DEPRECATED =
-  Functions::ZeroFunction<dim, RangeNumberType>;
-
 
 
 /**
@@ -553,7 +534,8 @@ using ZeroFunction DEAL_II_DEPRECATED =
  * @ingroup functions
  */
 template <int dim, typename RangeNumberType = double>
-class ComponentSelectFunction : public ConstantFunction<dim, RangeNumberType>
+class ComponentSelectFunction
+  : public Functions::ConstantFunction<dim, RangeNumberType>
 {
 public:
   /**

diff --git a/include/deal.II/base/function.templates.h b/include/deal.II/base/function.templates.h
index 8ac10ae560c6441f273a6dc89e362d16efd1924b..24933e819c716f51e59e5e2f92c4202d6dfbe108 100644 (file)
--- a/include/deal.II/base/function.templates.h
+++ b/include/deal.II/base/function.templates.h
@@ -539,7 +539,7 @@ ComponentSelectFunction<dim, RangeNumberType>::ComponentSelectFunction(
   const unsigned int    selected,
   const RangeNumberType value,
   const unsigned int    n_components)
-  : ConstantFunction<dim, RangeNumberType>(value, n_components)
+  : Functions::ConstantFunction<dim, RangeNumberType>(value, n_components)
   , selected_components(std::make_pair(selected, selected + 1))
 {}
 
@@ -549,7 +549,7 @@ template <int dim, typename RangeNumberType>
 ComponentSelectFunction<dim, RangeNumberType>::ComponentSelectFunction(
   const unsigned int selected,
   const unsigned int n_components)
-  : ConstantFunction<dim, RangeNumberType>(1., n_components)
+  : Functions::ConstantFunction<dim, RangeNumberType>(1., n_components)
   , selected_components(std::make_pair(selected, selected + 1))
 {
   AssertIndexRange(selected, n_components);
@@ -561,7 +561,7 @@ template <int dim, typename RangeNumberType>
 ComponentSelectFunction<dim, RangeNumberType>::ComponentSelectFunction(
   const std::pair<unsigned int, unsigned int> &selected,
   const unsigned int                           n_components)
-  : ConstantFunction<dim, RangeNumberType>(1., n_components)
+  : Functions::ConstantFunction<dim, RangeNumberType>(1., n_components)
   , selected_components(selected)
 {
   Assert(selected_components.first < selected_components.second,
@@ -577,7 +577,7 @@ ComponentSelectFunction<dim, RangeNumberType>::ComponentSelectFunction(
 template <int dim, typename RangeNumberType>
 void
 ComponentSelectFunction<dim, RangeNumberType>::substitute_function_value_with(
-  const ConstantFunction<dim, RangeNumberType> &f)
+  const Functions::ConstantFunction<dim, RangeNumberType> &f)
 {
   Point<dim> p;
   for (unsigned int i = 0; i < this->function_value_vector.size(); ++i)
@@ -626,8 +626,9 @@ ComponentSelectFunction<dim, RangeNumberType>::memory_consumption() const
   // No new complex data structure is introduced here, just evaluate how much
   // more memory is used *inside* the class via sizeof() and add that value to
   // parent class's memory_consumption()
-  return (sizeof(*this) - sizeof(ConstantFunction<dim, RangeNumberType>) +
-          ConstantFunction<dim, RangeNumberType>::memory_consumption());
+  return (
+    sizeof(*this) - sizeof(Functions::ConstantFunction<dim, RangeNumberType>) +
+    Functions::ConstantFunction<dim, RangeNumberType>::memory_consumption());
 }
 
 //---------------------------------------------------------------------------

diff --git a/include/deal.II/base/parsed_convergence_table.h b/include/deal.II/base/parsed_convergence_table.h
index a00dff2b143667725ef174351022ec08134a7f33..98513037833a4d687b998a81fb70737de8de3713 100644 (file)
--- a/include/deal.II/base/parsed_convergence_table.h
+++ b/include/deal.II/base/parsed_convergence_table.h
@@ -496,7 +496,7 @@ ParsedConvergenceTable::difference(
   solution -= solution2;
   error_from_exact(dh,
                    solution,
-                   ConstantFunction<DoFHandlerType::space_dimension>(
+                   Functions::ConstantFunction<DoFHandlerType::space_dimension>(
                      0, component_names.size()),
                    weight);
 }
@@ -520,7 +520,7 @@ ParsedConvergenceTable::difference(
   error_from_exact(mapping,
                    dh,
                    solution,
-                   ConstantFunction<DoFHandlerType::space_dimension>(
+                   Functions::ConstantFunction<DoFHandlerType::space_dimension>(
                      0, component_names.size()),
                    weight);
 }

diff --git a/include/deal.II/numerics/vector_tools_constraints.templates.h b/include/deal.II/numerics/vector_tools_constraints.templates.h
index a3057fdfa96137b06b26fd9c04bef21ec6f8c5ed..8fcc6c45f9b3dfef22a7f2d044f706a5fe28a235 100644 (file)
--- a/include/deal.II/numerics/vector_tools_constraints.templates.h
+++ b/include/deal.II/numerics/vector_tools_constraints.templates.h
@@ -1267,7 +1267,7 @@ namespace VectorTools
     AffineConstraints<double> &          constraints,
     const Mapping<dim, spacedim> &       mapping)
   {
-    ZeroFunction<dim>                                        zero_function(dim);
+    Functions::ZeroFunction<dim>                             zero_function(dim);
     std::map<types::boundary_id, const Function<spacedim> *> function_map;
     for (const types::boundary_id boundary_id : boundary_ids)
       function_map[boundary_id] = &zero_function;
@@ -1288,7 +1288,7 @@ namespace VectorTools
     AffineConstraints<double> &          constraints,
     const Mapping<dim, spacedim> &       mapping)
   {
-    ZeroFunction<dim>                                        zero_function(dim);
+    Functions::ZeroFunction<dim>                             zero_function(dim);
     std::map<types::boundary_id, const Function<spacedim> *> function_map;
     for (const types::boundary_id boundary_id : boundary_ids)
       function_map[boundary_id] = &zero_function;

diff --git a/tests/ad_common_tests/step-44-helper_res_lin_01.h b/tests/ad_common_tests/step-44-helper_res_lin_01.h
index 32472e508ee4351feae140b2a27b1fa6eb118bf0..1ec0a5903b5628d7ad0f6c9430e07d3e6430b417 100644 (file)
--- a/tests/ad_common_tests/step-44-helper_res_lin_01.h
+++ b/tests/ad_common_tests/step-44-helper_res_lin_01.h
@@ -1342,14 +1342,14 @@ namespace Step44
         VectorTools::interpolate_boundary_values(
           dof_handler_ref,
           boundary_id,
-          ZeroFunction<dim>(n_components),
+          Functions::ZeroFunction<dim>(n_components),
           constraints,
           fe.component_mask(x_displacement));
       else
         VectorTools::interpolate_boundary_values(
           dof_handler_ref,
           boundary_id,
-          ZeroFunction<dim>(n_components),
+          Functions::ZeroFunction<dim>(n_components),
           constraints,
           fe.component_mask(x_displacement));
     }
@@ -1359,14 +1359,14 @@ namespace Step44
         VectorTools::interpolate_boundary_values(
           dof_handler_ref,
           boundary_id,
-          ZeroFunction<dim>(n_components),
+          Functions::ZeroFunction<dim>(n_components),
           constraints,
           fe.component_mask(y_displacement));
       else
         VectorTools::interpolate_boundary_values(
           dof_handler_ref,
           boundary_id,
-          ZeroFunction<dim>(n_components),
+          Functions::ZeroFunction<dim>(n_components),
           constraints,
           fe.component_mask(y_displacement));
     }
@@ -1379,7 +1379,7 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement) |
                fe.component_mask(z_displacement)));
@@ -1387,7 +1387,7 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement) |
                fe.component_mask(z_displacement)));
@@ -1398,14 +1398,14 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               fe.component_mask(z_displacement));
           else
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               fe.component_mask(z_displacement));
         }
@@ -1415,7 +1415,7 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement) |
                fe.component_mask(z_displacement)));
@@ -1423,7 +1423,7 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement) |
                fe.component_mask(z_displacement)));
@@ -1437,14 +1437,14 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement)));
           else
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement)));
         }
@@ -1454,14 +1454,14 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement)));
           else
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement)));
         }

diff --git a/tests/ad_common_tests/step-44-helper_scalar_01.h b/tests/ad_common_tests/step-44-helper_scalar_01.h
index e8f1ac25f3da3aa13c522d53d9eacf5e9639c2e1..e643e8e18fe404c344d978636b9f65fe1d92af34 100644 (file)
--- a/tests/ad_common_tests/step-44-helper_scalar_01.h
+++ b/tests/ad_common_tests/step-44-helper_scalar_01.h
@@ -1874,14 +1874,14 @@ namespace Step44
         VectorTools::interpolate_boundary_values(
           dof_handler_ref,
           boundary_id,
-          ZeroFunction<dim>(n_components),
+          Functions::ZeroFunction<dim>(n_components),
           constraints,
           fe.component_mask(x_displacement));
       else
         VectorTools::interpolate_boundary_values(
           dof_handler_ref,
           boundary_id,
-          ZeroFunction<dim>(n_components),
+          Functions::ZeroFunction<dim>(n_components),
           constraints,
           fe.component_mask(x_displacement));
     }
@@ -1891,14 +1891,14 @@ namespace Step44
         VectorTools::interpolate_boundary_values(
           dof_handler_ref,
           boundary_id,
-          ZeroFunction<dim>(n_components),
+          Functions::ZeroFunction<dim>(n_components),
           constraints,
           fe.component_mask(y_displacement));
       else
         VectorTools::interpolate_boundary_values(
           dof_handler_ref,
           boundary_id,
-          ZeroFunction<dim>(n_components),
+          Functions::ZeroFunction<dim>(n_components),
           constraints,
           fe.component_mask(y_displacement));
     }
@@ -1911,7 +1911,7 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement) |
                fe.component_mask(z_displacement)));
@@ -1919,7 +1919,7 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement) |
                fe.component_mask(z_displacement)));
@@ -1930,14 +1930,14 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               fe.component_mask(z_displacement));
           else
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               fe.component_mask(z_displacement));
         }
@@ -1947,7 +1947,7 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement) |
                fe.component_mask(z_displacement)));
@@ -1955,7 +1955,7 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement) |
                fe.component_mask(z_displacement)));
@@ -1969,14 +1969,14 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement)));
           else
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement)));
         }
@@ -1986,14 +1986,14 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement)));
           else
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement)));
         }

diff --git a/tests/ad_common_tests/step-44-helper_var_form_01.h b/tests/ad_common_tests/step-44-helper_var_form_01.h
index 235d350314ba9ac482ab4815565b3d45030231be..f3e25ab0cdcb3a388377090c59fd0c11ea8321ed 100644 (file)
--- a/tests/ad_common_tests/step-44-helper_var_form_01.h
+++ b/tests/ad_common_tests/step-44-helper_var_form_01.h
@@ -1268,14 +1268,14 @@ namespace Step44
         VectorTools::interpolate_boundary_values(
           dof_handler_ref,
           boundary_id,
-          ZeroFunction<dim>(n_components),
+          Functions::ZeroFunction<dim>(n_components),
           constraints,
           fe.component_mask(x_displacement));
       else
         VectorTools::interpolate_boundary_values(
           dof_handler_ref,
           boundary_id,
-          ZeroFunction<dim>(n_components),
+          Functions::ZeroFunction<dim>(n_components),
           constraints,
           fe.component_mask(x_displacement));
     }
@@ -1285,14 +1285,14 @@ namespace Step44
         VectorTools::interpolate_boundary_values(
           dof_handler_ref,
           boundary_id,
-          ZeroFunction<dim>(n_components),
+          Functions::ZeroFunction<dim>(n_components),
           constraints,
           fe.component_mask(y_displacement));
       else
         VectorTools::interpolate_boundary_values(
           dof_handler_ref,
           boundary_id,
-          ZeroFunction<dim>(n_components),
+          Functions::ZeroFunction<dim>(n_components),
           constraints,
           fe.component_mask(y_displacement));
     }
@@ -1305,7 +1305,7 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement) |
                fe.component_mask(z_displacement)));
@@ -1313,7 +1313,7 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement) |
                fe.component_mask(z_displacement)));
@@ -1324,14 +1324,14 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               fe.component_mask(z_displacement));
           else
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               fe.component_mask(z_displacement));
         }
@@ -1341,7 +1341,7 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement) |
                fe.component_mask(z_displacement)));
@@ -1349,7 +1349,7 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement) |
                fe.component_mask(z_displacement)));
@@ -1363,14 +1363,14 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement)));
           else
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement)));
         }
@@ -1380,14 +1380,14 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement)));
           else
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement)));
         }

diff --git a/tests/ad_common_tests/step-44-helper_vector_01.h b/tests/ad_common_tests/step-44-helper_vector_01.h
index 72cd94e8991efe865cead382d7bde6af788c3b1f..4907f3caf9008ba8d2fc5611da607efe4e4fe9e8 100644 (file)
--- a/tests/ad_common_tests/step-44-helper_vector_01.h
+++ b/tests/ad_common_tests/step-44-helper_vector_01.h
@@ -1361,14 +1361,14 @@ namespace Step44
         VectorTools::interpolate_boundary_values(
           dof_handler_ref,
           boundary_id,
-          ZeroFunction<dim>(n_components),
+          Functions::ZeroFunction<dim>(n_components),
           constraints,
           fe.component_mask(x_displacement));
       else
         VectorTools::interpolate_boundary_values(
           dof_handler_ref,
           boundary_id,
-          ZeroFunction<dim>(n_components),
+          Functions::ZeroFunction<dim>(n_components),
           constraints,
           fe.component_mask(x_displacement));
     }
@@ -1378,14 +1378,14 @@ namespace Step44
         VectorTools::interpolate_boundary_values(
           dof_handler_ref,
           boundary_id,
-          ZeroFunction<dim>(n_components),
+          Functions::ZeroFunction<dim>(n_components),
           constraints,
           fe.component_mask(y_displacement));
       else
         VectorTools::interpolate_boundary_values(
           dof_handler_ref,
           boundary_id,
-          ZeroFunction<dim>(n_components),
+          Functions::ZeroFunction<dim>(n_components),
           constraints,
           fe.component_mask(y_displacement));
     }
@@ -1398,7 +1398,7 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement) |
                fe.component_mask(z_displacement)));
@@ -1406,7 +1406,7 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement) |
                fe.component_mask(z_displacement)));
@@ -1417,14 +1417,14 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               fe.component_mask(z_displacement));
           else
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               fe.component_mask(z_displacement));
         }
@@ -1434,7 +1434,7 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement) |
                fe.component_mask(z_displacement)));
@@ -1442,7 +1442,7 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement) |
                fe.component_mask(z_displacement)));
@@ -1456,14 +1456,14 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement)));
           else
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement)));
         }
@@ -1473,14 +1473,14 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement)));
           else
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement)));
         }

diff --git a/tests/adolc/step-44.cc b/tests/adolc/step-44.cc
index cd70429a424573be2fbc6b4ed19a911eaec8f829..5f2f2e9cc3f24d14baff483de4b963078c509ad5 100644 (file)
--- a/tests/adolc/step-44.cc
+++ b/tests/adolc/step-44.cc
@@ -1683,14 +1683,14 @@ namespace Step44
         VectorTools::interpolate_boundary_values(
           dof_handler_ref,
           boundary_id,
-          ZeroFunction<dim>(n_components),
+          Functions::ZeroFunction<dim>(n_components),
           constraints,
           fe.component_mask(x_displacement));
       else
         VectorTools::interpolate_boundary_values(
           dof_handler_ref,
           boundary_id,
-          ZeroFunction<dim>(n_components),
+          Functions::ZeroFunction<dim>(n_components),
           constraints,
           fe.component_mask(x_displacement));
     }
@@ -1700,14 +1700,14 @@ namespace Step44
         VectorTools::interpolate_boundary_values(
           dof_handler_ref,
           boundary_id,
-          ZeroFunction<dim>(n_components),
+          Functions::ZeroFunction<dim>(n_components),
           constraints,
           fe.component_mask(y_displacement));
       else
         VectorTools::interpolate_boundary_values(
           dof_handler_ref,
           boundary_id,
-          ZeroFunction<dim>(n_components),
+          Functions::ZeroFunction<dim>(n_components),
           constraints,
           fe.component_mask(y_displacement));
     }
@@ -1720,7 +1720,7 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement) |
                fe.component_mask(z_displacement)));
@@ -1728,7 +1728,7 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement) |
                fe.component_mask(z_displacement)));
@@ -1739,14 +1739,14 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               fe.component_mask(z_displacement));
           else
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               fe.component_mask(z_displacement));
         }
@@ -1756,7 +1756,7 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement) |
                fe.component_mask(z_displacement)));
@@ -1764,7 +1764,7 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement) |
                fe.component_mask(z_displacement)));
@@ -1778,14 +1778,14 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement)));
           else
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement)));
         }
@@ -1795,14 +1795,14 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement)));
           else
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement)));
         }

diff --git a/tests/data_out/data_out_postprocessor_vector_03.cc b/tests/data_out/data_out_postprocessor_vector_03.cc
index b7478e78827bee85287dc47fc2f9ac9cf343dedf..865922380f439318825ff8967dfb42b976810549 100644 (file)
--- a/tests/data_out/data_out_postprocessor_vector_03.cc
+++ b/tests/data_out/data_out_postprocessor_vector_03.cc
@@ -140,7 +140,7 @@ Step6<dim>::setup_system()
 
   VectorTools::interpolate_boundary_values(dof_handler,
                                            0,
-                                           ZeroFunction<dim>(),
+                                           Functions::ZeroFunction<dim>(),
                                            constraints);
 
 

diff --git a/tests/fe/fe_enriched_color_04.cc b/tests/fe/fe_enriched_color_04.cc
index f6d37ddb3be1ef151be4936f4ae24104bb13e33a..9382e49eefb2b79039ee5859bf4c6114d8c74fc3 100644 (file)
--- a/tests/fe/fe_enriched_color_04.cc
+++ b/tests/fe/fe_enriched_color_04.cc
@@ -130,7 +130,7 @@ main(int argc, char **argv)
   for (unsigned int i = 0; i < vec_predicates.size(); ++i)
     {
       // constant function is chosen as enrichment function
-      ConstantFunction<dim> func(i);
+      Functions::ConstantFunction<dim> func(i);
       vec_enrichments.push_back(std::make_shared<ConstantFunction<dim>>(func));
     }
 

diff --git a/tests/fe/fe_enriched_color_05.cc b/tests/fe/fe_enriched_color_05.cc
index eae155c1187b5c2265b35cb894c360402ec1c704..8146c4155855831676936b5be4632e51dbfdba72 100644 (file)
--- a/tests/fe/fe_enriched_color_05.cc
+++ b/tests/fe/fe_enriched_color_05.cc
@@ -202,7 +202,7 @@ main(int argc, char **argv)
   for (unsigned int i = 0; i < vec_predicates.size(); ++i)
     {
       // constant function.
-      ConstantFunction<dim> func(10 + i); // constant function
+      Functions::ConstantFunction<dim> func(10 + i); // constant function
       vec_enrichments.push_back(std::make_shared<ConstantFunction<dim>>(func));
     }
 

diff --git a/tests/fe/fe_enriched_color_06.cc b/tests/fe/fe_enriched_color_06.cc
index f286446711f7d247cfea65b9fb0885f31490cf19..ab58a9b6c4723731f68558b9b14bec3ef23deac4 100644 (file)
--- a/tests/fe/fe_enriched_color_06.cc
+++ b/tests/fe/fe_enriched_color_06.cc
@@ -114,7 +114,7 @@ main(int argc, char **argv)
   for (unsigned int i = 0; i < vec_predicates.size(); ++i)
     {
       // constant function.
-      ConstantFunction<dim> func(10 + i); // constant function
+      Functions::ConstantFunction<dim> func(10 + i); // constant function
       vec_enrichments.push_back(std::make_shared<ConstantFunction<dim>>(func));
     }
 

diff --git a/tests/fe/fe_enriched_color_07.cc b/tests/fe/fe_enriched_color_07.cc
index 95ed99be2bf6ddd7a4de970112e077c05e1b018e..700c17d82603b8983bba0818c670ba377e7ba8ae 100644 (file)
--- a/tests/fe/fe_enriched_color_07.cc
+++ b/tests/fe/fe_enriched_color_07.cc
@@ -1304,7 +1304,7 @@ LaplaceProblem<dim>::make_enrichment_functions()
       else
         {
           pcout << "Dummy function added at " << i << std::endl;
-          ConstantFunction<dim> func(0);
+          Functions::ConstantFunction<dim> func(0);
           vec_enrichments.push_back(
             std::make_shared<ConstantFunction<dim>>(func));
         }
@@ -1778,7 +1778,7 @@ LaplaceProblem<dim>::run()
           Vector<float> difference_per_cell(triangulation.n_active_cells());
           VectorTools::integrate_difference(dof_handler,
                                             localized_solution,
-                                            ZeroFunction<dim>(),
+                                            Functions::ZeroFunction<dim>(),
                                             difference_per_cell,
                                             q_collection,
                                             VectorTools::H1_norm);

diff --git a/tests/fe/fe_enriched_color_08.cc b/tests/fe/fe_enriched_color_08.cc
index 99e90d1d66f5656811cd411f040141262dcf2667..e28792df6e276280bd20916d9f4fa3cab84e12b1 100644 (file)
--- a/tests/fe/fe_enriched_color_08.cc
+++ b/tests/fe/fe_enriched_color_08.cc
@@ -242,7 +242,7 @@ main(int argc, char **argv)
   for (unsigned int i = 0; i < vec_predicates.size(); ++i)
     {
       // constant function.
-      ConstantFunction<dim> func(10 + i); // constant function
+      Functions::ConstantFunction<dim> func(10 + i); // constant function
       vec_enrichments.push_back(std::make_shared<ConstantFunction<dim>>(func));
     }
 

diff --git a/tests/fe/fe_faceq_interpolate.cc b/tests/fe/fe_faceq_interpolate.cc
index 8ccbaa22f395851c1630d1829192999824c34ef6..9960d897067d4b1fb4d6f54a9dd11dfde5c2eeac 100644 (file)
--- a/tests/fe/fe_faceq_interpolate.cc
+++ b/tests/fe/fe_faceq_interpolate.cc
@@ -42,7 +42,9 @@ test()
   dof_handler.distribute_dofs(fe);
   Vector<double> solution(dof_handler.n_dofs());
 
-  VectorTools::interpolate(dof_handler, ZeroFunction<dim>(), solution);
+  VectorTools::interpolate(dof_handler,
+                           Functions::ZeroFunction<dim>(),
+                           solution);
   deallog << "Success, dim = " << dim << std::endl;
 }
 

diff --git a/tests/fe/fe_nedelec_singularity_01.cc b/tests/fe/fe_nedelec_singularity_01.cc
index 244fd822f9cefd9e07f64840cf07ee288e80e9af..61bc4cf1afae1e8201a5d21f953dcd6b19fd85a1 100644 (file)
--- a/tests/fe/fe_nedelec_singularity_01.cc
+++ b/tests/fe/fe_nedelec_singularity_01.cc
@@ -391,7 +391,7 @@ namespace nedelec_singularity
     VectorTools::project_boundary_values_curl_conforming_l2(
       dof_handler,
       first_vector_component,
-      ZeroFunction<dim, std::complex<double>>(dim),
+      Functions::ZeroFunction<dim, std::complex<double>>(dim),
       0,
       constraints);
 

diff --git a/tests/fe/fe_nedelec_singularity_02.cc b/tests/fe/fe_nedelec_singularity_02.cc
index ac12fad6e3bc9d6387886b9dd1ac04e4b1e43912..75407045020fe6a6685c8a9af79cf8d3662a4c2f 100644 (file)
--- a/tests/fe/fe_nedelec_singularity_02.cc
+++ b/tests/fe/fe_nedelec_singularity_02.cc
@@ -381,7 +381,7 @@ namespace nedelec_singularity
     VectorTools::project_boundary_values_curl_conforming_l2(
       dof_handler,
       first_vector_component,
-      ZeroFunction<dim>(dim),
+      Functions::ZeroFunction<dim>(dim),
       0,
       constraints);
 

diff --git a/tests/fe/fe_traceq_interpolate.cc b/tests/fe/fe_traceq_interpolate.cc
index d0c9c28a17f327d530cdc66307e36c32898aa5e8..3802e48dc61baabf52c5fae9e161a86c3d44f4f1 100644 (file)
--- a/tests/fe/fe_traceq_interpolate.cc
+++ b/tests/fe/fe_traceq_interpolate.cc
@@ -42,7 +42,9 @@ test()
   dof_handler.distribute_dofs(fe);
   Vector<double> solution(dof_handler.n_dofs());
 
-  VectorTools::interpolate(dof_handler, ZeroFunction<dim>(), solution);
+  VectorTools::interpolate(dof_handler,
+                           Functions::ZeroFunction<dim>(),
+                           solution);
   deallog << "Success, dim = " << dim << std::endl;
 }
 

diff --git a/tests/matrix_free/loop_boundary_02.cc b/tests/matrix_free/loop_boundary_02.cc
index 08a6921e98f64fc17a0c206c64768155c8b66f24..1736158ed5f0b1153563a7a3831c73c94795e4b5 100644 (file)
--- a/tests/matrix_free/loop_boundary_02.cc
+++ b/tests/matrix_free/loop_boundary_02.cc
@@ -50,7 +50,7 @@ do_test(const unsigned int n_refine)
   AffineConstraints<double> constraints;
   VectorTools::interpolate_boundary_values(dof_handler,
                                            0,
-                                           ZeroFunction<dim>(),
+                                           Functions::ZeroFunction<dim>(),
                                            constraints);
   constraints.close();
 

diff --git a/tests/matrix_free/matrix_vector_24.cc b/tests/matrix_free/matrix_vector_24.cc
index 1580fba470cdaab1e3ca62be789ca7838f9ff443..9791a6582303de2bd5ebc387ee33db6b0f9f2d74 100644 (file)
--- a/tests/matrix_free/matrix_vector_24.cc
+++ b/tests/matrix_free/matrix_vector_24.cc
@@ -89,7 +89,7 @@ test()
   AffineConstraints<double> constraints;
   VectorTools::interpolate_boundary_values(dof,
                                            0,
-                                           ZeroFunction<dim>(),
+                                           Functions::ZeroFunction<dim>(),
                                            constraints);
   constraints.close();
 

diff --git a/tests/matrix_free/multigrid_dg_sip_01.cc b/tests/matrix_free/multigrid_dg_sip_01.cc
index a9bf1af70da04da97cc4809f2d855d120c191779..46f019922637f4ef96dd1103733344537627e984 100644 (file)
--- a/tests/matrix_free/multigrid_dg_sip_01.cc
+++ b/tests/matrix_free/multigrid_dg_sip_01.cc
@@ -594,7 +594,7 @@ do_test(const DoFHandler<dim> &dof, const bool also_test_parallel = false)
   mg_smoother.initialize(mg_matrices, smoother_data);
 
   MGConstrainedDoFs                                   mg_constrained_dofs;
-  ZeroFunction<dim>                                   zero_function;
+  Functions::ZeroFunction<dim>                        zero_function;
   std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
   dirichlet_boundary[0] = &zero_function;
   mg_constrained_dofs.initialize(dof, dirichlet_boundary);

diff --git a/tests/matrix_free/multigrid_dg_sip_02.cc b/tests/matrix_free/multigrid_dg_sip_02.cc
index be085448be16d5b1878215b877110990d4cfae49..93bb327e3c4f1b7add25d8fafd617a5815d218fd 100644 (file)
--- a/tests/matrix_free/multigrid_dg_sip_02.cc
+++ b/tests/matrix_free/multigrid_dg_sip_02.cc
@@ -501,7 +501,7 @@ do_test(const DoFHandler<dim> &dof, const bool also_test_parallel = false)
   mg_smoother.initialize(mg_matrices, smoother_data);
 
   MGConstrainedDoFs                                   mg_constrained_dofs;
-  ZeroFunction<dim>                                   zero_function;
+  Functions::ZeroFunction<dim>                        zero_function;
   std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
   dirichlet_boundary[0] = &zero_function;
   mg_constrained_dofs.initialize(dof, dirichlet_boundary);

diff --git a/tests/matrix_free/parallel_multigrid_adaptive_06.cc b/tests/matrix_free/parallel_multigrid_adaptive_06.cc
index 7a4c44875dd3cf33e60827797f924198035a4997..c7035df983cb9e9b085e3527ccb8b7755cb195e9 100644 (file)
--- a/tests/matrix_free/parallel_multigrid_adaptive_06.cc
+++ b/tests/matrix_free/parallel_multigrid_adaptive_06.cc
@@ -224,7 +224,7 @@ do_test(const DoFHandler<dim> &dof, const unsigned int nb)
   DoFTools::extract_locally_relevant_dofs(dof, locally_relevant_dofs);
 
   // Dirichlet BC
-  ZeroFunction<dim>                                   zero_function;
+  Functions::ZeroFunction<dim>                        zero_function;
   std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
   dirichlet_boundary[0] = &zero_function;
 

diff --git a/tests/matrix_free/parallel_multigrid_adaptive_06ref.cc b/tests/matrix_free/parallel_multigrid_adaptive_06ref.cc
index 9b70723a723b02123999bca4c7601a1d89a38109..27c37551199c80be71561e9e14c2f009291f58e3 100644 (file)
--- a/tests/matrix_free/parallel_multigrid_adaptive_06ref.cc
+++ b/tests/matrix_free/parallel_multigrid_adaptive_06ref.cc
@@ -140,7 +140,7 @@ do_test(const DoFHandler<dim> &dof)
   DoFTools::extract_locally_relevant_dofs(dof, locally_relevant_dofs);
 
   // Dirichlet BC
-  ZeroFunction<dim>                                   zero_function;
+  Functions::ZeroFunction<dim>                        zero_function;
   std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
   dirichlet_boundary[0] = &zero_function;
 

diff --git a/tests/matrix_free/parallel_multigrid_adaptive_07.cc b/tests/matrix_free/parallel_multigrid_adaptive_07.cc
index 62370ce38375e691c86acd996c8dc018c72a3ba7..90413c81fbaeebf9f530a8f56b692e9ccd13678a 100644 (file)
--- a/tests/matrix_free/parallel_multigrid_adaptive_07.cc
+++ b/tests/matrix_free/parallel_multigrid_adaptive_07.cc
@@ -243,7 +243,7 @@ do_test(const std::vector<const DoFHandler<dim> *> &dof)
     DoFTools::extract_locally_relevant_dofs(*dof[i], locally_relevant_dofs[i]);
 
   // Dirichlet BC
-  ZeroFunction<dim>                                   zero_function;
+  Functions::ZeroFunction<dim>                        zero_function;
   std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
   dirichlet_boundary[0] = &zero_function;
 

diff --git a/tests/matrix_free/pre_and_post_loops_02.cc b/tests/matrix_free/pre_and_post_loops_02.cc
index 8f3f745a2938304287a30b9c37e3221479d5fe08..28bc8354a95051679db77c061390c109280cf06f 100644 (file)
--- a/tests/matrix_free/pre_and_post_loops_02.cc
+++ b/tests/matrix_free/pre_and_post_loops_02.cc
@@ -146,7 +146,7 @@ test()
   constraints.reinit(relevant_dofs);
   VectorTools::interpolate_boundary_values(dof,
                                            0,
-                                           ZeroFunction<dim>(),
+                                           Functions::ZeroFunction<dim>(),
                                            constraints);
   constraints.close();
 

diff --git a/tests/meshworker/step-11-mesh_loop.cc b/tests/meshworker/step-11-mesh_loop.cc
index dba49fa217264270695ed786197d7c7cfeff9bf7..2e4584a373e274e3e7c90ef1f6174b35edf8fcbf 100644 (file)
--- a/tests/meshworker/step-11-mesh_loop.cc
+++ b/tests/meshworker/step-11-mesh_loop.cc
@@ -238,8 +238,8 @@ namespace Step11
 
       scratch_data.fe_values.reinit(cell);
 
-      std::vector<double>   rhs_values(n_q_points);
-      ConstantFunction<dim> right_hand_side(-2.0);
+      std::vector<double>              rhs_values(n_q_points);
+      Functions::ConstantFunction<dim> right_hand_side(-2.0);
       right_hand_side.value_list(scratch_data.fe_values.get_quadrature_points(),
                                  rhs_values);
 
@@ -269,8 +269,8 @@ namespace Step11
       const unsigned int n_face_q_points =
         scratch_data.fe_face_values.get_quadrature().size();
 
-      std::vector<double>   face_boundary_values(n_face_q_points);
-      ConstantFunction<dim> boundary_values(1.0);
+      std::vector<double>              face_boundary_values(n_face_q_points);
+      Functions::ConstantFunction<dim> boundary_values(1.0);
 
       scratch_data.fe_face_values.reinit(cell, face_no);
       boundary_values.value_list(
@@ -333,7 +333,7 @@ namespace Step11
     VectorTools::integrate_difference(mapping,
                                       dof_handler,
                                       solution,
-                                      ZeroFunction<dim>(),
+                                      Functions::ZeroFunction<dim>(),
                                       norm_per_cell,
                                       QGauss<dim>(gauss_degree + 1),
                                       VectorTools::H1_seminorm);

diff --git a/tests/mpi/constraints_consistent_01.cc b/tests/mpi/constraints_consistent_01.cc
index e96bd94392afd43372756010126616e21b4c546b..a72cd12c0460709e9eca0d180cfbaea2b2c42e78 100644 (file)
--- a/tests/mpi/constraints_consistent_01.cc
+++ b/tests/mpi/constraints_consistent_01.cc
@@ -68,7 +68,7 @@ check(parallel::distributed::Triangulation<dim> &tria)
     dealii::VectorTools::interpolate_boundary_values(
       dof_handler,
       id,
-      ConstantFunction<dim>(static_cast<double>(id) + 42.0, dim),
+      Functions::ConstantFunction<dim>(static_cast<double>(id) + 42.0, dim),
       constraints);
 
   VectorTools::compute_no_normal_flux_constraints(dof_handler,

diff --git a/tests/mpi/interpolate_05.cc b/tests/mpi/interpolate_05.cc
index c19bbb5e029ba6c499cb53c7677af150821bb915..e25f9d1ce5409da3d5b1ff277e785b7626b7a459 100644 (file)
--- a/tests/mpi/interpolate_05.cc
+++ b/tests/mpi/interpolate_05.cc
@@ -110,8 +110,8 @@ test()
 
   // Integrate the difference in the second component. Since we did not
   // interpolate the function into the finite element space, this should be
-  // equal to the integral of the ConstantFunction (=1) over the domain (unit
-  // square/cube). Thus the integral should be one.
+  // equal to the integral of the Functions::ConstantFunction (=1) over the
+  // domain (unit square/cube). Thus the integral should be one.
   VectorTools::integrate_difference(dofh,
                                     x_rel,
                                     Functions::ConstantFunction<dim>(1, 2),

diff --git a/tests/mpi/solution_transfer_05.cc b/tests/mpi/solution_transfer_05.cc
index 4562050e787bad0483582047afda01f5bc028142..6a2894e170bfcd9282c8218d41b5cf3297c4ae1b 100644 (file)
--- a/tests/mpi/solution_transfer_05.cc
+++ b/tests/mpi/solution_transfer_05.cc
@@ -77,7 +77,9 @@ test()
   // prepare dof_values
   LinearAlgebra::distributed::Vector<double> dgq_solution;
   dgq_solution.reinit(dgq_locally_owned_dofs, dgq_ghost_dofs, MPI_COMM_WORLD);
-  VectorTools::interpolate(dgq_dof_handler, ZeroFunction<dim>(), dgq_solution);
+  VectorTools::interpolate(dgq_dof_handler,
+                           Functions::ZeroFunction<dim>(),
+                           dgq_solution);
   dgq_solution.update_ghost_values();
 
   parallel::distributed::SolutionTransfer<

diff --git a/tests/multigrid/transfer_05.cc b/tests/multigrid/transfer_05.cc
index ec5447a9b33add4d905611ee48c06db2c93b8157..a720505812b291c55de1ece076debe93892069ec 100644 (file)
--- a/tests/multigrid/transfer_05.cc
+++ b/tests/multigrid/transfer_05.cc
@@ -106,7 +106,7 @@ check(const unsigned int fe_degree)
       mgdof.distribute_mg_dofs();
 
       MGConstrainedDoFs                                   mg_constrained_dofs;
-      ZeroFunction<dim>                                   zero_function;
+      Functions::ZeroFunction<dim>                        zero_function;
       std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
       dirichlet_boundary[0] = &zero_function;
       mg_constrained_dofs.initialize(mgdof, dirichlet_boundary);

diff --git a/tests/multigrid/transfer_06.cc b/tests/multigrid/transfer_06.cc
index 45116064f1817aa6a36e3e33ecce9776680638d3..3ceceec179697f0406d809d6c14f0905ec6c4d51 100644 (file)
--- a/tests/multigrid/transfer_06.cc
+++ b/tests/multigrid/transfer_06.cc
@@ -118,7 +118,7 @@ check(const unsigned int fe_degree)
       const std::vector<const DoFHandler<dim> *> mgdof_ptr{&mgdof_1, &mgdof_2};
 
       std::vector<MGConstrainedDoFs> mg_constrained_dofs_vector(2);
-      ZeroFunction<dim>              zero_function;
+      Functions::ZeroFunction<dim>   zero_function;
       std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
       dirichlet_boundary[0] = &zero_function;
       for (unsigned int i = 0; i < mgdof_ptr.size(); ++i)

diff --git a/tests/multigrid/transfer_matrix_free_02_block.cc b/tests/multigrid/transfer_matrix_free_02_block.cc
index 80bc808435f5f0e427e98bfe56759e23508b37a0..11058c2c17d5cbdcfb8a946503d798583755fc2a 100644 (file)
--- a/tests/multigrid/transfer_matrix_free_02_block.cc
+++ b/tests/multigrid/transfer_matrix_free_02_block.cc
@@ -101,7 +101,7 @@ check(const unsigned int fe_degree)
       mgdof.distribute_mg_dofs();
 
       MGConstrainedDoFs                                   mg_constrained_dofs;
-      ZeroFunction<dim>                                   zero_function;
+      Functions::ZeroFunction<dim>                        zero_function;
       std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
       dirichlet_boundary[0] = &zero_function;
       mg_constrained_dofs.initialize(mgdof, dirichlet_boundary);

diff --git a/tests/multigrid/transfer_matrix_free_02_block_02.cc b/tests/multigrid/transfer_matrix_free_02_block_02.cc
index 401f463a0ec6f575b27c180f75c78082210c33e8..ed9b210c9969278d8b86ad23a12258ff0be9e35f 100644 (file)
--- a/tests/multigrid/transfer_matrix_free_02_block_02.cc
+++ b/tests/multigrid/transfer_matrix_free_02_block_02.cc
@@ -112,7 +112,7 @@ check(const unsigned int fe_degree)
       const std::vector<const DoFHandler<dim> *> mgdof_ptr{&mgdof_1, &mgdof_2};
 
       std::vector<MGConstrainedDoFs> mg_constrained_dofs_vector(2);
-      ZeroFunction<dim>              zero_function;
+      Functions::ZeroFunction<dim>   zero_function;
       std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
       dirichlet_boundary[0] = &zero_function;
       for (unsigned int i = 0; i < mgdof_ptr.size(); ++i)

diff --git a/tests/numerics/generalized_interpolation_02.cc b/tests/numerics/generalized_interpolation_02.cc
index d148a13835742266092635df813cb2de1c021591..ab6073e8b1a18914fcb63f7de91337738daf77e6 100644 (file)
--- a/tests/numerics/generalized_interpolation_02.cc
+++ b/tests/numerics/generalized_interpolation_02.cc
@@ -30,31 +30,73 @@ main()
 {
   initlog();
 
-  test<2>(FE_Q<2>(1), ConstantFunction<2>(1.0, 1), 1, false, true);
-  test<2>(FE_Q<2>(2), ConstantFunction<2>(1.0, 1), 2, false, true);
-  test<3>(FE_Q<3>(3), ConstantFunction<3>(1.0, 1), 3, false, true);
-
-  test<2>(FE_Q<2>(1), ConstantFunction<2>(1.0, 1), 1, true, true);
-  test<2>(FE_Q<2>(2), ConstantFunction<2>(1.0, 1), 2, true, true);
-  test<3>(FE_Q<3>(3), ConstantFunction<3>(1.0, 1), 3, true, true);
-
-  test<2>(FE_RaviartThomas<2>(0), ConstantFunction<2>(1.0, 2), 1, false, true);
-  test<2>(FE_RaviartThomas<2>(1), ConstantFunction<2>(1.0, 2), 2, false, true);
-  test<2>(FE_RaviartThomas<2>(2), ConstantFunction<2>(1.0, 2), 3, false, true);
-  test<3>(FE_RaviartThomas<3>(0), ConstantFunction<3>(1.0, 3), 1, false, true);
-  test<3>(FE_RaviartThomas<3>(1), ConstantFunction<3>(1.0, 3), 2, false, true);
-
-  test<2>(FE_RaviartThomas<2>(0), ConstantFunction<2>(1.0, 2), 1, true, true);
-  test<2>(FE_RaviartThomas<2>(1), ConstantFunction<2>(1.0, 2), 2, true, true);
-  test<2>(FE_RaviartThomas<2>(2), ConstantFunction<2>(1.0, 2), 3, true, true);
+  test<2>(FE_Q<2>(1), Functions::ConstantFunction<2>(1.0, 1), 1, false, true);
+  test<2>(FE_Q<2>(2), Functions::ConstantFunction<2>(1.0, 1), 2, false, true);
+  test<3>(FE_Q<3>(3), Functions::ConstantFunction<3>(1.0, 1), 3, false, true);
+
+  test<2>(FE_Q<2>(1), Functions::ConstantFunction<2>(1.0, 1), 1, true, true);
+  test<2>(FE_Q<2>(2), Functions::ConstantFunction<2>(1.0, 1), 2, true, true);
+  test<3>(FE_Q<3>(3), Functions::ConstantFunction<3>(1.0, 1), 3, true, true);
+
+  test<2>(FE_RaviartThomas<2>(0),
+          Functions::ConstantFunction<2>(1.0, 2),
+          1,
+          false,
+          true);
+  test<2>(FE_RaviartThomas<2>(1),
+          Functions::ConstantFunction<2>(1.0, 2),
+          2,
+          false,
+          true);
+  test<2>(FE_RaviartThomas<2>(2),
+          Functions::ConstantFunction<2>(1.0, 2),
+          3,
+          false,
+          true);
+  test<3>(FE_RaviartThomas<3>(0),
+          Functions::ConstantFunction<3>(1.0, 3),
+          1,
+          false,
+          true);
+  test<3>(FE_RaviartThomas<3>(1),
+          Functions::ConstantFunction<3>(1.0, 3),
+          2,
+          false,
+          true);
+
+  test<2>(FE_RaviartThomas<2>(0),
+          Functions::ConstantFunction<2>(1.0, 2),
+          1,
+          true,
+          true);
+  test<2>(FE_RaviartThomas<2>(1),
+          Functions::ConstantFunction<2>(1.0, 2),
+          2,
+          true,
+          true);
+  test<2>(FE_RaviartThomas<2>(2),
+          Functions::ConstantFunction<2>(1.0, 2),
+          3,
+          true,
+          true);
   // lowest order RT in 3D does not contain constant 1 function on a
   // distorted mesh.
-  test<3>(FE_RaviartThomas<3>(1), ConstantFunction<3>(1.0, 3), 2, true, true);
-
-  test<2>(FE_Nedelec<2>(0), ConstantFunction<2>(1.0, 2), 1, false, true);
-  test<2>(FE_Nedelec<2>(1), ConstantFunction<2>(1.0, 2), 2, false, true);
-  test<2>(FE_Nedelec<2>(2), ConstantFunction<2>(1.0, 2), 3, false, true);
-  test<2>(FE_Nedelec<2>(0), ConstantFunction<2>(1.0, 2), 1, true, true);
-  test<2>(FE_Nedelec<2>(1), ConstantFunction<2>(1.0, 2), 2, true, true);
-  test<2>(FE_Nedelec<2>(2), ConstantFunction<2>(1.0, 2), 3, true, true);
+  test<3>(FE_RaviartThomas<3>(1),
+          Functions::ConstantFunction<3>(1.0, 3),
+          2,
+          true,
+          true);
+
+  test<2>(
+    FE_Nedelec<2>(0), Functions::ConstantFunction<2>(1.0, 2), 1, false, true);
+  test<2>(
+    FE_Nedelec<2>(1), Functions::ConstantFunction<2>(1.0, 2), 2, false, true);
+  test<2>(
+    FE_Nedelec<2>(2), Functions::ConstantFunction<2>(1.0, 2), 3, false, true);
+  test<2>(
+    FE_Nedelec<2>(0), Functions::ConstantFunction<2>(1.0, 2), 1, true, true);
+  test<2>(
+    FE_Nedelec<2>(1), Functions::ConstantFunction<2>(1.0, 2), 2, true, true);
+  test<2>(
+    FE_Nedelec<2>(2), Functions::ConstantFunction<2>(1.0, 2), 3, true, true);
 }

diff --git a/tests/optimization/step-44.h b/tests/optimization/step-44.h
index 1098160592160411b279cac0562c4f2d842c1ab6..dfce5daaeb3036c02f1b06dd37e868ebe1085225 100644 (file)
--- a/tests/optimization/step-44.h
+++ b/tests/optimization/step-44.h
@@ -1851,14 +1851,14 @@ namespace Step44
         VectorTools::interpolate_boundary_values(
           dof_handler_ref,
           boundary_id,
-          ZeroFunction<dim>(n_components),
+          Functions::ZeroFunction<dim>(n_components),
           constraints,
           fe.component_mask(x_displacement));
       else
         VectorTools::interpolate_boundary_values(
           dof_handler_ref,
           boundary_id,
-          ZeroFunction<dim>(n_components),
+          Functions::ZeroFunction<dim>(n_components),
           constraints,
           fe.component_mask(x_displacement));
     }
@@ -1868,14 +1868,14 @@ namespace Step44
         VectorTools::interpolate_boundary_values(
           dof_handler_ref,
           boundary_id,
-          ZeroFunction<dim>(n_components),
+          Functions::ZeroFunction<dim>(n_components),
           constraints,
           fe.component_mask(y_displacement));
       else
         VectorTools::interpolate_boundary_values(
           dof_handler_ref,
           boundary_id,
-          ZeroFunction<dim>(n_components),
+          Functions::ZeroFunction<dim>(n_components),
           constraints,
           fe.component_mask(y_displacement));
     }
@@ -1888,7 +1888,7 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement) |
                fe.component_mask(z_displacement)));
@@ -1896,7 +1896,7 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement) |
                fe.component_mask(z_displacement)));
@@ -1907,14 +1907,14 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               fe.component_mask(z_displacement));
           else
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               fe.component_mask(z_displacement));
         }
@@ -1924,7 +1924,7 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement) |
                fe.component_mask(z_displacement)));
@@ -1932,7 +1932,7 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement) |
                fe.component_mask(z_displacement)));
@@ -1946,14 +1946,14 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement)));
           else
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement)));
         }
@@ -1963,14 +1963,14 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement)));
           else
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement)));
         }

diff --git a/tests/particles/particle_interpolation_01.cc b/tests/particles/particle_interpolation_01.cc
index a27b8decc99f92b18a7ed88e2cc3f215ace81385..abc6bd26f194112f8ba34b54c4f3e5c26ec4b78e 100644 (file)
--- a/tests/particles/particle_interpolation_01.cc
+++ b/tests/particles/particle_interpolation_01.cc
@@ -61,7 +61,7 @@ test()
 
   Particles::Generators::probabilistic_locations<dim, spacedim>(
     space_tria,
-    ConstantFunction<spacedim, double>(1.),
+    Functions::ConstantFunction<spacedim, double>(1.),
     true,
     Utilities::MPI::n_mpi_processes(MPI_COMM_WORLD) *
       estimated_n_particles_per_processor,

diff --git a/tests/particles/particle_interpolation_02.cc b/tests/particles/particle_interpolation_02.cc
index 78d43fffce77c9735d0a2799c3614f83302fce2f..5cacdff2213271917f2a01ad720a4077cee8da23 100644 (file)
--- a/tests/particles/particle_interpolation_02.cc
+++ b/tests/particles/particle_interpolation_02.cc
@@ -65,7 +65,7 @@ test()
 
   Particles::Generators::probabilistic_locations<dim, spacedim>(
     space_tria,
-    ConstantFunction<spacedim, double>(1.),
+    Functions::ConstantFunction<spacedim, double>(1.),
     true,
     Utilities::MPI::n_mpi_processes(MPI_COMM_WORLD) *
       estimated_n_particles_per_processor,

diff --git a/tests/particles/particle_interpolation_03.cc b/tests/particles/particle_interpolation_03.cc
index 11a899990941dd8d0a8c85c3e1112f686451d150..b3edfb11ce6f3ddefc65cc71d7112701bb718459 100644 (file)
--- a/tests/particles/particle_interpolation_03.cc
+++ b/tests/particles/particle_interpolation_03.cc
@@ -64,7 +64,7 @@ test()
 
   Particles::Generators::probabilistic_locations<dim, spacedim>(
     space_tria,
-    ConstantFunction<spacedim, double>(1.),
+    Functions::ConstantFunction<spacedim, double>(1.),
     true,
     Utilities::MPI::n_mpi_processes(MPI_COMM_WORLD) *
       estimated_n_particles_per_processor,

diff --git a/tests/symengine/sd_common_tests/step-44-sd-quadrature_level.h b/tests/symengine/sd_common_tests/step-44-sd-quadrature_level.h
index 6b316bbd85db2e82818ce453aaf1b51418510276..1dc2f869b465952787729b8dd680d0ba8e18eb57 100644 (file)
--- a/tests/symengine/sd_common_tests/step-44-sd-quadrature_level.h
+++ b/tests/symengine/sd_common_tests/step-44-sd-quadrature_level.h
@@ -1650,14 +1650,14 @@ namespace Step44
         VectorTools::interpolate_boundary_values(
           dof_handler_ref,
           boundary_id,
-          ZeroFunction<dim>(n_components),
+          Functions::ZeroFunction<dim>(n_components),
           constraints,
           fe.component_mask(x_displacement));
       else
         VectorTools::interpolate_boundary_values(
           dof_handler_ref,
           boundary_id,
-          ZeroFunction<dim>(n_components),
+          Functions::ZeroFunction<dim>(n_components),
           constraints,
           fe.component_mask(x_displacement));
     }
@@ -1667,14 +1667,14 @@ namespace Step44
         VectorTools::interpolate_boundary_values(
           dof_handler_ref,
           boundary_id,
-          ZeroFunction<dim>(n_components),
+          Functions::ZeroFunction<dim>(n_components),
           constraints,
           fe.component_mask(y_displacement));
       else
         VectorTools::interpolate_boundary_values(
           dof_handler_ref,
           boundary_id,
-          ZeroFunction<dim>(n_components),
+          Functions::ZeroFunction<dim>(n_components),
           constraints,
           fe.component_mask(y_displacement));
     }
@@ -1687,7 +1687,7 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement) |
                fe.component_mask(z_displacement)));
@@ -1695,7 +1695,7 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement) |
                fe.component_mask(z_displacement)));
@@ -1706,14 +1706,14 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               fe.component_mask(z_displacement));
           else
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               fe.component_mask(z_displacement));
         }
@@ -1723,7 +1723,7 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement) |
                fe.component_mask(z_displacement)));
@@ -1731,7 +1731,7 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement) |
                fe.component_mask(z_displacement)));
@@ -1745,14 +1745,14 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement)));
           else
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement)));
         }
@@ -1762,14 +1762,14 @@ namespace Step44
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement)));
           else
             VectorTools::interpolate_boundary_values(
               dof_handler_ref,
               boundary_id,
-              ZeroFunction<dim>(n_components),
+              Functions::ZeroFunction<dim>(n_components),
               constraints,
               (fe.component_mask(x_displacement)));
         }

diff --git a/tests/vector_tools/integrate_difference_02_nan.cc b/tests/vector_tools/integrate_difference_02_nan.cc
index 801172af64575fee3b8eb9843fcc3a9c83572480..1b002e4c15efaa97ce5997bbddae9c5dd425349e 100644 (file)
--- a/tests/vector_tools/integrate_difference_02_nan.cc
+++ b/tests/vector_tools/integrate_difference_02_nan.cc
@@ -91,7 +91,7 @@ test(VectorTools::NormType norm, double exp = 2.0)
   const ComponentSelectFunction<dim> component_mask(1, 2);
   VectorTools::integrate_difference(dofh,
                                     solution,
-                                    ZeroFunction<dim>(2),
+                                    Functions::ZeroFunction<dim>(2),
                                     cellwise_errors,
                                     quadrature,
                                     norm,

diff --git a/tests/vector_tools/integrate_difference_05.cc b/tests/vector_tools/integrate_difference_05.cc
index bd4feac0e86df786f0b9567e3c3e069c2d159919..357088f75697603aeb37f954056ce6117365aa09 100644 (file)
--- a/tests/vector_tools/integrate_difference_05.cc
+++ b/tests/vector_tools/integrate_difference_05.cc
@@ -102,7 +102,7 @@ test(VectorTools::NormType norm, double value)
                                             2 * dim);
   VectorTools::integrate_difference(dofh,
                                     solution,
-                                    ZeroFunction<dim>(2 * dim),
+                                    Functions::ZeroFunction<dim>(2 * dim),
                                     cellwise_errors,
                                     QGauss<dim>(5),
                                     norm);
@@ -117,7 +117,7 @@ test(VectorTools::NormType norm, double value)
 
   VectorTools::integrate_difference(dofh,
                                     solution,
-                                    ZeroFunction<dim>(2 * dim),
+                                    Functions::ZeroFunction<dim>(2 * dim),
                                     cellwise_errors,
                                     QGauss<dim>(5),
                                     norm,