]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Avoid FunctionMap in tests
authorDaniel Arndt <daniel.arndt@iwr.uni-heidelberg.de>
Mon, 11 Jun 2018 15:28:50 +0000 (17:28 +0200)
committerDaniel Arndt <daniel.arndt@iwr.uni-heidelberg.de>
Thu, 14 Jun 2018 08:27:24 +0000 (10:27 +0200)
124 files changed:
tests/bits/joa_1.cc
tests/bits/static_condensation.cc
tests/bits/step-13.cc
tests/bits/step-14.cc
tests/bits/step-51.cc
tests/bits/step-51p.cc
tests/bits/step-6-racoptimize-2.cc
tests/bits/step-6-racoptimize.cc
tests/bits/step-6.cc
tests/bits/step-7.cc
tests/bits/step-8.cc
tests/data_out/data_out_postprocessor_tensor_01.cc
tests/data_out/data_out_postprocessor_vector_03.cc
tests/dofs/dof_renumbering.cc
tests/dofs/dof_tools_14.cc
tests/dofs/dof_tools_16a.cc
tests/dofs/dof_tools_16b.cc
tests/dofs/dof_tools_16c.cc
tests/dofs/dof_tools_16d.cc
tests/dofs/range_based_for_step-6.cc
tests/fail/circular_01.cc
tests/fail/hp-step-14.cc
tests/fe/abf_01.cc
tests/fe/deformed_projection.h
tests/fe/fe_enriched_step-36.cc
tests/fe/fe_enriched_step-36b.cc
tests/grid/mesh_3d_12.cc
tests/hp/boundary_matrices.cc
tests/hp/boundary_matrices_hp.cc
tests/hp/crash_17.cc
tests/hp/crash_18.cc
tests/hp/matrices.cc
tests/hp/matrices_hp.cc
tests/hp/step-13.cc
tests/hp/step-27.cc
tests/hp/step-6.cc
tests/hp/step-7.cc
tests/hp/step-8.cc
tests/lac/constrained_linear_operator_01.cc
tests/lac/matrices_02.cc
tests/lac/schur_complement_03.cc
tests/matrix_free/matrix_vector_mg.cc
tests/matrix_free/multigrid_dg_sip_01.cc
tests/matrix_free/multigrid_dg_sip_02.cc
tests/matrix_free/parallel_multigrid.cc
tests/matrix_free/parallel_multigrid_02.cc
tests/matrix_free/parallel_multigrid_adaptive_01.cc
tests/matrix_free/parallel_multigrid_adaptive_02.cc
tests/matrix_free/parallel_multigrid_adaptive_03.cc
tests/matrix_free/parallel_multigrid_adaptive_04.cc
tests/matrix_free/parallel_multigrid_adaptive_05.cc
tests/matrix_free/parallel_multigrid_adaptive_06.cc
tests/matrix_free/parallel_multigrid_adaptive_06ref.cc
tests/matrix_free/parallel_multigrid_adaptive_07.cc
tests/matrix_free/parallel_multigrid_mf.cc
tests/matrix_free/step-37.cc
tests/meshworker/step-50-mesh_loop.cc
tests/mpi/interpolate_to_different_mesh_02.cc
tests/mpi/muelu_periodicity.cc
tests/mpi/multigrid_adaptive.cc
tests/mpi/multigrid_uniform.cc
tests/mpi/periodicity_01.cc
tests/mpi/periodicity_02.cc
tests/mpi/periodicity_03.cc
tests/mpi/step-37.cc
tests/mpi/trilinos_distribute_04.cc
tests/multigrid/boundary_01.cc
tests/multigrid/constrained_dofs_01.cc
tests/multigrid/constrained_dofs_02.cc
tests/multigrid/constrained_dofs_03.cc
tests/multigrid/dof_01.cc
tests/multigrid/dof_02.cc
tests/multigrid/events_01.cc
tests/multigrid/interface_matrix_entry_01.cc
tests/multigrid/mg_coarse_01.cc
tests/multigrid/mg_output_dirichlet.cc
tests/multigrid/mg_output_neumann.cc
tests/multigrid/mg_renumbered_01.cc
tests/multigrid/mg_renumbered_02.cc
tests/multigrid/mg_renumbered_03.cc
tests/multigrid/step-16-02.cc
tests/multigrid/step-16-03.cc
tests/multigrid/step-16-04.cc
tests/multigrid/step-16-05.cc
tests/multigrid/step-16-06.cc
tests/multigrid/step-16-07.cc
tests/multigrid/step-16-50-mpi-linear-operator.cc
tests/multigrid/step-16-50-mpi-smoother.cc
tests/multigrid/step-16-50-mpi.cc
tests/multigrid/step-16-50-serial.cc
tests/multigrid/step-16-bdry1.cc
tests/multigrid/step-16.cc
tests/multigrid/step-50_01.cc
tests/multigrid/step-50_02.cc
tests/multigrid/transfer_04.cc
tests/multigrid/transfer_04a.cc
tests/multigrid/transfer_04b.cc
tests/multigrid/transfer_05.cc
tests/multigrid/transfer_06.cc
tests/multigrid/transfer_matrix_free_01.cc
tests/multigrid/transfer_matrix_free_02.cc
tests/multigrid/transfer_matrix_free_02_block.cc
tests/multigrid/transfer_matrix_free_02_block_02.cc
tests/multigrid/transfer_matrix_free_03.cc
tests/multigrid/transfer_matrix_free_06.cc
tests/multigrid/transfer_prebuilt_03.cc
tests/multigrid/transfer_prebuilt_04.cc
tests/multigrid/transfer_select.cc
tests/multigrid/transfer_system_adaptive_02.cc
tests/multigrid/transfer_system_adaptive_04.cc
tests/multigrid/transfer_system_adaptive_06.cc
tests/multigrid/transfer_system_adaptive_08.cc
tests/numerics/error_estimator_02.cc
tests/numerics/error_estimator_02_complex.cc
tests/numerics/normal_flux_inhom_01.cc
tests/numerics/project_boundary_01.cc
tests/numerics/project_boundary_rt_01.cc
tests/numerics/tangential_flux_inhom_01.cc
tests/physics/step-18-rotation_matrix.cc
tests/physics/step-18.cc
tests/trilinos/solver_control_06.cc
tests/vector_tools/boundaries.cc
tests/vector_tools/boundaries_complex.cc
tests/vector_tools/boundaries_complex_hp.cc

index bc549a67d2e0e66d5ec6de3229612aa8e031b9b6..8434d19569d0b0c59211da6db46b628f7f4e17ce 100644 (file)
@@ -808,10 +808,8 @@ LaplaceProblem<dim>::solve()
 // list of boundaries where we have
 // imposed Neumann value, and the
 // corresponding Neumann values. This
-// information is represented by an
-// object of type
-// <code>FunctionMap@<dim@>::type</code> that is
-// essentially a map from boundary
+// information is represented by
+// a map from boundary
 // indicators to function objects
 // describing Neumann boundary values
 // (in the present example program,
@@ -841,11 +839,12 @@ LaplaceProblem<dim>::refine_grid()
 {
   Vector<float> estimated_error_per_cell(triangulation.n_active_cells());
 
-  KellyErrorEstimator<dim>::estimate(dof_handler,
-                                     QGauss<dim - 1>(3),
-                                     typename FunctionMap<dim>::type(),
-                                     solution,
-                                     estimated_error_per_cell);
+  KellyErrorEstimator<dim>::estimate(
+    dof_handler,
+    QGauss<dim - 1>(3),
+    std::map<types::boundary_id, const Function<dim> *>(),
+    solution,
+    estimated_error_per_cell);
 
   // The above function returned one
   // error indicator value for each
index 68d20aff02c0182eaf813d07a135fde90594b2d7..2cff4ca7ad918524934fe6903c0f1182f0023298 100644 (file)
@@ -539,7 +539,7 @@ HelmholtzProblem<dim>::refine_grid()
           Vector<float> estimated_error_per_cell(
             triangulation.n_active_cells());
 
-          typename FunctionMap<dim>::type neumann_boundary;
+          std::map<types::boundary_id, const Function<dim> *> neumann_boundary;
           KellyErrorEstimator<dim>::estimate(dof_handler,
                                              QGauss<dim - 1>(3),
                                              neumann_boundary,
index f94eef1a8e43186261b77411040856f581a4779f..66e945180d8ef988af14b0f7465e54ab587203db 100644 (file)
@@ -632,11 +632,12 @@ namespace LaplaceSolver
   {
     Vector<float> estimated_error_per_cell(
       this->triangulation->n_active_cells());
-    KellyErrorEstimator<dim>::estimate(this->dof_handler,
-                                       QGauss<dim - 1>(3),
-                                       typename FunctionMap<dim>::type(),
-                                       this->solution,
-                                       estimated_error_per_cell);
+    KellyErrorEstimator<dim>::estimate(
+      this->dof_handler,
+      QGauss<dim - 1>(3),
+      std::map<types::boundary_id, const Function<dim> *>(),
+      this->solution,
+      estimated_error_per_cell);
     GridRefinement::refine_and_coarsen_fixed_number(*this->triangulation,
                                                     estimated_error_per_cell,
                                                     0.3,
index 44198bc93f259f0fb1ee1585d93fd8ead39afcfd..31533dd6abdbee619f6ceffed16ce625d9047a5d 100644 (file)
@@ -786,11 +786,12 @@ namespace LaplaceSolver
   {
     Vector<float> estimated_error_per_cell(
       this->triangulation->n_active_cells());
-    KellyErrorEstimator<dim>::estimate(this->dof_handler,
-                                       QGauss<dim - 1>(3),
-                                       typename FunctionMap<dim>::type(),
-                                       this->solution,
-                                       estimated_error_per_cell);
+    KellyErrorEstimator<dim>::estimate(
+      this->dof_handler,
+      QGauss<dim - 1>(3),
+      std::map<types::boundary_id, const Function<dim> *>(),
+      this->solution,
+      estimated_error_per_cell);
     GridRefinement::refine_and_coarsen_fixed_number(*this->triangulation,
                                                     estimated_error_per_cell,
                                                     0.3,
@@ -847,11 +848,12 @@ namespace LaplaceSolver
   RefinementWeightedKelly<dim>::refine_grid()
   {
     Vector<float> estimated_error(this->triangulation->n_active_cells());
-    KellyErrorEstimator<dim>::estimate(this->dof_handler,
-                                       *this->face_quadrature,
-                                       typename FunctionMap<dim>::type(),
-                                       this->solution,
-                                       estimated_error);
+    KellyErrorEstimator<dim>::estimate(
+      this->dof_handler,
+      *this->face_quadrature,
+      std::map<types::boundary_id, const Function<dim> *>(),
+      this->solution,
+      estimated_error);
 
     typename DoFHandler<dim>::active_cell_iterator cell = this->dof_handler
                                                             .begin_active(),
index 3be2cf4f7e0c6c8b1d44f25c89e907e3b4751b1a..8c744f4bac60e65e5400769743e104f0a84eb38d 100644 (file)
@@ -350,8 +350,8 @@ namespace Step51
 
     constraints.clear();
     DoFTools::make_hanging_node_constraints(dof_handler, constraints);
-    typename FunctionMap<dim>::type boundary_functions;
-    Solution<dim>                   solution_function;
+    std::map<types::boundary_id, const Function<dim> *> boundary_functions;
+    Solution<dim>                                       solution_function;
     boundary_functions[0] = &solution_function;
     VectorTools::project_boundary_values(dof_handler,
                                          boundary_functions,
index 5fc7060887a598ba4bfdf8710937541571885d58..eb77e3053e347d81c6ac0c13b61abd8602049f5e 100644 (file)
@@ -350,8 +350,8 @@ namespace Step51
 
     constraints.clear();
     DoFTools::make_hanging_node_constraints(dof_handler, constraints);
-    typename FunctionMap<dim>::type boundary_functions;
-    Solution<dim>                   solution_function;
+    std::map<types::boundary_id, const Function<dim> *> boundary_functions;
+    Solution<dim>                                       solution_function;
     boundary_functions[0] = &solution_function;
     VectorTools::project_boundary_values(dof_handler,
                                          boundary_functions,
index edb69dd0ef9d7e60a78ecd6f678bd945635dd382..0005fbb29d98e1b5a93b45dc65fd49a64fb02d81 100644 (file)
@@ -296,11 +296,12 @@ LaplaceProblem<dim>::refine_grid()
 {
   Vector<float> estimated_error_per_cell(triangulation.n_active_cells());
 
-  KellyErrorEstimator<dim>::estimate(dof_handler,
-                                     QGauss<dim - 1>(3),
-                                     typename FunctionMap<dim>::type(),
-                                     solution,
-                                     estimated_error_per_cell);
+  KellyErrorEstimator<dim>::estimate(
+    dof_handler,
+    QGauss<dim - 1>(3),
+    std::map<types::boundary_id, const Function<dim> *>(),
+    solution,
+    estimated_error_per_cell);
 
   GridRefinement::refine_and_coarsen_optimize(triangulation,
                                               estimated_error_per_cell,
index e159bdfd5258538993185a1d73d144452ed45a3e..848fa67327a9e6073204a817c555d308d7e89181 100644 (file)
@@ -296,11 +296,12 @@ LaplaceProblem<dim>::refine_grid()
 {
   Vector<float> estimated_error_per_cell(triangulation.n_active_cells());
 
-  KellyErrorEstimator<dim>::estimate(dof_handler,
-                                     QGauss<dim - 1>(3),
-                                     typename FunctionMap<dim>::type(),
-                                     solution,
-                                     estimated_error_per_cell);
+  KellyErrorEstimator<dim>::estimate(
+    dof_handler,
+    QGauss<dim - 1>(3),
+    std::map<types::boundary_id, const Function<dim> *>(),
+    solution,
+    estimated_error_per_cell);
 
   GridRefinement::refine_and_coarsen_optimize(triangulation,
                                               estimated_error_per_cell);
index 17b8ed95641b2a541c889210f4778ef309d86506..0c93a256c2e6f48c7184decf5a3c61988245a36b 100644 (file)
@@ -291,11 +291,12 @@ LaplaceProblem<dim>::refine_grid()
 {
   Vector<float> estimated_error_per_cell(triangulation.n_active_cells());
 
-  KellyErrorEstimator<dim>::estimate(dof_handler,
-                                     QGauss<dim - 1>(3),
-                                     typename FunctionMap<dim>::type(),
-                                     solution,
-                                     estimated_error_per_cell);
+  KellyErrorEstimator<dim>::estimate(
+    dof_handler,
+    QGauss<dim - 1>(3),
+    std::map<types::boundary_id, const Function<dim> *>(),
+    solution,
+    estimated_error_per_cell);
 
   GridRefinement::refine_and_coarsen_fixed_number(triangulation,
                                                   estimated_error_per_cell,
index 6705327d77b415734b3d5e2e9ef5da440877ae4d..93158bcac4d61160443199bce71e12be9b315565 100644 (file)
@@ -415,7 +415,7 @@ HelmholtzProblem<dim>::refine_grid()
           Vector<float> estimated_error_per_cell(
             triangulation.n_active_cells());
 
-          typename FunctionMap<dim>::type neumann_boundary;
+          std::map<types::boundary_id, const Function<dim> *> neumann_boundary;
           KellyErrorEstimator<dim>::estimate(dof_handler,
                                              QGauss<dim - 1>(3),
                                              neumann_boundary,
index e86fb66beb3072d4e38ff4113a15013db036f351..39a8af519ec4276b77c7e30db0b14c8fa45a2f98 100644 (file)
@@ -336,7 +336,7 @@ ElasticProblem<dim>::refine_grid()
 {
   Vector<float> estimated_error_per_cell(triangulation.n_active_cells());
 
-  typename FunctionMap<dim>::type neumann_boundary;
+  std::map<types::boundary_id, const Function<dim> *> neumann_boundary;
   KellyErrorEstimator<dim>::estimate(dof_handler,
                                      QGauss<dim - 1>(2),
                                      neumann_boundary,
index 2ccc13d8ac2079fb3f15296e08e733f64642acf1..daf83f3829bf511a3d93df53b604a3af7c9f5ffa 100644 (file)
@@ -299,11 +299,12 @@ namespace Step8
   {
     Vector<float> estimated_error_per_cell(triangulation.n_active_cells());
 
-    KellyErrorEstimator<dim>::estimate(dof_handler,
-                                       QGauss<dim - 1>(2),
-                                       typename FunctionMap<dim>::type(),
-                                       solution,
-                                       estimated_error_per_cell);
+    KellyErrorEstimator<dim>::estimate(
+      dof_handler,
+      QGauss<dim - 1>(2),
+      std::map<types::boundary_id, const Function<dim> *>(),
+      solution,
+      estimated_error_per_cell);
 
     GridRefinement::refine_and_coarsen_fixed_number(triangulation,
                                                     estimated_error_per_cell,
index 8cdb9a09758576e6203bfb878c69ca6a56264dc9..3efbe7d3e72ea648518b109d18aab2cc793bc0e7 100644 (file)
@@ -237,11 +237,12 @@ Step6<dim>::refine_grid()
 {
   Vector<float> estimated_error_per_cell(triangulation.n_active_cells());
 
-  KellyErrorEstimator<dim>::estimate(dof_handler,
-                                     QGauss<dim - 1>(3),
-                                     typename FunctionMap<dim>::type(),
-                                     solution,
-                                     estimated_error_per_cell);
+  KellyErrorEstimator<dim>::estimate(
+    dof_handler,
+    QGauss<dim - 1>(3),
+    std::map<types::boundary_id, const Function<dim> *>(),
+    solution,
+    estimated_error_per_cell);
 
   GridRefinement::refine_and_coarsen_fixed_number(triangulation,
                                                   estimated_error_per_cell,
index 43719ab08193cf18b03c2f590118cc8c642c6e90..62c44a8f1947c18ef6244186efb1c3e6885c5f48 100644 (file)
@@ -146,8 +146,7 @@ check_renumbering(DoFHandler<dim> &mgdof, bool discontinuous)
       // behavior of the
       // DoFRenumbering::component_wise set
       // of functions before December 2005
-      DoFRenumbering::component_wise(static_cast<DoFHandler<dim> &>(mgdof),
-                                     order);
+      DoFRenumbering::component_wise(mgdof, order);
       print_dofs(mgdof, level);
     }
 }
index 2822fd434078fe3ed7e3e9c9281d6cb600b081af..5700e54aeecc55388919cb5e90dc55eb6b956677 100644 (file)
@@ -31,8 +31,8 @@ check_this(const DoFHandler<dim> &dof_handler)
   // no other args
   deallog << dof_handler.n_boundary_dofs() << std::endl;
 
-  // with FunctionMap
-  typename FunctionMap<dim>::type fm;
+  // with std::map
+  std::map<types::boundary_id, const Function<dim> *> fm;
   fm[0] = nullptr;
   deallog << dof_handler.n_boundary_dofs(fm) << std::endl;
 
index f00c9f669fdc4dfe9c4c8c240ceb0ba851dfd8be..36486670049f2e9a4bcdb51ba9b2d64ff97f7ff0 100644 (file)
@@ -22,8 +22,9 @@
 // check
 //   DoFTools::
 //   make_boundary_sparsity_pattern (const DoFHandler<dim> &,
-//                                   const typename FunctionMap<dim>::type &
-//                                   const std::vector<unsigned int> &
+//                                   const std::map<types::boundary_id, const
+//                                   Function<dim>*> & const
+//                                   std::vector<unsigned int> &
 //                               SparsityPattern       &);
 
 
@@ -43,7 +44,7 @@ check_this(const DoFHandler<dim> &dof_handler)
   DoFTools::map_dof_to_boundary_indices(dof_handler, set, map);
 
   // create sparsity pattern
-  typename FunctionMap<dim>::type boundary_ids;
+  std::map<types::boundary_id, const Function<dim> *> boundary_ids;
   boundary_ids[0] = nullptr;
   SparsityPattern sp(dof_handler.n_boundary_dofs(boundary_ids),
                      dof_handler.max_couplings_between_dofs());
index 0a327a8b65acd1ad3c2c916b5e41de16d8160819..0b7060d37091283a4c6e5c97ebcecf096a171650 100644 (file)
@@ -22,8 +22,9 @@
 // check
 //   DoFTools::
 //   make_boundary_sparsity_pattern (const DoFHandler<dim>     &,
-//                                   const typename FunctionMap<dim>::type &
-//                                   const std::vector<unsigned int> &
+//                                   const std::map<types::boundary_id, const
+//                                   Function<dim>*> & const
+//                                   std::vector<unsigned int> &
 //                               DynamicSparsityPattern &);
 
 
@@ -43,7 +44,7 @@ check_this(const DoFHandler<dim> &dof_handler)
   DoFTools::map_dof_to_boundary_indices(dof_handler, set, map);
 
   // create sparsity pattern
-  typename FunctionMap<dim>::type boundary_ids;
+  std::map<types::boundary_id, const Function<dim> *> boundary_ids;
   boundary_ids[0] = nullptr;
   DynamicSparsityPattern sp(dof_handler.n_boundary_dofs(boundary_ids));
   DoFTools::make_boundary_sparsity_pattern(dof_handler, boundary_ids, map, sp);
index 9199ee603bb5f0709f71c7406b9440167d1e92b8..df84a2a32f08b14f40cbfb5e1ae8113c67e512e8 100644 (file)
@@ -22,8 +22,9 @@
 // check
 //   DoFTools::
 //   make_boundary_sparsity_pattern (const DoFHandler<dim> &,
-//                                   const typename FunctionMap<dim>::type &
-//                                   const std::vector<unsigned int> &
+//                                   const std::map<types::boundary_id, const
+//                                   Function<dim>*> & const
+//                                   std::vector<unsigned int> &
 //                               BlockSparsityPattern  &);
 
 
@@ -42,7 +43,7 @@ check_this(const DoFHandler<dim> &dof_handler)
   set.insert(0);
   DoFTools::map_dof_to_boundary_indices(dof_handler, set, map);
 
-  typename FunctionMap<dim>::type boundary_ids;
+  std::map<types::boundary_id, const Function<dim> *> boundary_ids;
   boundary_ids[0] = nullptr;
   const unsigned int n_boundary_dofs =
     dof_handler.n_boundary_dofs(boundary_ids);
index ef63eda919be216aabef11f682d98b0fe7fd5a28..7724beb4844a1128ba5f9a988588efef2c2687e4 100644 (file)
@@ -22,8 +22,9 @@
 // check
 //   DoFTools::
 //   make_boundary_sparsity_pattern (const DoFHandler<dim> &,
-//                                   const typename FunctionMap<dim>::type &
-//                                   const std::vector<unsigned int> &
+//                                   const std::map<types::boundary_id, const
+//                                   Function<dim>*> & const
+//                                   std::vector<unsigned int> &
 //                               BlockDynamicSparsityPattern  &);
 
 
@@ -42,7 +43,7 @@ check_this(const DoFHandler<dim> &dof_handler)
   set.insert(0);
   DoFTools::map_dof_to_boundary_indices(dof_handler, set, map);
 
-  typename FunctionMap<dim>::type boundary_ids;
+  std::map<types::boundary_id, const Function<dim> *> boundary_ids;
   boundary_ids[0] = nullptr;
   const types::global_dof_index n_boundary_dofs =
     dof_handler.n_boundary_dofs(boundary_ids);
index 524ec2a60b7eb152aedd411f93d92234f29c9058..c929d18321a21b39dc21481c2aab687aeeecbd80 100644 (file)
@@ -277,11 +277,12 @@ Step6<dim>::refine_grid()
 {
   Vector<float> estimated_error_per_cell(triangulation.n_active_cells());
 
-  KellyErrorEstimator<dim>::estimate(dof_handler,
-                                     QGauss<dim - 1>(3),
-                                     typename FunctionMap<dim>::type(),
-                                     solution,
-                                     estimated_error_per_cell);
+  KellyErrorEstimator<dim>::estimate(
+    dof_handler,
+    QGauss<dim - 1>(3),
+    std::map<types::boundary_id, const Function<dim> *>(),
+    solution,
+    estimated_error_per_cell);
 
   GridRefinement::refine_and_coarsen_fixed_number(triangulation,
                                                   estimated_error_per_cell,
index ecd170f928b349521c010391f710a43585f7e767..f477566a3f964c014adcf721f4669ef60368fadb 100644 (file)
@@ -468,11 +468,12 @@ void
 LaplaceProblem<dim>::refine_grid()
 {
   Vector<float> estimated_error_per_cell(triangulation.n_active_cells());
-  KellyErrorEstimator<dim>::estimate(dof_handler,
-                                     face_quadrature_collection,
-                                     typename FunctionMap<dim>::type(),
-                                     solution,
-                                     estimated_error_per_cell);
+  KellyErrorEstimator<dim>::estimate(
+    dof_handler,
+    face_quadrature_collection,
+    std::map<types::boundary_id, const Function<dim> *>(),
+    solution,
+    estimated_error_per_cell);
 
   Vector<float> smoothness_indicators(triangulation.n_active_cells());
   estimate_smoothness(smoothness_indicators);
index 0aae5f009c3f060eaf7f924a0c739a157c3d0b71..5d763d777b60639fb685f9982a1e43fe0d79facb 100644 (file)
@@ -796,11 +796,12 @@ namespace LaplaceSolver
   {
     Vector<float> estimated_error_per_cell(
       this->triangulation->n_active_cells());
-    KellyErrorEstimator<dim>::estimate(this->dof_handler,
-                                       QGauss<dim - 1>(3),
-                                       typename FunctionMap<dim>::type(),
-                                       this->solution,
-                                       estimated_error_per_cell);
+    KellyErrorEstimator<dim>::estimate(
+      this->dof_handler,
+      QGauss<dim - 1>(3),
+      std::map<types::boundary_id, const Function<dim> *>(),
+      this->solution,
+      estimated_error_per_cell);
     GridRefinement::refine_and_coarsen_fixed_number(*this->triangulation,
                                                     estimated_error_per_cell,
                                                     0.3,
@@ -857,11 +858,12 @@ namespace LaplaceSolver
   RefinementWeightedKelly<dim>::refine_grid()
   {
     Vector<float> estimated_error(this->triangulation->n_active_cells());
-    KellyErrorEstimator<dim>::estimate(this->dof_handler,
-                                       (*this->face_quadrature)[0],
-                                       typename FunctionMap<dim>::type(),
-                                       this->solution,
-                                       estimated_error);
+    KellyErrorEstimator<dim>::estimate(
+      this->dof_handler,
+      (*this->face_quadrature)[0],
+      std::map<types::boundary_id, const Function<dim> *>(),
+      this->solution,
+      estimated_error);
 
     typename hp::DoFHandler<dim>::active_cell_iterator
       cell = this->dof_handler.begin_active(),
index cae1e00bd3ed82950fdfeca34640a6f41ed39665..04efe07bc77055af5074291b4164ac0fc632d328 100644 (file)
@@ -499,7 +499,7 @@ project(const Mapping<dim> &    mapping,
                  // the different boundary parts. We want the
                  // @p{function} to hold on all parts of the
                  // boundary
-        typename FunctionMap<dim>::type boundary_functions;
+        std::map<types::boundary_id, const Function<dim>*> boundary_functions;
         for (types::boundary_id c=0; c<255; ++c)
           boundary_functions[c] = &function;
         project_boundary_values (dof, boundary_functions, q_boundary,
index 3024bc3ec59e88d05824013440c4458c2e1a9708..8b745e8a01dab4e09abe7bce4e87cc9f4c35dc6c 100644 (file)
@@ -549,17 +549,15 @@ project(const Mapping<dim> &    mapping,
     if (project_to_boundary_first == true)
     // boundary projection required
     {
-      /*
-               // set up a list of boundary functions for
-                        // the different boundary parts. We want the
-                                 // @p{function} to hold on all parts of the
-                                          // boundary
-                                          typename FunctionMap<dim>::type
-         boundary_functions; for (unsigned char c=0; c<255; ++c)
-                                          boundary_functions[c] = &function;
-                                          project_boundary_values (dof,
-         boundary_functions, q_boundary, boundary_values);
-      */
+      //   // set up a list of boundary functions for
+      //   // the different boundary parts. We want the
+      //   // @p{function} to hold on all parts of the
+      //   // boundary
+      //   std::map<types::boundary_id, const Function<dim>*>
+      //   boundary_functions; for (unsigned char c=0; c<255; ++c)
+      //     boundary_functions[c] = &function;
+      //     project_boundary_values (dof,
+      //   boundary_functions, q_boundary, boundary_values);
     }
 
 
index f6c32fc444058c194349dfc8e2c1d6d1f840456a..81c5c577157df2d8ef007a7407c14073541504a3 100644 (file)
@@ -503,11 +503,12 @@ namespace Step36
       face_quadrature_formula.push_back(QGauss<dim - 1>(3));
       face_quadrature_formula.push_back(QGauss<dim - 1>(3));
 
-      KellyErrorEstimator<dim>::estimate(dof_handler,
-                                         face_quadrature_formula,
-                                         typename FunctionMap<dim>::type(),
-                                         sol,
-                                         error);
+      KellyErrorEstimator<dim>::estimate(
+        dof_handler,
+        face_quadrature_formula,
+        std::map<types::boundary_id, const Function<dim> *>(),
+        sol,
+        error);
     }
 
     // sum up for a global:
index e56cb22beb2b8e28c3860e1ce60beaf85fb0d2d5..37f46fc3ddbdf2a7ff518a8bf8f3ac5663b9c684 100644 (file)
@@ -709,11 +709,12 @@ namespace Step36
       face_quadrature_formula.push_back(dealii::QGauss<dim - 1>(3));
       face_quadrature_formula.push_back(dealii::QGauss<dim - 1>(3));
 
-      KellyErrorEstimator<dim>::estimate(dof_handler,
-                                         face_quadrature_formula,
-                                         typename FunctionMap<dim>::type(),
-                                         sol,
-                                         error);
+      KellyErrorEstimator<dim>::estimate(
+        dof_handler,
+        face_quadrature_formula,
+        std::map<types::boundary_id, const Function<dim> *>(),
+        sol,
+        error);
     }
 
     // sum up for a global:
index 84087324a59aaa0a9c50e50003a6b36493ec0cd6..c46c057e4d470678c625473060231425e18982d1 100644 (file)
@@ -56,7 +56,11 @@ void check_this(Triangulation<3> &tria)
   VectorTools::interpolate(dof_handler, Functions::SquareFunction<3>(), u);
 
   KellyErrorEstimator<3>::estimate(
-    dof_handler, QGauss<2>(2), FunctionMap<3>::type(), u, e);
+    dof_handler,
+    QGauss<2>(2),
+    std::map<types::boundary_id, const Function<3> *>(),
+    u,
+    e);
 
   deallog << "  " << static_cast<double>(e.l1_norm()) << std::endl;
   deallog << "  " << static_cast<double>(e.l2_norm()) << std::endl;
index 05950c297f91faed38df8e35345886bb814dfbe2..00fe52aefde2d3f3ec33e623f47b49c66a6c8fa8 100644 (file)
@@ -98,8 +98,8 @@ check()
   hp::DoFHandler<dim> dof(tr);
   dof.distribute_dofs(element);
 
-  MySquareFunction<dim>           coefficient;
-  typename FunctionMap<dim>::type function_map;
+  MySquareFunction<dim>                               coefficient;
+  std::map<types::boundary_id, const Function<dim> *> function_map;
   function_map[0] = &coefficient;
 
   hp::QCollection<dim - 1> face_quadrature;
index 791824900bb0032e9aeed6b46c483157c37f2abf..d88763616e362dc0924fa941eb40f70ddcafc775 100644 (file)
@@ -118,8 +118,8 @@ check()
 
   dof.distribute_dofs(element);
 
-  MySquareFunction<dim>           coefficient;
-  typename FunctionMap<dim>::type function_map;
+  MySquareFunction<dim>                               coefficient;
+  std::map<types::boundary_id, const Function<dim> *> function_map;
   function_map[0] = &coefficient;
 
   hp::QCollection<dim - 1> face_quadrature;
index 53cefa97ab97d598da06a62ae5c719f815b5c912..477ac7fa4037d474faac7f53e45a52078440a188 100644 (file)
@@ -468,11 +468,12 @@ void
 LaplaceProblem<dim>::refine_grid()
 {
   Vector<float> estimated_error_per_cell(triangulation.n_active_cells());
-  KellyErrorEstimator<dim>::estimate(dof_handler,
-                                     face_quadrature_collection,
-                                     typename FunctionMap<dim>::type(),
-                                     solution,
-                                     estimated_error_per_cell);
+  KellyErrorEstimator<dim>::estimate(
+    dof_handler,
+    face_quadrature_collection,
+    std::map<types::boundary_id, const Function<dim> *>(),
+    solution,
+    estimated_error_per_cell);
 
   Vector<float> smoothness_indicators(triangulation.n_active_cells());
   estimate_smoothness(smoothness_indicators);
index 9e147af5b272efcdc4b71911419589e06358a1cb..7efc01c2700d48acbe75567429f2c5be2d5327c6 100644 (file)
@@ -473,11 +473,12 @@ void
 LaplaceProblem<dim>::refine_grid()
 {
   Vector<float> estimated_error_per_cell(triangulation.n_active_cells());
-  KellyErrorEstimator<dim>::estimate(dof_handler,
-                                     face_quadrature_collection,
-                                     typename FunctionMap<dim>::type(),
-                                     solution,
-                                     estimated_error_per_cell);
+  KellyErrorEstimator<dim>::estimate(
+    dof_handler,
+    face_quadrature_collection,
+    std::map<types::boundary_id, const Function<dim> *>(),
+    solution,
+    estimated_error_per_cell);
 
   Vector<float> smoothness_indicators(triangulation.n_active_cells());
   estimate_smoothness(smoothness_indicators);
index 32163b8275705ae1efb1f4b1d3fc0bd506a5846d..c636c673a5e8283984b0bcb96106a2837e527d7b 100644 (file)
@@ -78,8 +78,8 @@ void
 check_boundary(const hp::DoFHandler<dim> &       dof,
                const hp::MappingCollection<dim> &mapping)
 {
-  MySquareFunction<dim>           coefficient;
-  typename FunctionMap<dim>::type function_map;
+  MySquareFunction<dim>                               coefficient;
+  std::map<types::boundary_id, const Function<dim> *> function_map;
   function_map[0] = &coefficient;
 
   hp::QCollection<dim - 1> face_quadrature;
@@ -181,7 +181,7 @@ check()
 
   Functions::ExpFunction<dim> coefficient;
 
-  typename FunctionMap<dim>::type function_map;
+  std::map<types::boundary_id, const Function<dim> *> function_map;
   function_map[0] = &coefficient;
 
   for (unsigned int test = 0; test < 2; ++test)
index 5587fa7e03d534db654b517a53b6e08b9b65a00b..52ed9ea229f063f43fb0cd8a5cc5f929d04b26c4 100644 (file)
@@ -76,8 +76,8 @@ void
 check_boundary(const hp::DoFHandler<dim> &       dof,
                const hp::MappingCollection<dim> &mapping)
 {
-  MySquareFunction<dim>           coefficient;
-  typename FunctionMap<dim>::type function_map;
+  MySquareFunction<dim>                               coefficient;
+  std::map<types::boundary_id, const Function<dim> *> function_map;
   function_map[0] = &coefficient;
 
   hp::QCollection<dim - 1> face_quadrature;
@@ -193,7 +193,7 @@ check()
 
   Functions::ExpFunction<dim> coefficient;
 
-  typename FunctionMap<dim>::type function_map;
+  std::map<types::boundary_id, const Function<dim> *> function_map;
   function_map[0] = &coefficient;
 
   for (unsigned int test = 0; test < 2; ++test)
index 79f7337ee98a9c8abe287c05d4235113f89b2332..3f949b05248172afa8c1e6bf4b25a08e2eefeac8 100644 (file)
@@ -638,11 +638,12 @@ namespace LaplaceSolver
   {
     Vector<float> estimated_error_per_cell(
       this->triangulation->n_active_cells());
-    KellyErrorEstimator<dim>::estimate(this->dof_handler,
-                                       QGauss<dim - 1>(3),
-                                       typename FunctionMap<dim>::type(),
-                                       this->solution,
-                                       estimated_error_per_cell);
+    KellyErrorEstimator<dim>::estimate(
+      this->dof_handler,
+      QGauss<dim - 1>(3),
+      std::map<types::boundary_id, const Function<dim> *>(),
+      this->solution,
+      estimated_error_per_cell);
     GridRefinement::refine_and_coarsen_fixed_number(*this->triangulation,
                                                     estimated_error_per_cell,
                                                     0.3,
index d46b96a2b569ce517e26f68437082a6727c98b00..1c4ff31749aa6ff4b8dc444d0f4905cb8b9b4211 100644 (file)
@@ -288,11 +288,12 @@ namespace Step27
   LaplaceProblem<dim>::postprocess(const unsigned int cycle)
   {
     Vector<float> estimated_error_per_cell(triangulation.n_active_cells());
-    KellyErrorEstimator<dim>::estimate(dof_handler,
-                                       face_quadrature_collection,
-                                       typename FunctionMap<dim>::type(),
-                                       solution,
-                                       estimated_error_per_cell);
+    KellyErrorEstimator<dim>::estimate(
+      dof_handler,
+      face_quadrature_collection,
+      std::map<types::boundary_id, const Function<dim> *>(),
+      solution,
+      estimated_error_per_cell);
 
 
     Vector<float> smoothness_indicators(triangulation.n_active_cells());
index a1ebd8d816009a35d7a300bdaa8dd05b93dc7a45..3b3ae6b2534263d0b2b9db69139169d8a12c4e71 100644 (file)
@@ -293,11 +293,12 @@ LaplaceProblem<dim>::refine_grid()
 {
   Vector<float> estimated_error_per_cell(triangulation.n_active_cells());
 
-  KellyErrorEstimator<dim>::estimate(dof_handler,
-                                     QGauss<dim - 1>(3),
-                                     typename FunctionMap<dim>::type(),
-                                     solution,
-                                     estimated_error_per_cell);
+  KellyErrorEstimator<dim>::estimate(
+    dof_handler,
+    QGauss<dim - 1>(3),
+    std::map<types::boundary_id, const Function<dim> *>(),
+    solution,
+    estimated_error_per_cell);
 
   GridRefinement::refine_and_coarsen_fixed_number(triangulation,
                                                   estimated_error_per_cell,
index 4f026c12ebe23a2ee2cf3d211f711b2f48236815..927ce0cbc97924be6a927278ea74f8477f0e15eb 100644 (file)
@@ -415,7 +415,7 @@ HelmholtzProblem<dim>::refine_grid()
           Vector<float> estimated_error_per_cell(
             triangulation.n_active_cells());
 
-          typename FunctionMap<dim>::type neumann_boundary;
+          std::map<types::boundary_id, const Function<dim> *> neumann_boundary;
           KellyErrorEstimator<dim>::estimate(dof_handler,
                                              QGauss<dim - 1>(3),
                                              neumann_boundary,
index c2f5214f967a9fcc9a4bcfd2fee2d4cb77f835cc..8ffd7f63f8d1f045ed2aa96afd5c991109b075f9 100644 (file)
@@ -336,7 +336,7 @@ ElasticProblem<dim>::refine_grid()
 {
   Vector<float> estimated_error_per_cell(triangulation.n_active_cells());
 
-  typename FunctionMap<dim>::type neumann_boundary;
+  std::map<types::boundary_id, const Function<dim> *> neumann_boundary;
   KellyErrorEstimator<dim>::estimate(dof_handler,
                                      QGauss<dim - 1>(2),
                                      neumann_boundary,
index d1c94e1e98c891fb9ac59190b92f27ec24ccca2f..22626b32b3901ac1386f90229a470a6fba1b66f9 100644 (file)
@@ -214,11 +214,12 @@ Step6<dim>::refine_grid()
 {
   Vector<float> estimated_error_per_cell(triangulation.n_active_cells());
 
-  KellyErrorEstimator<dim>::estimate(dof_handler,
-                                     QGauss<dim - 1>(3),
-                                     typename FunctionMap<dim>::type(),
-                                     solution,
-                                     estimated_error_per_cell);
+  KellyErrorEstimator<dim>::estimate(
+    dof_handler,
+    QGauss<dim - 1>(3),
+    std::map<types::boundary_id, const Function<dim> *>(),
+    solution,
+    estimated_error_per_cell);
 
   GridRefinement::refine_and_coarsen_fixed_number(triangulation,
                                                   estimated_error_per_cell,
index 47889d45cdc8b33834f4a20faf4a83f1ab7d13c9..ea00c8e942a55b9ef6315e7de1442011adadfdcf 100644 (file)
@@ -72,8 +72,8 @@ template <int dim>
 void
 check_boundary(const DoFHandler<dim> &dof, const Mapping<dim> &mapping)
 {
-  MySquareFunction<dim>           coefficient;
-  typename FunctionMap<dim>::type function_map;
+  MySquareFunction<dim>                               coefficient;
+  std::map<types::boundary_id, const Function<dim> *> function_map;
   function_map[0] = &coefficient;
 
   QGauss<dim - 1> face_quadrature(6);
@@ -170,7 +170,7 @@ check()
 
   Functions::ExpFunction<dim> coefficient;
 
-  typename FunctionMap<dim>::type function_map;
+  std::map<types::boundary_id, const Function<dim> *> function_map;
   function_map[0] = &coefficient;
 
   for (unsigned int test = 0; test < 2; ++test)
index 74959d03d1b613d8d2bd00776fd35b83e36c6e0d..adb229dd798ae693ab9d276069d1fa10bba4a764 100644 (file)
@@ -344,12 +344,13 @@ namespace Step22
   {
     Vector<float> estimated_error_per_cell(triangulation.n_active_cells());
     FEValuesExtractors::Scalar pressure(dim);
-    KellyErrorEstimator<dim>::estimate(dof_handler,
-                                       QGauss<dim - 1>(degree + 1),
-                                       typename FunctionMap<dim>::type(),
-                                       solution,
-                                       estimated_error_per_cell,
-                                       fe.component_mask(pressure));
+    KellyErrorEstimator<dim>::estimate(
+      dof_handler,
+      QGauss<dim - 1>(degree + 1),
+      std::map<types::boundary_id, const Function<dim> *>(),
+      solution,
+      estimated_error_per_cell,
+      fe.component_mask(pressure));
     GridRefinement::refine_and_coarsen_fixed_number(triangulation,
                                                     estimated_error_per_cell,
                                                     0.3,
index 5caa72a2bb9be3f0954bad26446431a1ab41f61f..924c4c67ce21304e6762850c77582087d20a1a23 100644 (file)
@@ -96,8 +96,8 @@ test()
   mg_sparsities.resize(0, nlevels - 1);
   mg_ref_matrices.resize(0, nlevels - 1);
 
-  typename FunctionMap<dim>::type dirichlet_boundary;
-  Functions::ZeroFunction<dim>    homogeneous_dirichlet_bc(1);
+  std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
+  Functions::ZeroFunction<dim> homogeneous_dirichlet_bc(1);
   dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
   std::vector<std::set<types::global_dof_index>> boundary_indices(nlevels);
   MGTools::make_boundary_list(dof, dirichlet_boundary, boundary_indices);
index e2cdea288a1d4c675d4b98cd012e06ba0ab16bf4..667f541e7128dcd6c303258e86513f3c6696e52a 100644 (file)
@@ -587,9 +587,9 @@ 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;
-  typename FunctionMap<dim>::type dirichlet_boundary;
+  MGConstrainedDoFs                                   mg_constrained_dofs;
+  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);
 
index 83033d4ab88000d73fbb1134bf98a4d52ffd70fa..fff021fc33e66962c67087c3d28e93a692b381a0 100644 (file)
@@ -499,9 +499,9 @@ 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;
-  typename FunctionMap<dim>::type dirichlet_boundary;
+  MGConstrainedDoFs                                   mg_constrained_dofs;
+  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);
 
index db115e4ef5ab88518286c945503ae6f5cef693c0..6ce47e6de538602c722eb87827ee3b9fee7ab065 100644 (file)
@@ -74,9 +74,9 @@ public:
     addit_data.level_mg_handler = level;
 
     // extract the constraints due to Dirichlet boundary conditions
-    ConstraintMatrix                constraints;
-    Functions::ZeroFunction<dim>    zero;
-    typename FunctionMap<dim>::type functions;
+    ConstraintMatrix                                    constraints;
+    Functions::ZeroFunction<dim>                        zero;
+    std::map<types::boundary_id, const Function<dim> *> functions;
     for (std::set<types::boundary_id>::const_iterator it =
            dirichlet_boundaries.begin();
          it != dirichlet_boundaries.end();
index 3bce17bd069e1f1b5858801cdf6d4a47ce031cb6..9312e9252bb8ef7e13dcce997c497d135ecb8e3d 100644 (file)
@@ -103,8 +103,8 @@ do_test(const DoFHandler<dim> &dof)
   DoFTools::extract_locally_relevant_dofs(dof, locally_relevant_dofs);
 
   // Dirichlet BC
-  Functions::ZeroFunction<dim>    zero_function;
-  typename FunctionMap<dim>::type dirichlet_boundary;
+  Functions::ZeroFunction<dim>                        zero_function;
+  std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
   dirichlet_boundary[0] = &zero_function;
 
   // fine-level constraints
index ac54052996c7deff5820981575d14b1cc4cfcb53..a442e78faeff126bc561be49bdaa03942cca3fdc 100644 (file)
@@ -63,10 +63,11 @@ public:
 
 
   void
-  initialize(const Mapping<dim> &                   mapping,
-             const DoFHandler<dim> &                dof_handler,
-             const MGConstrainedDoFs &              mg_constrained_dofs,
-             const typename FunctionMap<dim>::type &dirichlet_boundary,
+  initialize(const Mapping<dim> &     mapping,
+             const DoFHandler<dim> &  dof_handler,
+             const MGConstrainedDoFs &mg_constrained_dofs,
+             const std::map<types::boundary_id, const Function<dim> *>
+               &                dirichlet_boundary,
              const unsigned int level = numbers::invalid_unsigned_int)
   {
     const QGauss<1>                                  quad(n_q_points_1d);
@@ -513,9 +514,9 @@ do_test(const DoFHandler<dim> &dof)
   DoFTools::make_hanging_node_constraints(dof, hanging_node_constraints);
   hanging_node_constraints.close();
 
-  MGConstrainedDoFs               mg_constrained_dofs;
-  Functions::ZeroFunction<dim>    zero_function;
-  typename FunctionMap<dim>::type dirichlet_boundary;
+  MGConstrainedDoFs                                   mg_constrained_dofs;
+  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);
 
index 5c6f098682381967900f30041128f544a49358ed..b79b59854eef374b51344e3803c96bff7a1956e5 100644 (file)
@@ -140,8 +140,8 @@ do_test(const DoFHandler<dim> &dof)
   DoFTools::extract_locally_relevant_dofs(dof, locally_relevant_dofs);
 
   // Dirichlet BC
-  Functions::ZeroFunction<dim>    zero_function;
-  typename FunctionMap<dim>::type dirichlet_boundary;
+  Functions::ZeroFunction<dim>                        zero_function;
+  std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
   dirichlet_boundary[0] = &zero_function;
 
   // fine-level constraints
index dbec01a1eda7df11a62ea763b8ae1b1d77def81c..e0c1c840d1ddfe7b5e821641512a81c1dbcee7b4 100644 (file)
@@ -64,12 +64,13 @@ public:
 
 
   void
-  initialize(const Mapping<dim> &                   mapping,
-             const DoFHandler<dim> &                dof_handler,
-             const MGConstrainedDoFs &              mg_constrained_dofs,
-             const typename FunctionMap<dim>::type &dirichlet_boundary,
-             const unsigned int                     level,
-             const bool                             threaded)
+  initialize(const Mapping<dim> &     mapping,
+             const DoFHandler<dim> &  dof_handler,
+             const MGConstrainedDoFs &mg_constrained_dofs,
+             const std::map<types::boundary_id, const Function<dim> *>
+               &                dirichlet_boundary,
+             const unsigned int level,
+             const bool         threaded)
   {
     const QGauss<1>                                  quad(n_q_points_1d);
     typename MatrixFree<dim, number>::AdditionalData addit_data;
@@ -520,9 +521,9 @@ do_test(const DoFHandler<dim> &dof, const bool threaded)
   DoFTools::make_hanging_node_constraints(dof, hanging_node_constraints);
   hanging_node_constraints.close();
 
-  MGConstrainedDoFs               mg_constrained_dofs;
-  Functions::ZeroFunction<dim>    zero_function;
-  typename FunctionMap<dim>::type dirichlet_boundary;
+  MGConstrainedDoFs                                   mg_constrained_dofs;
+  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);
 
index 4be60970b59f589825656929a4dbb2017ed87aba..ea1345a99aa9f0beeb255bac942ac368066dcca0 100644 (file)
@@ -140,8 +140,8 @@ do_test(const DoFHandler<dim> &dof)
   DoFTools::extract_locally_relevant_dofs(dof, locally_relevant_dofs);
 
   // Dirichlet BC
-  Functions::ZeroFunction<dim>    zero_function;
-  typename FunctionMap<dim>::type dirichlet_boundary;
+  Functions::ZeroFunction<dim>                        zero_function;
+  std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
   dirichlet_boundary[0] = &zero_function;
 
   // fine-level constraints
index c29cce44f545c4f83cdcf7e19de555d2ca561ec4..2730c4ee43bc9b7fde92f6ddf9bd3cdb801c34be 100644 (file)
@@ -61,12 +61,13 @@ public:
 
 
   void
-  initialize(const Mapping<dim> &                   mapping,
-             const DoFHandler<dim> &                dof_handler,
-             const MGConstrainedDoFs &              mg_constrained_dofs,
-             const typename FunctionMap<dim>::type &dirichlet_boundary,
-             const unsigned int                     level,
-             const bool                             threaded)
+  initialize(const Mapping<dim> &     mapping,
+             const DoFHandler<dim> &  dof_handler,
+             const MGConstrainedDoFs &mg_constrained_dofs,
+             const std::map<types::boundary_id, const Function<dim> *>
+               &                dirichlet_boundary,
+             const unsigned int level,
+             const bool         threaded)
   {
     const QGauss<1>                                  quad(n_q_points_1d);
     typename MatrixFree<dim, number>::AdditionalData addit_data;
@@ -517,9 +518,9 @@ do_test(const DoFHandler<dim> &dof, const bool threaded)
   DoFTools::make_hanging_node_constraints(dof, hanging_node_constraints);
   hanging_node_constraints.close();
 
-  MGConstrainedDoFs               mg_constrained_dofs;
-  Functions::ZeroFunction<dim>    zero_function;
-  typename FunctionMap<dim>::type dirichlet_boundary;
+  MGConstrainedDoFs                                   mg_constrained_dofs;
+  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);
 
index 9c3abe3fdb644a00b65cd5fa2be7c250abcd7696..53b6296ce42fb4bbb58b1602cc74615f8231ab42 100644 (file)
@@ -225,8 +225,8 @@ 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;
-  typename FunctionMap<dim>::type dirichlet_boundary;
+  ZeroFunction<dim>                                   zero_function;
+  std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
   dirichlet_boundary[0] = &zero_function;
 
   // fine-level constraints
index 73741568dc208e82ce8e5cb199dcd64f9ae06b34..22069eea5cd29e0ad632521e4c646d9a23c4ca8b 100644 (file)
@@ -141,8 +141,8 @@ do_test(const DoFHandler<dim> &dof)
   DoFTools::extract_locally_relevant_dofs(dof, locally_relevant_dofs);
 
   // Dirichlet BC
-  ZeroFunction<dim>               zero_function;
-  typename FunctionMap<dim>::type dirichlet_boundary;
+  ZeroFunction<dim>                                   zero_function;
+  std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
   dirichlet_boundary[0] = &zero_function;
 
   // fine-level constraints
index 07d67350f1a8dc9771aca486fb8fc1ea3841480e..bffdaff1295f6b146c3f9fb95f14a64551319f5f 100644 (file)
@@ -243,8 +243,8 @@ 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;
-  typename FunctionMap<dim>::type dirichlet_boundary;
+  ZeroFunction<dim>                                   zero_function;
+  std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
   dirichlet_boundary[0] = &zero_function;
 
   // fine-level constraints
index 66725235130c53936e108e815c897f1047d92b4b..3c15b1deb8b266582e7263943ff334cbf36b8377 100644 (file)
@@ -73,9 +73,9 @@ public:
     addit_data.level_mg_handler = level;
 
     // extract the constraints due to Dirichlet boundary conditions
-    ConstraintMatrix                constraints;
-    Functions::ZeroFunction<dim>    zero;
-    typename FunctionMap<dim>::type functions;
+    ConstraintMatrix                                    constraints;
+    Functions::ZeroFunction<dim>                        zero;
+    std::map<types::boundary_id, const Function<dim> *> functions;
     for (std::set<types::boundary_id>::const_iterator it =
            dirichlet_boundaries.begin();
          it != dirichlet_boundaries.end();
@@ -375,9 +375,9 @@ do_test(const DoFHandler<dim> &dof)
       mg_matrices[level].initialize(mapping, dof, dirichlet_boundaries, level);
     }
 
-  MGConstrainedDoFs               mg_constrained_dofs;
-  Functions::ZeroFunction<dim>    zero_function;
-  typename FunctionMap<dim>::type dirichlet_boundary;
+  MGConstrainedDoFs                                   mg_constrained_dofs;
+  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);
 
index 882e517b6f70de1619d49d36b584c5217cadef3c..903734f5d06569e9ee722ed8c5d35b96bf1f4866 100644 (file)
@@ -436,8 +436,8 @@ namespace Step37
     mg_matrices.resize(0, nlevels - 1);
     mg_constraints.resize(0, nlevels - 1);
 
-    typename FunctionMap<dim>::type dirichlet_boundary;
-    Functions::ZeroFunction<dim>    homogeneous_dirichlet_bc(1);
+    std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
+    Functions::ZeroFunction<dim> homogeneous_dirichlet_bc(1);
     dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
     std::vector<std::set<types::global_dof_index>> boundary_indices(
       triangulation.n_levels());
index 0017ec5af767619bdc98e0e08effc06b22d00339..4db1310b9d77547aab8516797362889c9906a96e 100644 (file)
@@ -244,8 +244,8 @@ namespace Step50
     constraints.reinit(locally_relevant_set);
     DoFTools::make_hanging_node_constraints(mg_dof_handler, constraints);
 
-    std::set<types::boundary_id>     dirichlet_boundary_ids;
-    typename FunctionMap<dim>::type  dirichlet_boundary;
+    std::set<types::boundary_id>                        dirichlet_boundary_ids;
+    std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
     Functions::ConstantFunction<dim> homogeneous_dirichlet_bc(1.0);
     dirichlet_boundary_ids.insert(0);
     dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
index 415057ca73596987b110276f1d6f6b08eeb98194..df29a858e71e3e18bc58a14582b6e76f3c91c66b 100644 (file)
@@ -247,11 +247,12 @@ SeventhProblem<dim>::run(unsigned int cycle)
   else
     {
       Vector<float> estimated_error_per_cell(triangulation.n_active_cells());
-      KellyErrorEstimator<dim>::estimate(dof_handler,
-                                         QGauss<dim - 1>(3),
-                                         typename FunctionMap<dim>::type(),
-                                         locally_relevant_solution,
-                                         estimated_error_per_cell);
+      KellyErrorEstimator<dim>::estimate(
+        dof_handler,
+        QGauss<dim - 1>(3),
+        std::map<types::boundary_id, const Function<dim> *>(),
+        locally_relevant_solution,
+        estimated_error_per_cell);
 
       parallel::distributed::GridRefinement::refine_and_coarsen_fixed_number(
         triangulation, estimated_error_per_cell, 0.5, 0.3);
index 82151d581e60c6f77533900cf51ad98cc1b0218d..aee894f8d5e9c9fc91bbfede193e453ca6cf0ca1 100644 (file)
@@ -718,12 +718,13 @@ namespace Step22
     Vector<float> estimated_error_per_cell(triangulation.n_active_cells());
 
     FEValuesExtractors::Scalar pressure(dim);
-    KellyErrorEstimator<dim>::estimate(dof_handler,
-                                       QGauss<dim - 1>(degree + 1),
-                                       typename FunctionMap<dim>::type(),
-                                       solution,
-                                       estimated_error_per_cell,
-                                       fe.component_mask(pressure));
+    KellyErrorEstimator<dim>::estimate(
+      dof_handler,
+      QGauss<dim - 1>(degree + 1),
+      std::map<types::boundary_id, const Function<dim> *>(),
+      solution,
+      estimated_error_per_cell,
+      fe.component_mask(pressure));
 
     parallel::distributed::GridRefinement::refine_and_coarsen_fixed_number(
       triangulation, estimated_error_per_cell, 0.3, 0.0);
index 877acb441cd65f93b5f79567954c9205b9ae6395..03ccf5c231a18568fd30dc1b9c295a43779ce49e 100644 (file)
@@ -193,8 +193,8 @@ namespace Step50
     constraints.clear();
     DoFTools::make_hanging_node_constraints(mg_dof_handler, constraints);
 
-    typename FunctionMap<dim>::type dirichlet_boundary;
-    Functions::ZeroFunction<dim>    homogeneous_dirichlet_bc(1);
+    std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
+    Functions::ZeroFunction<dim> homogeneous_dirichlet_bc(1);
     dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
     VectorTools::interpolate_boundary_values(
       static_cast<const DoFHandler<dim> &>(mg_dof_handler),
@@ -461,12 +461,12 @@ namespace Step50
     temp_solution.reinit(idx, MPI_COMM_WORLD);
     temp_solution = solution;
 
-    KellyErrorEstimator<dim>::estimate(static_cast<DoFHandler<dim> &>(
-                                         mg_dof_handler),
-                                       QGauss<dim - 1>(3),
-                                       typename FunctionMap<dim>::type(),
-                                       temp_solution,
-                                       estimated_error_per_cell);
+    KellyErrorEstimator<dim>::estimate(
+      mg_dof_handler,
+      QGauss<dim - 1>(3),
+      std::map<types::boundary_id, const Function<dim> *>(),
+      temp_solution,
+      estimated_error_per_cell);
     GridRefinement::refine_and_coarsen_fixed_number(triangulation,
                                                     estimated_error_per_cell,
                                                     0.3,
index 75a14149bf6bec93ac98e8b95c97bedca255ef02..8b46436162c1af70d783028969ca565e23551ee5 100644 (file)
@@ -193,8 +193,8 @@ namespace Step50
     constraints.clear();
     DoFTools::make_hanging_node_constraints(mg_dof_handler, constraints);
 
-    typename FunctionMap<dim>::type dirichlet_boundary;
-    Functions::ZeroFunction<dim>    homogeneous_dirichlet_bc(1);
+    std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
+    Functions::ZeroFunction<dim> homogeneous_dirichlet_bc(1);
     dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
     VectorTools::interpolate_boundary_values(
       static_cast<const DoFHandler<dim> &>(mg_dof_handler),
@@ -442,12 +442,12 @@ namespace Step50
   {
     Vector<float> estimated_error_per_cell(triangulation.n_active_cells());
 
-    KellyErrorEstimator<dim>::estimate(static_cast<DoFHandler<dim> &>(
-                                         mg_dof_handler),
-                                       QGauss<dim - 1>(3),
-                                       typename FunctionMap<dim>::type(),
-                                       solution,
-                                       estimated_error_per_cell);
+    KellyErrorEstimator<dim>::estimate(
+      mg_dof_handler,
+      QGauss<dim - 1>(3),
+      std::map<types::boundary_id, const Function<dim> *>(),
+      solution,
+      estimated_error_per_cell);
     GridRefinement::refine_and_coarsen_fixed_number(triangulation,
                                                     estimated_error_per_cell,
                                                     0.3,
index 0687bbe4fc051fae789c87e517c24a9da48077c7..004c0939685cfd74024aa5a4ac380478dcdd8fcd 100644 (file)
@@ -296,11 +296,12 @@ namespace Step40
   LaplaceProblem<dim>::refine_grid()
   {
     Vector<float> estimated_error_per_cell(triangulation.n_active_cells());
-    KellyErrorEstimator<dim>::estimate(dof_handler,
-                                       QGauss<dim - 1>(3),
-                                       typename FunctionMap<dim>::type(),
-                                       locally_relevant_solution,
-                                       estimated_error_per_cell);
+    KellyErrorEstimator<dim>::estimate(
+      dof_handler,
+      QGauss<dim - 1>(3),
+      std::map<types::boundary_id, const Function<dim> *>(),
+      locally_relevant_solution,
+      estimated_error_per_cell);
     parallel::distributed::GridRefinement::refine_and_coarsen_fixed_number(
       triangulation, estimated_error_per_cell, 0.3, 0.03);
 
index 6462e91ce1e6be52e82f6f57ee83740c8ed6c4cf..21678b1cf9fd12e69ca1f5e9fa1ab19cfb8cefd8 100644 (file)
@@ -727,12 +727,13 @@ namespace Step22
     Vector<float> estimated_error_per_cell(triangulation.n_active_cells());
 
     FEValuesExtractors::Scalar pressure(dim);
-    KellyErrorEstimator<dim>::estimate(dof_handler,
-                                       QGauss<dim - 1>(degree + 1),
-                                       typename FunctionMap<dim>::type(),
-                                       solution,
-                                       estimated_error_per_cell,
-                                       fe.component_mask(pressure));
+    KellyErrorEstimator<dim>::estimate(
+      dof_handler,
+      QGauss<dim - 1>(degree + 1),
+      std::map<types::boundary_id, const Function<dim> *>(),
+      solution,
+      estimated_error_per_cell,
+      fe.component_mask(pressure));
 
     // Note: this test does
     parallel::distributed::GridRefinement::refine_and_coarsen_fixed_number(
index 33cbcff451a0a88dea258d08864be6c3e4d4d30d..b68fbcd68b83bee36149b048dd5db47a9b9eda2d 100644 (file)
@@ -814,12 +814,13 @@ namespace Step22
     Vector<float> estimated_error_per_cell(triangulation.n_active_cells());
 
     FEValuesExtractors::Scalar pressure(dim);
-    KellyErrorEstimator<dim>::estimate(dof_handler,
-                                       QGauss<dim - 1>(degree + 1),
-                                       typename FunctionMap<dim>::type(),
-                                       solution,
-                                       estimated_error_per_cell,
-                                       fe.component_mask(pressure));
+    KellyErrorEstimator<dim>::estimate(
+      dof_handler,
+      QGauss<dim - 1>(degree + 1),
+      std::map<types::boundary_id, const Function<dim> *>(),
+      solution,
+      estimated_error_per_cell,
+      fe.component_mask(pressure));
 
     parallel::distributed::GridRefinement::refine_and_coarsen_fixed_number(
       triangulation, estimated_error_per_cell, 0.3, 0.0);
index 1e8ea85fe82c15a91a03c6f039e51c9fa6852886..b4419174297ad1e5e8a06246909386a0abdc18c8 100644 (file)
@@ -327,9 +327,10 @@ namespace Step37
       DoFTools::make_hanging_node_constraints(
         dof_handler, hanging_nodes_laplace_constraints);
 
-      std::set<types::boundary_id>    dirichlet_boundary_ids;
-      typename FunctionMap<dim>::type dirichlet_boundary_functions;
-      PotentialBCFunction<dim>        bc_func(240, Point<dim>());
+      std::set<types::boundary_id> dirichlet_boundary_ids;
+      std::map<types::boundary_id, const Function<dim> *>
+                               dirichlet_boundary_functions;
+      PotentialBCFunction<dim> bc_func(240, Point<dim>());
       dirichlet_boundary_ids.insert(0);
       dirichlet_boundary_functions[0] = &bc_func;
       VectorTools::interpolate_boundary_values(*mapping.get(),
index c5134005612cf050333e3eb8d1c4efbd385b7908..2a0644022d74d0e8c6f7fa5fcd0812244f983e66 100644 (file)
@@ -98,8 +98,8 @@ test()
   cm.reinit(locally_relevant_set);
   DoFTools::make_hanging_node_constraints(dofh, cm);
 
-  typename FunctionMap<dim>::type dirichlet_boundary;
-  Functions::ZeroFunction<dim>    homogeneous_dirichlet_bc(1);
+  std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
+  Functions::ZeroFunction<dim> homogeneous_dirichlet_bc(1);
   dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
   VectorTools::interpolate_boundary_values(dofh, dirichlet_boundary, cm);
 
index e1877fa02f5a7ac318b15745efa7945170d8df54..59dfab1064e59e53ce50d8228f6860062f7876f1 100644 (file)
@@ -19,7 +19,6 @@
 #include <deal.II/base/function.h>
 
 #include <deal.II/dofs/dof_accessor.h>
-#include <deal.II/dofs/function_map.h>
 
 #include <deal.II/fe/fe_dgq.h>
 #include <deal.II/fe/fe_q.h>
@@ -67,8 +66,8 @@ check_fe(FiniteElement<dim> &fe)
   Triangulation<dim> tr(Triangulation<dim>::limit_level_difference_at_vertices);
   GridGenerator::hyper_cube(tr);
   tr.refine_global(2);
-  Functions::ZeroFunction<dim>    zero;
-  typename FunctionMap<dim>::type fmap;
+  Functions::ZeroFunction<dim>                        zero;
+  std::map<types::boundary_id, const Function<dim> *> fmap;
   fmap.insert(std::make_pair(0, &zero));
 
   DoFHandler<dim> mgdof(tr);
index 26ad58a5a30e99888fd83f943bcc0ebe17e2dfd5..5b9a828415bd011e436a7b60346fa0198b73e147 100644 (file)
@@ -21,7 +21,6 @@
 #include <deal.II/distributed/tria.h>
 
 #include <deal.II/dofs/dof_accessor.h>
-#include <deal.II/dofs/function_map.h>
 
 #include <deal.II/fe/fe_dgq.h>
 #include <deal.II/fe/fe_q.h>
@@ -75,8 +74,8 @@ check_fe(FiniteElement<dim> &fe)
     parallel::distributed::Triangulation<dim>::construct_multigrid_hierarchy);
   setup_tria(tr);
 
-  Functions::ZeroFunction<dim>    zero;
-  typename FunctionMap<dim>::type fmap;
+  Functions::ZeroFunction<dim>                        zero;
+  std::map<types::boundary_id, const Function<dim> *> fmap;
   fmap.insert(std::make_pair(0, &zero));
 
   DoFHandler<dim> dofh(tr);
@@ -125,8 +124,8 @@ check_fe(FiniteElement<dim> &fe)
         cell->update_cell_dof_indices_cache();
       }
 
-    typename FunctionMap<dim>::type dirichlet_boundary;
-    Functions::ZeroFunction<dim>    homogeneous_dirichlet_bc(1);
+    std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
+    Functions::ZeroFunction<dim> homogeneous_dirichlet_bc(1);
     dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
     mg_constrained_dofs_ref.initialize(dofhref, dirichlet_boundary);
   }
@@ -135,8 +134,8 @@ check_fe(FiniteElement<dim> &fe)
 
   MGConstrainedDoFs mg_constrained_dofs;
 
-  typename FunctionMap<dim>::type dirichlet_boundary;
-  Functions::ZeroFunction<dim>    homogeneous_dirichlet_bc(1);
+  std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
+  Functions::ZeroFunction<dim> homogeneous_dirichlet_bc(1);
   dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
   mg_constrained_dofs.initialize(dofh, dirichlet_boundary);
 
index bc004182cb2fbf9c59d647ee8f94718a703ade96..ce3848b73e804daba58800768898413b9d9c7072 100644 (file)
@@ -21,7 +21,6 @@
 #include <deal.II/distributed/tria.h>
 
 #include <deal.II/dofs/dof_accessor.h>
-#include <deal.II/dofs/function_map.h>
 
 #include <deal.II/fe/fe_dgq.h>
 #include <deal.II/fe/fe_q.h>
@@ -136,8 +135,8 @@ check_fe(FiniteElement<dim> &fe)
     parallel::distributed::Triangulation<dim>::construct_multigrid_hierarchy);
   setup_tria(tr);
 
-  Functions::ZeroFunction<dim>    zero;
-  typename FunctionMap<dim>::type fmap;
+  Functions::ZeroFunction<dim>                        zero;
+  std::map<types::boundary_id, const Function<dim> *> fmap;
   fmap.insert(std::make_pair(0, &zero));
 
   DoFHandler<dim> dofh(tr);
@@ -186,8 +185,8 @@ check_fe(FiniteElement<dim> &fe)
         cell->update_cell_dof_indices_cache();
       }
 
-    typename FunctionMap<dim>::type dirichlet_boundary;
-    Functions::ZeroFunction<dim>    homogeneous_dirichlet_bc(1);
+    std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
+    Functions::ZeroFunction<dim> homogeneous_dirichlet_bc(1);
     dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
     mg_constrained_dofs_ref.initialize(dofhref, dirichlet_boundary);
   }
@@ -196,8 +195,8 @@ check_fe(FiniteElement<dim> &fe)
 
   MGConstrainedDoFs mg_constrained_dofs;
 
-  typename FunctionMap<dim>::type dirichlet_boundary;
-  Functions::ZeroFunction<dim>    homogeneous_dirichlet_bc(1);
+  std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
+  Functions::ZeroFunction<dim> homogeneous_dirichlet_bc(1);
   dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
   mg_constrained_dofs.initialize(dofh, dirichlet_boundary);
 
index 848536c2706cd1a896ab576df9e58d919e5d6672..177995219950d38738c3976b7e1bcbd3d6af73a2 100644 (file)
@@ -21,7 +21,6 @@
 #include <deal.II/distributed/tria.h>
 
 #include <deal.II/dofs/dof_accessor.h>
-#include <deal.II/dofs/function_map.h>
 
 #include <deal.II/fe/fe_dgq.h>
 #include <deal.II/fe/fe_q.h>
index 11b26a4aafbbedcb4c963c81fe7ea4e00f3393d8..ffa4fe1065fac3f099be84ab3d07379ec9d33f94 100644 (file)
@@ -19,7 +19,6 @@
 #include <deal.II/base/function.h>
 
 #include <deal.II/dofs/dof_accessor.h>
-#include <deal.II/dofs/function_map.h>
 
 #include <deal.II/fe/fe_dgq.h>
 #include <deal.II/fe/fe_q.h>
@@ -77,8 +76,8 @@ check_fe(FiniteElement<dim> &fe)
   Triangulation<dim> tr(Triangulation<dim>::limit_level_difference_at_vertices);
   GridGenerator::hyper_cube(tr);
   tr.refine_global(2);
-  Functions::ZeroFunction<dim>    zero;
-  typename FunctionMap<dim>::type fmap;
+  Functions::ZeroFunction<dim>                        zero;
+  std::map<types::boundary_id, const Function<dim> *> fmap;
   fmap.insert(std::make_pair(0, &zero));
 
   DoFHandler<dim> mgdof(tr);
index f60e2b3ca1b650b62b082fba6cddc531d1e45f44..2cf428a05d158dea763e3f3754b48c441ae1412e 100644 (file)
@@ -19,7 +19,6 @@
 #include <deal.II/base/function.h>
 
 #include <deal.II/dofs/dof_accessor.h>
-#include <deal.II/dofs/function_map.h>
 
 #include <deal.II/fe/fe_dgq.h>
 #include <deal.II/fe/fe_q.h>
@@ -83,8 +82,8 @@ check_fe(FiniteElement<dim> &fe)
   Triangulation<dim> tr(Triangulation<dim>::limit_level_difference_at_vertices);
   GridGenerator::hyper_cube(tr);
   tr.refine_global(2);
-  Functions::ZeroFunction<dim>    zero;
-  typename FunctionMap<dim>::type fmap;
+  Functions::ZeroFunction<dim>                        zero;
+  std::map<types::boundary_id, const Function<dim> *> fmap;
   fmap.insert(std::make_pair(0, &zero));
 
   DoFHandler<dim> mgdof(tr);
index 0f65791191bbd331fe413f47e4ed9219f5bd2478..d0492f2b7f88ba1ad5d7626d04cabe662b5045f9 100644 (file)
@@ -154,7 +154,7 @@ namespace Step50
     constraints.reinit(locally_relevant_set);
     DoFTools::make_hanging_node_constraints(mg_dof_handler, constraints);
 
-    typename FunctionMap<dim>::type  dirichlet_boundary;
+    std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
     Functions::ConstantFunction<dim> homogeneous_dirichlet_bc(0.0);
     dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
     VectorTools::interpolate_boundary_values(mg_dof_handler,
@@ -500,12 +500,12 @@ namespace Step50
     temp_solution.reinit(locally_relevant_set, MPI_COMM_WORLD);
     temp_solution = solution;
 
-    KellyErrorEstimator<dim>::estimate(static_cast<DoFHandler<dim> &>(
-                                         mg_dof_handler),
-                                       QGauss<dim - 1>(degree + 1),
-                                       typename FunctionMap<dim>::type(),
-                                       temp_solution,
-                                       estimated_error_per_cell);
+    KellyErrorEstimator<dim>::estimate(
+      mg_dof_handler,
+      QGauss<dim - 1>(degree + 1),
+      std::map<types::boundary_id, const Function<dim> *>(),
+      temp_solution,
+      estimated_error_per_cell);
 
     parallel::distributed::GridRefinement::refine_and_coarsen_fixed_fraction(
       triangulation, estimated_error_per_cell, 0.3, 0.0);
index 97ca541e83cb5a6d010bc535bd16701a0d3ea1b4..80a8370fda9de2a7fb79931bce10ef6f5a7833de 100644 (file)
@@ -95,8 +95,8 @@ test()
   constraints.reinit(locally_relevant_set);
   DoFTools::make_hanging_node_constraints(mg_dof_handler, constraints);
 
-  std::set<types::boundary_id>     dirichlet_boundary_ids;
-  typename FunctionMap<dim>::type  dirichlet_boundary;
+  std::set<types::boundary_id>                        dirichlet_boundary_ids;
+  std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
   Functions::ConstantFunction<dim> homogeneous_dirichlet_bc(0.0);
   dirichlet_boundary_ids.insert(0);
   dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
index ff4a19f265cf11c558e8978ca825c31951247dc9..b3b7b82d57aa99dfabed211dd457b6018fd8168d 100644 (file)
@@ -211,7 +211,7 @@ namespace Step50
     constraints.reinit(locally_relevant_set);
     DoFTools::make_hanging_node_constraints(mg_dof_handler, constraints);
 
-    typename FunctionMap<dim>::type  dirichlet_boundary;
+    std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
     Functions::ConstantFunction<dim> homogeneous_dirichlet_bc(0.0);
     dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
     VectorTools::interpolate_boundary_values(mg_dof_handler,
@@ -587,12 +587,12 @@ namespace Step50
     temp_solution.reinit(locally_relevant_set, MPI_COMM_WORLD);
     temp_solution = solution;
 
-    KellyErrorEstimator<dim>::estimate(static_cast<DoFHandler<dim> &>(
-                                         mg_dof_handler),
-                                       QGauss<dim - 1>(degree + 1),
-                                       typename FunctionMap<dim>::type(),
-                                       temp_solution,
-                                       estimated_error_per_cell);
+    KellyErrorEstimator<dim>::estimate(
+      mg_dof_handler,
+      QGauss<dim - 1>(degree + 1),
+      std::map<types::boundary_id, const Function<dim> *>(),
+      temp_solution,
+      estimated_error_per_cell);
 
     parallel::distributed::GridRefinement::refine_and_coarsen_fixed_fraction(
       triangulation, estimated_error_per_cell, 0.3, 0.0);
index da30b0fcc5bbb375806b07ac734f16bb15c3ae60..e7c3c9a1b1ddff51cae908fef54e40a8211a2805 100644 (file)
@@ -206,8 +206,9 @@ check_simple(const FiniteElement<dim> &fe)
 
   Triangulation<dim> tr(Triangulation<dim>::limit_level_difference_at_vertices);
   GridGenerator::hyper_cube(tr, -1, 1);
-  typename FunctionMap<dim>::type dirichlet_boundary_functions;
-  Functions::ZeroFunction<dim>    homogeneous_dirichlet_bc(1);
+  std::map<types::boundary_id, const Function<dim> *>
+                               dirichlet_boundary_functions;
+  Functions::ZeroFunction<dim> homogeneous_dirichlet_bc(1);
   dirichlet_boundary_functions[0] = &homogeneous_dirichlet_bc;
 
   tr.refine_global(1);
index 92b71b0f0e9cfd4e9d55ac39638efce7335b818a..be5b7c44737cb80fdbcd9658b793cf3e15fa5b0e 100644 (file)
@@ -206,7 +206,8 @@ check_simple(const FiniteElement<dim> &fe)
 
   Triangulation<dim> tr(Triangulation<dim>::limit_level_difference_at_vertices);
   GridGenerator::hyper_cube(tr, -1, 1);
-  typename FunctionMap<dim>::type dirichlet_boundary_functions;
+  std::map<types::boundary_id, const Function<dim> *>
+    dirichlet_boundary_functions;
 
   tr.refine_global(1);
   refine_mesh(tr);
index 7524f8aebf0e0c0eb1995ea95d69d08a58216a61..f8874b4de5f82af4925815f492e4f387cd630faf 100644 (file)
@@ -340,8 +340,8 @@ template <int dim>
 void
 LaplaceProblem<dim>::test()
 {
-  typename FunctionMap<dim>::type dirichlet_boundary;
-  Functions::ZeroFunction<dim>    dirichlet_bc(fe.n_components());
+  std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
+  Functions::ZeroFunction<dim> dirichlet_bc(fe.n_components());
   dirichlet_boundary[0] = &dirichlet_bc;
 
   const unsigned int min_l = mg_matrices.min_level();
index 237133e1bd5b1a999c767652507156136baf98e5..c84ee05aa9f6b8f4ac5f146dd9eb545fd7b25a88 100644 (file)
@@ -292,8 +292,8 @@ template <int dim>
 void
 LaplaceProblem<dim>::test_boundary()
 {
-  typename FunctionMap<dim>::type dirichlet_boundary;
-  Functions::ZeroFunction<dim>    dirichlet_bc(fe.n_components());
+  std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
+  Functions::ZeroFunction<dim> dirichlet_bc(fe.n_components());
   dirichlet_boundary[0] = &dirichlet_bc;
   MGTools::make_boundary_list(mg_dof_handler_renumbered,
                               dirichlet_boundary,
index 3e59056a3b89ad18a5d782f42c956f171be374b6..58b2ee41baae46bdcced882e320111c79f528c95 100644 (file)
@@ -349,8 +349,8 @@ template <int dim>
 void
 LaplaceProblem<dim>::test()
 {
-  typename FunctionMap<dim>::type dirichlet_boundary;
-  Functions::ZeroFunction<dim>    dirichlet_bc(fe.n_components());
+  std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
+  Functions::ZeroFunction<dim> dirichlet_bc(fe.n_components());
   dirichlet_boundary[0] = &dirichlet_bc;
 
   MGConstrainedDoFs mg_constrained_dofs;
index a76317db6f05ca86ee05eaced485ea0b4fc36104..8bd51acab036545845761198109fe9ffc7bcd736 100644 (file)
@@ -255,8 +255,8 @@ LaplaceProblem<dim>::setup_system()
 
   constraints.clear();
   DoFTools::make_hanging_node_constraints(mg_dof_handler, constraints);
-  typename FunctionMap<dim>::type dirichlet_boundary;
-  Functions::ZeroFunction<dim>    homogeneous_dirichlet_bc(1);
+  std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
+  Functions::ZeroFunction<dim> homogeneous_dirichlet_bc(1);
   dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
   MappingQGeneric<dim> mapping(1);
   VectorTools::interpolate_boundary_values(mapping,
index e26962725883e9b044cc504a92c195f3c24b20ce..117a53900e181eb7f0be4348c881e1747ba64cef 100644 (file)
@@ -174,8 +174,8 @@ LaplaceProblem<dim>::setup_system()
 
   constraints.clear();
   DoFTools::make_hanging_node_constraints(mg_dof_handler, constraints);
-  typename FunctionMap<dim>::type dirichlet_boundary;
-  Functions::ZeroFunction<dim>    homogeneous_dirichlet_bc(1);
+  std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
+  Functions::ZeroFunction<dim> homogeneous_dirichlet_bc(1);
   dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
   MappingQGeneric<dim> mapping(1);
   VectorTools::interpolate_boundary_values(mapping,
@@ -419,12 +419,12 @@ LaplaceProblem<dim>::refine_grid()
 {
   Vector<float> estimated_error_per_cell(triangulation.n_active_cells());
 
-  KellyErrorEstimator<dim>::estimate(static_cast<DoFHandler<dim> &>(
-                                       mg_dof_handler),
-                                     QGauss<dim - 1>(3),
-                                     typename FunctionMap<dim>::type(),
-                                     solution,
-                                     estimated_error_per_cell);
+  KellyErrorEstimator<dim>::estimate(
+    mg_dof_handler,
+    QGauss<dim - 1>(3),
+    std::map<types::boundary_id, const Function<dim> *>(),
+    solution,
+    estimated_error_per_cell);
   GridRefinement::refine_and_coarsen_fixed_number(triangulation,
                                                   estimated_error_per_cell,
                                                   0.3,
index dfe915b35cd63c723c71d39cb66173d33d403acc..b82f2c0f9aaeeb3331ccb02615a0cee072812e4a 100644 (file)
@@ -178,8 +178,8 @@ LaplaceProblem<dim>::setup_system()
 
   constraints.clear();
   DoFTools::make_hanging_node_constraints(mg_dof_handler, constraints);
-  typename FunctionMap<dim>::type dirichlet_boundary;
-  Functions::ZeroFunction<dim>    homogeneous_dirichlet_bc(1);
+  std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
+  Functions::ZeroFunction<dim> homogeneous_dirichlet_bc(1);
   dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
   MappingQGeneric<dim> mapping(1);
   VectorTools::interpolate_boundary_values(mapping,
@@ -444,12 +444,12 @@ LaplaceProblem<dim>::refine_grid()
 {
   Vector<float> estimated_error_per_cell(triangulation.n_active_cells());
 
-  KellyErrorEstimator<dim>::estimate(static_cast<DoFHandler<dim> &>(
-                                       mg_dof_handler),
-                                     QGauss<dim - 1>(3),
-                                     typename FunctionMap<dim>::type(),
-                                     solution,
-                                     estimated_error_per_cell);
+  KellyErrorEstimator<dim>::estimate(
+    mg_dof_handler,
+    QGauss<dim - 1>(3),
+    std::map<types::boundary_id, const Function<dim> *>(),
+    solution,
+    estimated_error_per_cell);
   GridRefinement::refine_and_coarsen_fixed_number(triangulation,
                                                   estimated_error_per_cell,
                                                   0.3,
index fa53e044543686f079c892f5d104b3c3f47ae570..aea5b7db46e5f061447d92092e7fac3617704fae 100644 (file)
@@ -178,8 +178,8 @@ LaplaceProblem<dim>::setup_system()
   DoFTools::make_hanging_node_constraints(mg_dof_handler, constraints);
   DoFTools::make_hanging_node_constraints(mg_dof_handler,
                                           hanging_node_constraints);
-  typename FunctionMap<dim>::type dirichlet_boundary;
-  Functions::ZeroFunction<dim>    homogeneous_dirichlet_bc(1);
+  std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
+  Functions::ZeroFunction<dim> homogeneous_dirichlet_bc(1);
   dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
   MappingQGeneric<dim> mapping(1);
   VectorTools::interpolate_boundary_values(mapping,
index b6057e38923ea83b282908c2a43e4bf251c116c4..629f6b2dd41ebefc4966ba56911bc448a72339f5 100644 (file)
@@ -178,8 +178,8 @@ LaplaceProblem<dim>::setup_system()
   DoFTools::make_hanging_node_constraints(mg_dof_handler, constraints);
   DoFTools::make_hanging_node_constraints(mg_dof_handler,
                                           hanging_node_constraints);
-  typename FunctionMap<dim>::type dirichlet_boundary;
-  Functions::ZeroFunction<dim>    homogeneous_dirichlet_bc(1);
+  std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
+  Functions::ZeroFunction<dim> homogeneous_dirichlet_bc(1);
   dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
   MappingQGeneric<dim> mapping(1);
   VectorTools::interpolate_boundary_values(mapping,
index f90c3f16fc6d06fcbe3777f2e54c9e2ca1b40c1e..8410447e4570962af1d9d511fba48c7c0268027a 100644 (file)
@@ -180,8 +180,8 @@ LaplaceProblem<dim>::setup_system()
 
   constraints.clear();
   DoFTools::make_hanging_node_constraints(mg_dof_handler, constraints);
-  typename FunctionMap<dim>::type dirichlet_boundary;
-  Functions::ZeroFunction<dim>    homogeneous_dirichlet_bc(1);
+  std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
+  Functions::ZeroFunction<dim> homogeneous_dirichlet_bc(1);
   dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
   MappingQGeneric<dim> mapping(1);
   VectorTools::interpolate_boundary_values(mapping,
@@ -514,12 +514,12 @@ LaplaceProblem<dim>::refine_grid()
 {
   Vector<float> estimated_error_per_cell(triangulation.n_active_cells());
 
-  KellyErrorEstimator<dim>::estimate(static_cast<DoFHandler<dim> &>(
-                                       mg_dof_handler),
-                                     QGauss<dim - 1>(3),
-                                     typename FunctionMap<dim>::type(),
-                                     solution,
-                                     estimated_error_per_cell);
+  KellyErrorEstimator<dim>::estimate(
+    mg_dof_handler,
+    QGauss<dim - 1>(3),
+    std::map<types::boundary_id, const Function<dim> *>(),
+    solution,
+    estimated_error_per_cell);
   GridRefinement::refine_and_coarsen_fixed_number(triangulation,
                                                   estimated_error_per_cell,
                                                   0.3,
index 4ce9efa67f60bc518a72501ced4ebc39f74256fc..7994253bb6665a64887e43c8bd3f039b92824c0b 100644 (file)
@@ -207,8 +207,8 @@ namespace Step50
     constraints.reinit(locally_relevant_set);
     DoFTools::make_hanging_node_constraints(mg_dof_handler, constraints);
 
-    typename FunctionMap<dim>::type dirichlet_boundary;
-    Functions::ZeroFunction<dim>    homogeneous_dirichlet_bc;
+    std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
+    Functions::ZeroFunction<dim> homogeneous_dirichlet_bc;
     dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
     VectorTools::interpolate_boundary_values(mg_dof_handler,
                                              dirichlet_boundary,
@@ -504,12 +504,12 @@ namespace Step50
     temp_solution.reinit(locally_relevant_set, MPI_COMM_WORLD);
     temp_solution = solution;
 
-    KellyErrorEstimator<dim>::estimate(static_cast<DoFHandler<dim> &>(
-                                         mg_dof_handler),
-                                       QGauss<dim - 1>(degree + 1),
-                                       typename FunctionMap<dim>::type(),
-                                       temp_solution,
-                                       estimated_error_per_cell);
+    KellyErrorEstimator<dim>::estimate(
+      mg_dof_handler,
+      QGauss<dim - 1>(degree + 1),
+      std::map<types::boundary_id, const Function<dim> *>(),
+      temp_solution,
+      estimated_error_per_cell);
 
     const double threshold =
       0.6 * Utilities::MPI::max(estimated_error_per_cell.linfty_norm(),
index 45159e0ed126c3b1a2fdbdbcd3f08ec042bcfd13..f1261b025ef2b80b94c46ac55f0fc77b7d50d886 100644 (file)
@@ -207,8 +207,8 @@ namespace Step50
     constraints.reinit(locally_relevant_set);
     DoFTools::make_hanging_node_constraints(mg_dof_handler, constraints);
 
-    typename FunctionMap<dim>::type dirichlet_boundary;
-    Functions::ZeroFunction<dim>    homogeneous_dirichlet_bc;
+    std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
+    Functions::ZeroFunction<dim> homogeneous_dirichlet_bc;
     dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
     VectorTools::interpolate_boundary_values(mg_dof_handler,
                                              dirichlet_boundary,
@@ -493,12 +493,12 @@ namespace Step50
     temp_solution.reinit(locally_relevant_set, MPI_COMM_WORLD);
     temp_solution = solution;
 
-    KellyErrorEstimator<dim>::estimate(static_cast<DoFHandler<dim> &>(
-                                         mg_dof_handler),
-                                       QGauss<dim - 1>(degree + 1),
-                                       typename FunctionMap<dim>::type(),
-                                       temp_solution,
-                                       estimated_error_per_cell);
+    KellyErrorEstimator<dim>::estimate(
+      mg_dof_handler,
+      QGauss<dim - 1>(degree + 1),
+      std::map<types::boundary_id, const Function<dim> *>(),
+      temp_solution,
+      estimated_error_per_cell);
 
     const double threshold =
       0.6 * Utilities::MPI::max(estimated_error_per_cell.linfty_norm(),
index 8a2831c7fd2a3b3d408c26f3ad60c92bf06875f5..c17f2d7b809d0c1c653aa37895fa6f498184cc1f 100644 (file)
@@ -207,8 +207,8 @@ namespace Step50
     constraints.reinit(locally_relevant_set);
     DoFTools::make_hanging_node_constraints(mg_dof_handler, constraints);
 
-    typename FunctionMap<dim>::type dirichlet_boundary;
-    Functions::ZeroFunction<dim>    homogeneous_dirichlet_bc;
+    std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
+    Functions::ZeroFunction<dim> homogeneous_dirichlet_bc;
     dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
     VectorTools::interpolate_boundary_values(mg_dof_handler,
                                              dirichlet_boundary,
@@ -490,12 +490,12 @@ namespace Step50
     temp_solution.reinit(locally_relevant_set, MPI_COMM_WORLD);
     temp_solution = solution;
 
-    KellyErrorEstimator<dim>::estimate(static_cast<DoFHandler<dim> &>(
-                                         mg_dof_handler),
-                                       QGauss<dim - 1>(degree + 1),
-                                       typename FunctionMap<dim>::type(),
-                                       temp_solution,
-                                       estimated_error_per_cell);
+    KellyErrorEstimator<dim>::estimate(
+      mg_dof_handler,
+      QGauss<dim - 1>(degree + 1),
+      std::map<types::boundary_id, const Function<dim> *>(),
+      temp_solution,
+      estimated_error_per_cell);
 
     const double threshold =
       0.6 * Utilities::MPI::max(estimated_error_per_cell.linfty_norm(),
index 9a7c30f0061e3111db4f55b0ae2ec1fd214c7bc0..efa367ca44f4f038fac2ff50ee409599594cf116 100644 (file)
@@ -178,8 +178,8 @@ LaplaceProblem<dim>::setup_system()
 
   constraints.clear();
   DoFTools::make_hanging_node_constraints(mg_dof_handler, constraints);
-  typename FunctionMap<dim>::type dirichlet_boundary;
-  Functions::ZeroFunction<dim>    homogeneous_dirichlet_bc(1);
+  std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
+  Functions::ZeroFunction<dim> homogeneous_dirichlet_bc(1);
   dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
   MappingQGeneric<dim> mapping(1);
   VectorTools::interpolate_boundary_values(mapping,
@@ -414,12 +414,12 @@ LaplaceProblem<dim>::refine_grid()
 {
   Vector<float> estimated_error_per_cell(triangulation.n_active_cells());
 
-  KellyErrorEstimator<dim>::estimate(static_cast<DoFHandler<dim> &>(
-                                       mg_dof_handler),
-                                     QGauss<dim - 1>(degree + 1),
-                                     typename FunctionMap<dim>::type(),
-                                     solution,
-                                     estimated_error_per_cell);
+  KellyErrorEstimator<dim>::estimate(
+    mg_dof_handler,
+    QGauss<dim - 1>(degree + 1),
+    std::map<types::boundary_id, const Function<dim> *>(),
+    solution,
+    estimated_error_per_cell);
 
   const double threshold = 0.6 * estimated_error_per_cell.linfty_norm();
   GridRefinement::refine(triangulation, estimated_error_per_cell, threshold);
index 2bde093414ec18cf7546541ea465078b270a5cd2..113457519d4cbee05cc27e1c8481ebee25dd8f74 100644 (file)
@@ -256,8 +256,8 @@ LaplaceProblem<dim>::setup_system()
 
   constraints.clear();
   DoFTools::make_hanging_node_constraints(mg_dof_handler, constraints);
-  typename FunctionMap<dim>::type dirichlet_boundary;
-  Functions::ZeroFunction<dim>    homogeneous_dirichlet_bc(1);
+  std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
+  Functions::ZeroFunction<dim> homogeneous_dirichlet_bc(1);
   dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
   MappingQGeneric<dim> mapping(1);
   VectorTools::interpolate_boundary_values(mapping,
index ad77d3632b3c2faff4670d92b6cfeb10f18b65f0..62135d11752174bab92650839a2e14da6809dbe0 100644 (file)
@@ -180,8 +180,8 @@ LaplaceProblem<dim>::setup_system()
 
   constraints.clear();
   DoFTools::make_hanging_node_constraints(mg_dof_handler, constraints);
-  typename FunctionMap<dim>::type dirichlet_boundary;
-  Functions::ZeroFunction<dim>    homogeneous_dirichlet_bc(1);
+  std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
+  Functions::ZeroFunction<dim> homogeneous_dirichlet_bc(1);
   dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
   MappingQGeneric<dim> mapping(1);
   VectorTools::interpolate_boundary_values(mapping,
@@ -515,12 +515,12 @@ LaplaceProblem<dim>::refine_grid()
 {
   Vector<float> estimated_error_per_cell(triangulation.n_active_cells());
 
-  KellyErrorEstimator<dim>::estimate(static_cast<DoFHandler<dim> &>(
-                                       mg_dof_handler),
-                                     QGauss<dim - 1>(3),
-                                     typename FunctionMap<dim>::type(),
-                                     solution,
-                                     estimated_error_per_cell);
+  KellyErrorEstimator<dim>::estimate(
+    mg_dof_handler,
+    QGauss<dim - 1>(3),
+    std::map<types::boundary_id, const Function<dim> *>(),
+    solution,
+    estimated_error_per_cell);
   GridRefinement::refine_and_coarsen_fixed_number(triangulation,
                                                   estimated_error_per_cell,
                                                   0.3,
index 0050d023142d64f04eab3fb9582f4bde5b8c5b21..d6b0da2f9f2108d0fa9bc8ede24d411a99077a9a 100644 (file)
@@ -208,7 +208,7 @@ namespace Step50
     constraints.reinit(locally_relevant_set);
     DoFTools::make_hanging_node_constraints(mg_dof_handler, constraints);
 
-    typename FunctionMap<dim>::type  dirichlet_boundary;
+    std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
     Functions::ConstantFunction<dim> homogeneous_dirichlet_bc(0.0);
     dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
     VectorTools::interpolate_boundary_values(mg_dof_handler,
@@ -513,12 +513,12 @@ namespace Step50
     temp_solution.reinit(locally_relevant_set, MPI_COMM_WORLD);
     temp_solution = solution;
 
-    KellyErrorEstimator<dim>::estimate(static_cast<DoFHandler<dim> &>(
-                                         mg_dof_handler),
-                                       QGauss<dim - 1>(degree + 1),
-                                       typename FunctionMap<dim>::type(),
-                                       temp_solution,
-                                       estimated_error_per_cell);
+    KellyErrorEstimator<dim>::estimate(
+      mg_dof_handler,
+      QGauss<dim - 1>(degree + 1),
+      std::map<types::boundary_id, const Function<dim> *>(),
+      temp_solution,
+      estimated_error_per_cell);
 
     parallel::distributed::GridRefinement::refine_and_coarsen_fixed_fraction(
       triangulation, estimated_error_per_cell, 0.3, 0.0);
index 4bb3190c25aeb8709bbf3ccd67ca2989e10d51af..2166659c31bf813ad8e9f11a774bb1a3b0f2de9f 100644 (file)
@@ -212,8 +212,8 @@ namespace Step50
     constraints.reinit(locally_relevant_set);
     DoFTools::make_hanging_node_constraints(mg_dof_handler, constraints);
 
-    std::set<types::boundary_id>     dirichlet_boundary_ids;
-    typename FunctionMap<dim>::type  dirichlet_boundary;
+    std::set<types::boundary_id>                        dirichlet_boundary_ids;
+    std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
     Functions::ConstantFunction<dim> homogeneous_dirichlet_bc(1.0);
     dirichlet_boundary_ids.insert(0);
     dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
index d9074b1192c1125d470aac639d6331b8f5f432e7..764e7382c63f96031bdc71ce4d07f06b8f8146fd 100644 (file)
@@ -21,7 +21,6 @@
 #include <deal.II/distributed/tria.h>
 
 #include <deal.II/dofs/dof_accessor.h>
-#include <deal.II/dofs/function_map.h>
 
 #include <deal.II/fe/fe_dgq.h>
 #include <deal.II/fe/fe_q.h>
index b4b0563a1c2a581ebd80f7f6acd0a57fc361c97b..640f982274760b721015f74fe5f5cbb30213d3e1 100644 (file)
@@ -21,7 +21,6 @@
 #include <deal.II/distributed/tria.h>
 
 #include <deal.II/dofs/dof_accessor.h>
-#include <deal.II/dofs/function_map.h>
 
 #include <deal.II/fe/fe_dgq.h>
 #include <deal.II/fe/fe_q.h>
@@ -121,8 +120,8 @@ check_fe(FiniteElement<dim> &fe)
     }
 
 
-  Functions::ZeroFunction<dim>    zero;
-  typename FunctionMap<dim>::type fmap;
+  Functions::ZeroFunction<dim>                        zero;
+  std::map<types::boundary_id, const Function<dim> *> fmap;
   fmap.insert(std::make_pair(0, &zero));
 
   DoFHandler<dim> dofh(tr);
index 72955a09cbadccd55e75c4010dbbbca766f767ab..db52a3ba5d9b5af40c8448541976efcced5353bf 100644 (file)
@@ -21,7 +21,6 @@
 #include <deal.II/distributed/tria.h>
 
 #include <deal.II/dofs/dof_accessor.h>
-#include <deal.II/dofs/function_map.h>
 
 #include <deal.II/fe/fe_dgq.h>
 #include <deal.II/fe/fe_q.h>
@@ -121,8 +120,8 @@ check_fe(FiniteElement<dim> &fe)
     }
 
 
-  Functions::ZeroFunction<dim>    zero;
-  typename FunctionMap<dim>::type fmap;
+  Functions::ZeroFunction<dim>                        zero;
+  std::map<types::boundary_id, const Function<dim> *> fmap;
   fmap.insert(std::make_pair(0, &zero));
 
   DoFHandler<dim> dofh(tr);
index 272edb057ee3ecc1bb364c804145e13d64079df0..b799c0d53ad148ed5de4b9ba25aa63f15fb54522 100644 (file)
@@ -22,7 +22,6 @@
 #include <deal.II/distributed/tria.h>
 
 #include <deal.II/dofs/dof_accessor.h>
-#include <deal.II/dofs/function_map.h>
 
 #include <deal.II/fe/fe_q.h>
 
@@ -106,9 +105,9 @@ check(const unsigned int fe_degree)
       mgdof.distribute_dofs(fe);
       mgdof.distribute_mg_dofs(fe);
 
-      MGConstrainedDoFs               mg_constrained_dofs;
-      ZeroFunction<dim>               zero_function;
-      typename FunctionMap<dim>::type dirichlet_boundary;
+      MGConstrainedDoFs                                   mg_constrained_dofs;
+      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);
 
index bfb2c6fd4352ace7e1e7fb82f083cb62c2617b5f..551bdf0cc0b80ae3cb89544fd9af1a3725f6411d 100644 (file)
@@ -23,7 +23,6 @@
 #include <deal.II/distributed/tria.h>
 
 #include <deal.II/dofs/dof_accessor.h>
-#include <deal.II/dofs/function_map.h>
 
 #include <deal.II/fe/fe_q.h>
 
@@ -118,9 +117,9 @@ 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;
-      typename FunctionMap<dim>::type dirichlet_boundary;
+      std::vector<MGConstrainedDoFs> mg_constrained_dofs_vector(2);
+      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)
         mg_constrained_dofs_vector[i].initialize(*mgdof_ptr[i],
index 3951ed44db31e11f2ec7a55b58a056c42737f0fe..ef6a46505ec009451b810304cc1395d472a907b4 100644 (file)
@@ -67,9 +67,9 @@ check(const unsigned int fe_degree)
       mgdof.distribute_dofs(fe);
       mgdof.distribute_mg_dofs(fe);
 
-      MGConstrainedDoFs               mg_constrained_dofs;
-      Functions::ZeroFunction<dim>    zero_function;
-      typename FunctionMap<dim>::type dirichlet_boundary;
+      MGConstrainedDoFs                                   mg_constrained_dofs;
+      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);
 
index 71a2e4406f83b8051dfcdf6fdcc4611abe54be22..4c75298375842f7fad3d50a75bd96146b79d83b5 100644 (file)
@@ -96,9 +96,9 @@ check(const unsigned int fe_degree)
       mgdof.distribute_dofs(fe);
       mgdof.distribute_mg_dofs(fe);
 
-      MGConstrainedDoFs               mg_constrained_dofs;
-      Functions::ZeroFunction<dim>    zero_function;
-      typename FunctionMap<dim>::type dirichlet_boundary;
+      MGConstrainedDoFs                                   mg_constrained_dofs;
+      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);
 
index 710fee7bf0bf3b41aaafd997ddeed5a954e57d94..39f03ea23bdd5b4c065d1e258f0c6cd1913f358c 100644 (file)
@@ -100,9 +100,9 @@ check(const unsigned int fe_degree)
       mgdof.distribute_dofs(fe);
       mgdof.distribute_mg_dofs(fe);
 
-      MGConstrainedDoFs               mg_constrained_dofs;
-      ZeroFunction<dim>               zero_function;
-      typename FunctionMap<dim>::type dirichlet_boundary;
+      MGConstrainedDoFs                                   mg_constrained_dofs;
+      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);
 
index 052beb862a84e374455c20d5a4b48426fc3abb7b..2fe11cd47e99d1ec092544d94c4c033f2a3a8e18 100644 (file)
@@ -111,9 +111,9 @@ 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;
-      typename FunctionMap<dim>::type dirichlet_boundary;
+      std::vector<MGConstrainedDoFs> mg_constrained_dofs_vector(2);
+      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)
         mg_constrained_dofs_vector[i].initialize(*mgdof_ptr[i],
index 9b3edf2a1c4dad8b140c86b68d56c39bba76276c..16a5a339fe8c08353b80b32c5ed6f9a5e0855a39 100644 (file)
@@ -65,9 +65,9 @@ check(const unsigned int fe_degree)
       mgdof.distribute_dofs(fe);
       mgdof.distribute_mg_dofs(fe);
 
-      MGConstrainedDoFs               mg_constrained_dofs;
-      Functions::ZeroFunction<dim>    zero_function;
-      typename FunctionMap<dim>::type dirichlet_boundary;
+      MGConstrainedDoFs                                   mg_constrained_dofs;
+      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);
 
index 5b25c48e8a746839db03365a669a1bb2e8b30971..bc8ccda34ab746d6ce868a831d1345f2cda2e0ee 100644 (file)
@@ -98,9 +98,9 @@ check(const unsigned int fe_degree)
       mgdof.distribute_dofs(fe);
       mgdof.distribute_mg_dofs(fe);
 
-      MGConstrainedDoFs               mg_constrained_dofs;
-      Functions::ZeroFunction<dim>    zero_function;
-      typename FunctionMap<dim>::type dirichlet_boundary;
+      MGConstrainedDoFs                                   mg_constrained_dofs;
+      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);
 
index 1c5e40d87a21c32e36dcb1b7ffe1fdc336d710ac..f5c0b3efac7d9adcd4e2c119da6089b91090789f 100644 (file)
@@ -63,8 +63,8 @@ check_simple(const FiniteElement<dim> &fe)
   mgdof.distribute_dofs(fe);
   mgdof.distribute_mg_dofs(fe);
 
-  typename FunctionMap<dim>::type dirichlet_boundary;
-  Functions::ZeroFunction<dim>    homogeneous_dirichlet_bc(1);
+  std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
+  Functions::ZeroFunction<dim> homogeneous_dirichlet_bc(1);
   dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
 
   MGConstrainedDoFs mg_constrained_dofs;
index 21d7846d194f63afa5b5ce20da3a0fa4e59219cb..5fc6d573f21e68b317874cd457bbc73685fc4cdd 100644 (file)
@@ -65,9 +65,9 @@ check()
       mgdof.distribute_dofs(fe);
       mgdof.distribute_mg_dofs(fe);
 
-      MGConstrainedDoFs               mg_constrained_dofs;
-      Functions::ZeroFunction<dim>    zero_function;
-      typename FunctionMap<dim>::type dirichlet_boundary;
+      MGConstrainedDoFs                                   mg_constrained_dofs;
+      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);
 
index 33d0d028a97a39f45a0852e42100f1aa7ad38f35..bba557a45304dc62971b8f28602925a18b62a3f0 100644 (file)
@@ -59,8 +59,7 @@ check_select(const FiniteElement<dim> &fe,
   DoFHandler<dim> &dof = mgdof;
   mgdof.distribute_dofs(fe);
   mgdof.distribute_mg_dofs(fe);
-  DoFRenumbering::component_wise(static_cast<DoFHandler<dim> &>(mgdof),
-                                 target_component);
+  DoFRenumbering::component_wise(mgdof, target_component);
   vector<types::global_dof_index> ndofs(
     *std::max_element(target_component.begin(), target_component.end()) + 1);
   DoFTools::count_dofs_per_component(dof, ndofs, true, target_component);
index d983a45143875bfea84a45b41617b7638f80590d..3789c0ea56048d4945623bce4a26af6050862bd2 100644 (file)
@@ -152,8 +152,8 @@ check(const FiniteElement<dim> &fe)
     DoFRenumbering::component_wise(mg_dof_handler, level);
 
   std::vector<std::set<unsigned int>> boundary_indices(tr.n_levels());
-  typename FunctionMap<dim>::type     dirichlet_boundary;
-  Functions::ZeroFunction<dim>        dirichlet_bc(fe.n_components());
+  std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
+  Functions::ZeroFunction<dim> dirichlet_bc(fe.n_components());
   dirichlet_boundary[3] = &dirichlet_bc;
 
   MGConstrainedDoFs mg_constrained_dofs;
index a143b97461911db5b71ef751091c846cc493f7f3..e5d20fdab71c2ad4d39819bed746c150328dcff0 100644 (file)
@@ -153,8 +153,8 @@ check(const FiniteElement<dim> &fe)
 
   std::vector<std::set<types::global_dof_index>> boundary_indices(
     tr.n_levels());
-  typename FunctionMap<dim>::type dirichlet_boundary;
-  Functions::ZeroFunction<dim>    dirichlet_bc(fe.n_components());
+  std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
+  Functions::ZeroFunction<dim> dirichlet_bc(fe.n_components());
   dirichlet_boundary[3] = &dirichlet_bc;
 
   MGTools::make_boundary_list(mg_dof_handler,
index 0642c4325b82030b2830ea90046f9508d9ee214c..8fae1ab698b6f318a5095207a99dbef18308ee24 100644 (file)
@@ -153,8 +153,8 @@ check(const FiniteElement<dim> &fe)
 
   std::vector<std::set<types::global_dof_index>> boundary_indices(
     tr.n_levels());
-  typename FunctionMap<dim>::type dirichlet_boundary;
-  Functions::ZeroFunction<dim>    dirichlet_bc(fe.n_components());
+  std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
+  Functions::ZeroFunction<dim> dirichlet_bc(fe.n_components());
   dirichlet_boundary[3] = &dirichlet_bc;
 
   MGTools::make_boundary_list(mg_dof_handler,
index 14b0ace0059a208bd2f6e715948a29e4d9dcca33..f34544233e9fe408d29fd8ea4cc3a1480e85d35c 100644 (file)
@@ -157,8 +157,8 @@ check(const FiniteElement<dim> &fe)
 
   std::vector<std::set<types::global_dof_index>> boundary_indices(
     tr.n_levels());
-  typename FunctionMap<dim>::type dirichlet_boundary;
-  Functions::ZeroFunction<dim>    dirichlet_bc(fe.n_components());
+  std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
+  Functions::ZeroFunction<dim> dirichlet_bc(fe.n_components());
   dirichlet_boundary[3] = &dirichlet_bc;
 
   MGTools::make_boundary_list(mg_dof_handler,
index f7736b27b1e1d41c8003f3e519e190aa58d4e9bd..479084dd4fc668e35db463667f55b65d6d0bc063 100644 (file)
@@ -300,7 +300,7 @@ test_neumann(const NeumanBC<dim> &func)
   dealii::deallog << std::endl;
 
   // call Kelly
-  typename dealii::FunctionMap<dim>::type function_map;
+  std::map<types::boundary_id, const Function<dim> *> function_map;
   function_map[0] = &func;
 
   dealii::Vector<float> error(dof_handler.n_dofs());
@@ -420,7 +420,7 @@ test_regular(const MyFunction<dim> &func)
   dealii::KellyErrorEstimator<dim>::estimate(
     dof_handler,
     face_quadrature_formula,
-    typename dealii::FunctionMap<dim>::type(),
+    std::map<types::boundary_id, const Function<dim> *>(),
     values,
     error,
     dealii::ComponentMask(),
@@ -550,7 +550,7 @@ test_irregular(const MyFunction<dim> &func)
   dealii::KellyErrorEstimator<dim>::estimate(
     dof_handler,
     face_quadrature_formula,
-    typename dealii::FunctionMap<dim>::type(),
+    std::map<types::boundary_id, const Function<dim> *>(),
     values,
     error,
     dealii::ComponentMask(),
@@ -719,7 +719,7 @@ test(const MySecondFunction<dim> &func)
   dealii::KellyErrorEstimator<dim>::estimate(
     dof_handler,
     face_quadrature_formula,
-    typename dealii::FunctionMap<dim>::type(),
+    std::map<types::boundary_id, const Function<dim> *>(),
     values,
     error,
     dealii::ComponentMask(),
index f55cfba6ae2ed39e764c8dff672c73a46768cd25..30a61183abe2f161a53dd28eb0f7c01762178b77 100644 (file)
@@ -244,7 +244,8 @@ test_neumann(const NeumanBC<dim> &func)
   dealii::deallog << std::endl;
 
   // call Kelly
-  typename dealii::FunctionMap<dim, std::complex<double>>::type function_map;
+  std::map<types::boundary_id, const Function<dim, std::complex<double>> *>
+    function_map;
   function_map[0] = &func;
 
   dealii::Vector<float> error(dof_handler.n_dofs());
@@ -364,7 +365,7 @@ test_regular(const MyFunction<dim> &func)
   dealii::KellyErrorEstimator<dim>::estimate(
     dof_handler,
     face_quadrature_formula,
-    typename dealii::FunctionMap<dim, std::complex<double>>::type(),
+    std::map<types::boundary_id, const Function<dim, std::complex<double>> *>(),
     values,
     error,
     dealii::ComponentMask(),
@@ -494,7 +495,7 @@ test_irregular(const MyFunction<dim> &func)
   dealii::KellyErrorEstimator<dim>::estimate(
     dof_handler,
     face_quadrature_formula,
-    typename dealii::FunctionMap<dim, std::complex<double>>::type(),
+    std::map<types::boundary_id, const Function<dim, std::complex<double>> *>(),
     values,
     error,
     dealii::ComponentMask(),
@@ -665,7 +666,7 @@ test(const MySecondFunction<dim> &func)
   dealii::KellyErrorEstimator<dim>::estimate(
     dof_handler,
     face_quadrature_formula,
-    typename dealii::FunctionMap<dim, std::complex<double>>::type(),
+    std::map<types::boundary_id, const Function<dim, std::complex<double>> *>(),
     values,
     error,
     dealii::ComponentMask(),
index 65343ee71131ff64c26289d6539ea8fe88334037..6fcfafedb2ad39d5763a5e5d5984013bd703b781 100644 (file)
@@ -48,7 +48,7 @@ test(const Triangulation<dim> &tr, const FiniteElement<dim> &fe)
   dof.distribute_dofs(fe);
 
   Functions::ConstantFunction<dim> constant_function(1., dim);
-  typename FunctionMap<dim>::type  function_map;
+  std::map<types::boundary_id, const Function<dim> *> function_map;
   for (unsigned int j = 0; j < GeometryInfo<dim>::faces_per_cell; ++j)
     function_map[j] = &constant_function;
 
index 89b40d47e320c29274d316fb627541304f82fff8..5a22a36c35b7e139cb8fb07801a3731572394177 100644 (file)
@@ -163,7 +163,7 @@ check()
           DoFHandler<dim> dof(tr);
           dof.distribute_dofs(fe);
 
-          typename FunctionMap<dim>::type function_map;
+          std::map<types::boundary_id, const Function<dim> *> function_map;
           function_map[0] = function_list[i];
 
           // interpolate boundary values
index fdcc8356709718c8c50c56afd09d707f5e55d2e3..39ea198d21ee32a384bc37f393cba9d734556f09 100644 (file)
@@ -147,9 +147,9 @@ test_projection(const Triangulation<dim> &tr, const FiniteElement<dim> &fe)
   QGauss<dim - 1>      quadrature(degree + 2);
   MappingQGeneric<dim> mapping(1);
 
-  TestFunction<dim>                         f(degree - 1);
-  std::map<types::global_dof_index, double> boundary_constraints;
-  typename FunctionMap<dim>::type           boundary_map;
+  TestFunction<dim>                                   f(degree - 1);
+  std::map<types::global_dof_index, double>           boundary_constraints;
+  std::map<types::boundary_id, const Function<dim> *> boundary_map;
   for (types::boundary_id i = 0; i < 255; ++i)
     boundary_map[i] = &f;
   VectorTools::project_boundary_values(
index b3f3431f9dfc6043149d94c9c452c06931c8a7c9..1f3880450428ce3283ac7e2c6770c38bd8d92e57 100644 (file)
@@ -49,7 +49,7 @@ test(const Triangulation<dim> &tr, const FiniteElement<dim> &fe)
   dof.distribute_dofs(fe);
 
   Functions::ConstantFunction<dim> constant_function(1., dim);
-  typename FunctionMap<dim>::type  function_map;
+  std::map<types::boundary_id, const Function<dim> *> function_map;
   for (unsigned int j = 0; j < GeometryInfo<dim>::faces_per_cell; ++j)
     function_map[j] = &constant_function;
 
index a0dce64327ad773a8522820622026011ce6c492e..51250bb64101a49a8b70b10b3cf38c012626e350 100644 (file)
@@ -657,15 +657,16 @@ namespace Step18
   TopLevel<dim>::refine_initial_grid()
   {
     Vector<float> error_per_cell(triangulation.n_active_cells());
-    KellyErrorEstimator<dim>::estimate(dof_handler,
-                                       QGauss<dim - 1>(2),
-                                       typename FunctionMap<dim>::type(),
-                                       incremental_displacement,
-                                       error_per_cell,
-                                       ComponentMask(),
-                                       nullptr,
-                                       MultithreadInfo::n_threads(),
-                                       this_mpi_process);
+    KellyErrorEstimator<dim>::estimate(
+      dof_handler,
+      QGauss<dim - 1>(2),
+      std::map<types::boundary_id, const Function<dim> *>(),
+      incremental_displacement,
+      error_per_cell,
+      ComponentMask(),
+      nullptr,
+      MultithreadInfo::n_threads(),
+      this_mpi_process);
     const unsigned int n_local_cells =
       triangulation.n_locally_owned_active_cells();
     PETScWrappers::MPI::Vector distributed_error_per_cell(
index 8dcd054790243e51e41944dbf91ba9f7faf613ab..a00bfff28968410bcc378010f5cf0ab32718da66 100644 (file)
@@ -673,15 +673,16 @@ namespace Step18
   TopLevel<dim>::refine_initial_grid()
   {
     Vector<float> error_per_cell(triangulation.n_active_cells());
-    KellyErrorEstimator<dim>::estimate(dof_handler,
-                                       QGauss<dim - 1>(2),
-                                       typename FunctionMap<dim>::type(),
-                                       incremental_displacement,
-                                       error_per_cell,
-                                       ComponentMask(),
-                                       nullptr,
-                                       MultithreadInfo::n_threads(),
-                                       this_mpi_process);
+    KellyErrorEstimator<dim>::estimate(
+      dof_handler,
+      QGauss<dim - 1>(2),
+      std::map<types::boundary_id, const Function<dim> *>(),
+      incremental_displacement,
+      error_per_cell,
+      ComponentMask(),
+      nullptr,
+      MultithreadInfo::n_threads(),
+      this_mpi_process);
     const unsigned int n_local_cells =
       triangulation.n_locally_owned_active_cells();
     PETScWrappers::MPI::Vector distributed_error_per_cell(
index f52fea462011d23b07443e5d5b73bd6001f8fead..7082a88e3233350fe0bb75a6c2f6e4c642af8bd5 100644 (file)
@@ -491,11 +491,12 @@ Test_Solver_Output::refine_grid()
   TimerOutput::Scope t(timer, "refine");
 
   Vector<float> estimated_error_per_cell(triangulation.n_active_cells());
-  KellyErrorEstimator<2>::estimate(dof_handler,
-                                   QGauss<2 - 1>(3),
-                                   typename FunctionMap<2>::type(),
-                                   locally_relevant_solution,
-                                   estimated_error_per_cell);
+  KellyErrorEstimator<2>::estimate(
+    dof_handler,
+    QGauss<2 - 1>(3),
+    std::map<types::boundary_id, const Function<2> *>(),
+    locally_relevant_solution,
+    estimated_error_per_cell);
   parallel::distributed::GridRefinement::refine_and_coarsen_fixed_number(
     triangulation, estimated_error_per_cell, 0.3, 0.03);
   triangulation.execute_coarsening_and_refinement();
index cdc5604202c9ffca56756b02b9f7bfb781a84895..906f69cb13c00badf6f40082bf5482e394cfc71f 100644 (file)
@@ -142,7 +142,7 @@ check()
       DoFHandler<dim> dof(tr);
       dof.distribute_dofs(fe);
 
-      typename FunctionMap<dim>::type function_map;
+      std::map<types::boundary_id, const Function<dim> *> function_map;
       function_map[0] = function_list[i];
 
       // interpolate boundary values
index db2ef3c7631f65b37a6a949d64630a3b0f45b9d4..d806160037022642e6717fb259966ad3614af8d9 100644 (file)
@@ -149,7 +149,8 @@ check()
       DoFHandler<dim> dof(tr);
       dof.distribute_dofs(fe);
 
-      typename FunctionMap<dim, std::complex<double>>::type function_map;
+      std::map<types::boundary_id, const Function<dim, std::complex<double>> *>
+        function_map;
       function_map[0] = function_list[i];
 
       // interpolate boundary values
index 526b264a211622603014bdb899279e860109c37e..22c4a8e69cc60945db99ff1e474f160a488e09db 100644 (file)
@@ -150,7 +150,8 @@ check()
       hp::DoFHandler<dim> dof(tr);
       dof.distribute_dofs(fe);
 
-      typename FunctionMap<dim, std::complex<double>>::type function_map;
+      std::map<types::boundary_id, const Function<dim, std::complex<double>> *>
+        function_map;
       function_map[0] = function_list[i];
 
       // interpolate boundary values

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.