]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Move all code of MappingQGeneric to MappingQ 12561/head
authorMartin Kronbichler <kronbichler@lnm.mw.tum.de>
Sat, 10 Jul 2021 19:26:40 +0000 (21:26 +0200)
committerMartin Kronbichler <kronbichler@lnm.mw.tum.de>
Sun, 11 Jul 2021 07:43:04 +0000 (09:43 +0200)
282 files changed:
contrib/python-bindings/source/mapping_wrapper.cc
contrib/python-bindings/source/triangulation_wrapper.cc
examples/step-19/step-19.cc
examples/step-49/doc/results.dox
examples/step-6/doc/results.dox
examples/step-6/step-6.cc
examples/step-64/step-64.cu
examples/step-65/doc/intro.dox
examples/step-65/doc/results.dox
examples/step-65/step-65.cc
examples/step-66/doc/intro.dox
examples/step-66/step-66.cc
examples/step-67/step-67.cc
examples/step-76/step-76.cc
examples/step-79/step-79.cc
include/deal.II/fe/fe_values.h
include/deal.II/fe/mapping.h
include/deal.II/fe/mapping_c1.h
include/deal.II/fe/mapping_fe.h
include/deal.II/fe/mapping_q.h
include/deal.II/fe/mapping_q1.h
include/deal.II/fe/mapping_q1_eulerian.h
include/deal.II/fe/mapping_q_cache.h
include/deal.II/fe/mapping_q_eulerian.h
include/deal.II/fe/mapping_q_generic.h
include/deal.II/fe/mapping_q_internal.h
include/deal.II/grid/grid_generator.h
include/deal.II/grid/grid_out.h
include/deal.II/grid/manifold.h
include/deal.II/grid/manifold_lib.h
include/deal.II/grid/reference_cell.h
include/deal.II/hp/fe_values.h
include/deal.II/hp/mapping_collection.h
include/deal.II/matrix_free/fe_evaluation.h
include/deal.II/matrix_free/fe_point_evaluation.h
include/deal.II/matrix_free/mapping_data_on_the_fly.h
include/deal.II/matrix_free/mapping_info.templates.h
include/deal.II/numerics/derivative_approximation.h
include/deal.II/numerics/error_estimator.h
include/deal.II/numerics/matrix_tools.h
include/deal.II/numerics/vector_tools.h
include/deal.II/numerics/vector_tools_boundary.h
include/deal.II/numerics/vector_tools_constraints.h
include/deal.II/numerics/vector_tools_integrate_difference.h
include/deal.II/numerics/vector_tools_interpolate.h
include/deal.II/numerics/vector_tools_mean_value.h
include/deal.II/numerics/vector_tools_project.h
include/deal.II/numerics/vector_tools_rhs.h
source/fe/CMakeLists.txt
source/fe/mapping_c1.cc
source/fe/mapping_q.cc
source/fe/mapping_q1.cc
source/fe/mapping_q1_eulerian.cc
source/fe/mapping_q_cache.cc
source/fe/mapping_q_eulerian.cc
source/fe/mapping_q_generic.cc [deleted file]
source/fe/mapping_q_generic.inst.in [deleted file]
source/grid/grid_tools.cc
source/grid/grid_tools_dof_handlers.cc
source/grid/reference_cell.cc
source/hp/mapping_collection.cc
tests/aniso/solution_transfer.cc
tests/bits/find_cell_10.cc
tests/bits/find_cell_10a.cc
tests/bits/find_cell_12.cc
tests/bits/find_cell_7.cc
tests/bits/find_cell_alt_4.cc
tests/bits/find_cell_alt_5.cc
tests/bits/find_cell_alt_6.cc
tests/bits/point_difference_02.cc
tests/bits/point_gradient_02.cc
tests/bits/point_gradient_hp_02.cc
tests/bits/point_value_02.cc
tests/bits/point_value_hp_02.cc
tests/bits/solution_transfer.cc
tests/bits/step-12.cc
tests/bits/step-4_dg_periodic.cc
tests/bits/step-4_dg_periodic_coupling.cc
tests/codim_one/mapping_01.cc
tests/codim_one/mapping_q1.cc
tests/cuda/coefficient_eval.cu
tests/cuda/matrix_free_initialize_vector.cu
tests/cuda/matrix_free_matrix_vector_10.cu
tests/cuda/matrix_free_matrix_vector_10a.cu
tests/cuda/matrix_free_matrix_vector_19.cu
tests/cuda/matrix_free_matrix_vector_25.cu
tests/cuda/matrix_free_multiple_objects.cu
tests/cuda/matrix_free_reinit_01.cu
tests/cuda/matrix_vector_common.h
tests/cuda/precondition_03.cu
tests/data_out/data_out_11.cc
tests/data_out/data_out_base_vtk_04.cc
tests/data_out/data_out_base_vtk_05.cc
tests/data_out/data_out_base_vtu_04.cc
tests/data_out/data_out_base_vtu_05.cc
tests/data_out/data_out_curved_cells.cc
tests/data_out/data_out_mapping_collection_01.cc
tests/distributed_grids/solution_transfer_02.cc
tests/distributed_grids/solution_transfer_03.cc
tests/dofs/dof_tools_04a.cc
tests/dofs/interpolate_based_on_material_id_01.cc
tests/fe/abf_01.cc
tests/fe/abf_02.cc
tests/fe/cell_similarity_01.cc
tests/fe/cell_similarity_02.cc
tests/fe/cell_similarity_dgp_monomial_01.cc
tests/fe/cell_similarity_dgp_monomial_02.cc
tests/fe/cell_similarity_dgp_nonparametric_01.cc
tests/fe/cell_similarity_dgp_nonparametric_02.cc
tests/fe/deformed_projection.h
tests/fe/derivatives.cc
tests/fe/derivatives_bernstein.cc
tests/fe/derivatives_face.cc
tests/fe/fe_face_values_1d.cc
tests/fe/fe_project_2d.cc
tests/fe/fe_project_3d.cc
tests/fe/fe_tools_test.cc
tests/fe/fe_values_function_manifold.cc
tests/fe/fe_values_view_30.cc
tests/fe/shapes_bernstein.cc
tests/fe/shapes_dgp.cc
tests/fe/shapes_dgp_monomial.cc
tests/fe/shapes_dgp_nonparametric.cc
tests/fe/shapes_dgq.cc
tests/fe/shapes_faceq.cc
tests/fe/shapes_nedelec.cc
tests/fe/shapes_q.cc
tests/fe/shapes_q_bubbles.cc
tests/fe/shapes_q_dg0.cc
tests/fe/shapes_q_hierarchical.cc
tests/fe/shapes_q_iso_q1.cc
tests/fe/shapes_system.cc
tests/fe/shapes_system_02.cc
tests/fe/shapes_traceq.cc
tests/fullydistributed_grids/copy_serial_tria_06.cc
tests/grid/find_all_active_cells_around_point_01.cc
tests/grid/find_all_active_cells_around_point_01_b.cc
tests/grid/find_all_active_cells_around_point_02.cc
tests/grid/find_all_active_cells_around_point_03.cc
tests/grid/grid_generator_marching_cube_algorithm_01.cc
tests/grid/grid_generator_open_torus.cc
tests/grid/grid_out_gnuplot_01.cc
tests/grid/grid_tools_aspect_ratio.cc
tests/grid/project_to_object_01.cc
tests/hp/project_01_curved_boundary.cc
tests/hp/solution_transfer.cc
tests/hp/solution_transfer_12.cc
tests/hp/step-12.cc
tests/integrators/assembler_simple_mgmatrix_04.cc
tests/integrators/cochain_01.cc
tests/integrators/mesh_worker_01.cc
tests/integrators/mesh_worker_02.cc
tests/integrators/mesh_worker_03.cc
tests/integrators/mesh_worker_1d_dg.cc
tests/integrators/mesh_worker_matrix_01.cc
tests/lac/block_linear_operator_01.cc
tests/lac/block_linear_operator_02.cc
tests/lac/block_linear_operator_06.cc
tests/lac/linear_operator_02.cc
tests/lac/linear_operator_02a.cc
tests/lac/linear_operator_03.cc
tests/lac/packaged_operation_02.cc
tests/manifold/polar_manifold_06.cc
tests/manifold/spherical_manifold_10.cc
tests/manifold/spherical_manifold_12.cc
tests/manifold/transfinite_manifold_03.cc
tests/mappings/mapping.cc
tests/mappings/mapping_fe_field_05.cc
tests/mappings/mapping_fe_field_06.cc
tests/mappings/mapping_fe_field_07.cc
tests/mappings/mapping_fe_field_08.cc
tests/mappings/mapping_fe_field_08.output
tests/mappings/mapping_get_bounding_box_01.cc
tests/mappings/mapping_get_bounding_box_01.output
tests/mappings/mapping_manifold_01.cc
tests/mappings/mapping_manifold_02.cc
tests/mappings/mapping_manifold_03.cc
tests/mappings/mapping_manifold_04.cc
tests/mappings/mapping_manifold_05.cc
tests/mappings/mapping_manifold_06.cc
tests/mappings/mapping_manifold_07.cc
tests/mappings/mapping_points_real_to_unit.cc
tests/mappings/mapping_project_01.cc
tests/mappings/mapping_q1_cartesian_grid.cc
tests/mappings/mapping_q_cache_01.cc
tests/mappings/mapping_q_cache_02.cc
tests/mappings/mapping_q_cache_03.cc
tests/mappings/mapping_q_cache_04.cc
tests/mappings/mapping_q_cache_05.cc
tests/mappings/mapping_q_cache_06.cc
tests/mappings/mapping_q_cache_07.cc
tests/mappings/mapping_q_cache_08.cc
tests/mappings/mapping_q_eulerian.cc
tests/mappings/mapping_q_inverse_quadratic_approximation.cc
tests/mappings/mapping_q_mixed_manifolds_01.cc
tests/mappings/mapping_q_mixed_manifolds_02.cc
tests/mappings/mapping_q_points_real_to_unit.cc
tests/mappings/mapping_q_quadrature_points.cc
tests/mappings/mapping_q_real_to_unit_internal.cc
tests/mappings/mapping_real_to_unit_02.cc
tests/mappings/mapping_real_to_unit_q1.cc
tests/mappings/mapping_real_to_unit_q1_singular.cc
tests/mappings/mapping_real_to_unit_q1_singular_02.cc
tests/mappings/mapping_real_to_unit_q4_sphere_x.cc
tests/mappings/mapping_real_to_unit_q4_sphere_y.cc
tests/matrix_free/boundary_id.cc
tests/matrix_free/compare_faces_by_cells.cc
tests/matrix_free/compress_mapping.cc
tests/matrix_free/mapping_info_01.cc
tests/matrix_free/matrix_vector_common.h
tests/matrix_free/matrix_vector_faces_14.cc
tests/matrix_free/matrix_vector_faces_29.cc
tests/matrix_free/matrix_vector_faces_common.h
tests/matrix_free/matrix_vector_mg.cc
tests/matrix_free/point_evaluation_01.cc
tests/matrix_free/point_evaluation_02.cc
tests/matrix_free/point_evaluation_03.cc
tests/matrix_free/point_evaluation_04.cc
tests/matrix_free/point_evaluation_09.cc
tests/matrix_free/point_evaluation_10.cc
tests/matrix_free/point_evaluation_11.cc
tests/matrix_free/point_evaluation_12.cc
tests/mpi/derivative_approximation_01.cc
tests/mpi/flux_edge_01.cc
tests/mpi/map_dofs_to_support_points.cc
tests/mpi/mesh_worker_matrix_01.cc
tests/mpi/periodicity_04.cc
tests/mpi/solution_transfer_09.cc
tests/mpi/solution_transfer_10.cc
tests/mpi/step-39-block.cc
tests/mpi/step-39.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-08.cc
tests/multigrid/step-16-50-serial.cc
tests/multigrid/step-16-bdry1.cc
tests/multigrid/step-16.cc
tests/multigrid/step-39-02.cc
tests/multigrid/step-39-02a.cc
tests/multigrid/step-39-03.cc
tests/multigrid/step-39.cc
tests/numerics/derivative_approximation_02.cc
tests/numerics/derivatives.cc
tests/numerics/interpolate_to_different_mesh_01.cc
tests/numerics/interpolate_to_different_mesh_02.cc
tests/numerics/interpolate_to_different_mesh_03.cc
tests/numerics/interpolate_to_different_mesh_04.cc
tests/numerics/project_01_curved_boundary.cc
tests/numerics/project_boundary_rt_01.cc
tests/numerics/project_parallel_qp_common.h
tests/opencascade/normal_to_mesh_projection_03.cc
tests/opencascade/normal_to_mesh_projection_04.cc
tests/particles/generators_03.cc
tests/particles/local_particle_index.cc
tests/remote_point_evaluation/remote_point_evaluation_01.cc
tests/remote_point_evaluation/remote_point_evaluation_02.cc
tests/remote_point_evaluation/remote_point_evaluation_03.cc
tests/remote_point_evaluation/vector_tools_evaluate_at_points_01.cc
tests/remote_point_evaluation/vector_tools_evaluate_at_points_02.cc
tests/remote_point_evaluation/vector_tools_evaluate_at_points_03.cc
tests/remote_point_evaluation/vector_tools_evaluate_at_points_04.cc
tests/remote_point_evaluation/vector_tools_evaluate_at_points_05.cc
tests/simplex/data_out_write_vtk_02.cc
tests/simplex/matrix_free_range_iteration_01.cc
tests/simplex/step-12b.cc
tests/simplex/step-12c.cc
tests/simplex/step-17.cc
tests/simplex/step-18.cc
tests/simplex/step-23.cc
tests/simplex/step-40.cc
tests/simplex/step-67.cc
tests/trilinos/precondition_amg_dgp_01.cc
tests/trilinos/precondition_amg_dgp_03.cc
tests/trilinos/precondition_muelu_dgp.cc
tests/vector_tools/get_position_vector_01.cc
tests/vector_tools/interpolate_with_material_id_01.cc

index f846d216301529c4408c96ca7c106b09d06faab4..2866bf90d5cada811d5456d661ba74c87d2280fe 100644 (file)
@@ -30,8 +30,8 @@ namespace python
                                 void *cell_accessor_ptr,
                                 void *point_ptr)
     {
-      const MappingQGeneric<dim, spacedim> *mapping =
-        static_cast<const MappingQGeneric<dim, spacedim> *>(mapping_ptr);
+      const MappingQ<dim, spacedim> *mapping =
+        static_cast<const MappingQ<dim, spacedim> *>(mapping_ptr);
 
       const CellAccessor<dim, spacedim> *cell_accessor =
         static_cast<const CellAccessor<dim, spacedim> *>(cell_accessor_ptr);
@@ -61,8 +61,8 @@ namespace python
                                 void *cell_accessor_ptr,
                                 void *point_ptr)
     {
-      const MappingQGeneric<dim, spacedim> *mapping =
-        static_cast<const MappingQGeneric<dim, spacedim> *>(mapping_ptr);
+      const MappingQ<dim, spacedim> *mapping =
+        static_cast<const MappingQ<dim, spacedim> *>(mapping_ptr);
 
       const CellAccessor<dim, spacedim> *cell_accessor =
         static_cast<const CellAccessor<dim, spacedim> *>(cell_accessor_ptr);
@@ -93,8 +93,8 @@ namespace python
                                              const unsigned int face_no,
                                              void *             point_ptr)
     {
-      const MappingQGeneric<dim, spacedim> *mapping =
-        static_cast<const MappingQGeneric<dim, spacedim> *>(mapping_ptr);
+      const MappingQ<dim, spacedim> *mapping =
+        static_cast<const MappingQ<dim, spacedim> *>(mapping_ptr);
 
       const CellAccessor<dim, spacedim> *cell_accessor =
         static_cast<const CellAccessor<dim, spacedim> *>(cell_accessor_ptr);
@@ -142,15 +142,15 @@ namespace python
   {
     if ((dim == 2) && (spacedim == 2))
       {
-        mapping_ptr = new MappingQGeneric<2, 2>(degree);
+        mapping_ptr = new MappingQ<2, 2>(degree);
       }
     else if ((dim == 2) && (spacedim == 3))
       {
-        mapping_ptr = new MappingQGeneric<2, 3>(degree);
+        mapping_ptr = new MappingQ<2, 3>(degree);
       }
     else if ((dim == 3) && (spacedim == 3))
       {
-        mapping_ptr = new MappingQGeneric<3, 3>(degree);
+        mapping_ptr = new MappingQ<3, 3>(degree);
       }
     else
       AssertThrow(false, ExcMessage("Wrong dim-spacedim combination."));
@@ -170,15 +170,15 @@ namespace python
 
     if ((dim == 2) && (spacedim == 2))
       {
-        mapping_ptr = new MappingQGeneric<2, 2>(other.degree);
+        mapping_ptr = new MappingQ<2, 2>(other.degree);
       }
     else if ((dim == 2) && (spacedim == 3))
       {
-        mapping_ptr = new MappingQGeneric<2, 3>(other.degree);
+        mapping_ptr = new MappingQ<2, 3>(other.degree);
       }
     else if ((dim == 3) && (spacedim == 3))
       {
-        mapping_ptr = new MappingQGeneric<3, 3>(other.degree);
+        mapping_ptr = new MappingQ<3, 3>(other.degree);
       }
     else
       AssertThrow(false, ExcMessage("Wrong dim-spacedim combination."));
@@ -194,20 +194,17 @@ namespace python
           {
             // We cannot call delete on a void pointer so cast the void pointer
             // back first.
-            MappingQGeneric<2, 2> *tmp =
-              static_cast<MappingQGeneric<2, 2> *>(mapping_ptr);
+            MappingQ<2, 2> *tmp = static_cast<MappingQ<2, 2> *>(mapping_ptr);
             delete tmp;
           }
         else if ((dim == 2) && (spacedim == 3))
           {
-            MappingQGeneric<2, 3> *tmp =
-              static_cast<MappingQGeneric<2, 3> *>(mapping_ptr);
+            MappingQ<2, 3> *tmp = static_cast<MappingQ<2, 3> *>(mapping_ptr);
             delete tmp;
           }
         else
           {
-            MappingQGeneric<3, 3> *tmp =
-              static_cast<MappingQGeneric<3, 3> *>(mapping_ptr);
+            MappingQ<3, 3> *tmp = static_cast<MappingQ<3, 3> *>(mapping_ptr);
             delete tmp;
           }
 
index 9555af64367ada39e5c142f9903e5a40ffc7537f..ddc5c69a84a6009002df82330d7cdce29499d48c 100644 (file)
@@ -651,8 +651,8 @@ namespace python
 
       if (mapping_wrapper.get_mapping() != nullptr)
         {
-          const MappingQGeneric<dim, spacedim> *mapping =
-            static_cast<const MappingQGeneric<dim, spacedim> *>(
+          const MappingQ<dim, spacedim> *mapping =
+            static_cast<const MappingQ<dim, spacedim> *>(
               mapping_wrapper.get_mapping());
 
           auto cell_pair =
@@ -682,8 +682,8 @@ namespace python
       const Quadrature<dim> *quad = static_cast<const Quadrature<dim> *>(
         quadrature_wrapper.get_quadrature());
 
-      const MappingQGeneric<dim, spacedim> *mapping =
-        static_cast<const MappingQGeneric<dim, spacedim> *>(
+      const MappingQ<dim, spacedim> *mapping =
+        static_cast<const MappingQ<dim, spacedim> *>(
           mapping_wrapper.get_mapping());
 
       auto aspect_ratios =
index ebb49bbcd9e181964ff4454d5faf11eee72409b1..37ab1240fff89851ddb788d678a347435fb7988d 100644 (file)
@@ -144,7 +144,7 @@ namespace Step19
     void output_results() const;
 
     Triangulation<dim>        triangulation;
-    MappingQGeneric<dim>      mapping;
+    MappingQ<dim>             mapping;
     FE_Q<dim>                 fe;
     DoFHandler<dim>           dof_handler;
     AffineConstraints<double> constraints;
index 27ae172399642fdeb48114c00194bcc0273d2208..e14b2c5dae9a2a88b3c2146a743040a9c97453f0 100644 (file)
@@ -28,7 +28,7 @@ to use a curved geometry. The way to do this requires three steps:
 - Create an object that describes the desired geometry. This object will be
   queried when refining the Triangulation for new point placement. It will also
   be used to calculate shape function values if a high degree mapping, like
-  MappingQ or MappingQGeneric, is used during system assembly.
+  MappingQ, is used during system assembly.
   In deal.II the Manifold class and classes inheriting from it (e.g.,
   PolarManifold and FlatManifold) perform these calculations.
 - Notify the Triangulation object which Manifold classes to use. By default, a
index 2927a0cab89dd4a0a4235a5b656e22bb19575593..0c7bb638d9881c44b859a8e9da9a56c117ff2dea 100644 (file)
@@ -254,7 +254,7 @@ curved. We can do this by making one change to the gnuplot part of
   std::ofstream output("grid-" + std::to_string(cycle) + ".gnuplot");
   GridOutFlags::Gnuplot gnuplot_flags(false, 5, /*curved_interior_cells*/true);
   grid_out.set_flags(gnuplot_flags);
-  MappingQGeneric<dim> mapping(3);
+  MappingQ<dim> mapping(3);
   grid_out.write_gnuplot(triangulation, output, &mapping);
 }
 @endcode
index 858260b104536d08fba0ae602cf6884941251e24..c34903c5fa3d38fef5f57f778c45de2f4bc85650 100644 (file)
@@ -478,7 +478,7 @@ void Step6<dim>::output_results(const unsigned int cycle) const
     std::ofstream         output("grid-" + std::to_string(cycle) + ".gnuplot");
     GridOutFlags::Gnuplot gnuplot_flags(false, 5);
     grid_out.set_flags(gnuplot_flags);
-    MappingQGeneric<dim> mapping(3);
+    MappingQ<dim> mapping(3);
     grid_out.write_gnuplot(triangulation, output, &mapping);
   }
 
index a1b4a8a5162db1489d1645caa309833876591a42..20e06b3cb27e7a0473d0099189b4e0de86a54a7f 100644 (file)
@@ -264,7 +264,7 @@ namespace Step64
     const DoFHandler<dim> &          dof_handler,
     const AffineConstraints<double> &constraints)
   {
-    MappingQGeneric<dim> mapping(fe_degree);
+    MappingQ<dim> mapping(fe_degree);
     typename CUDAWrappers::MatrixFree<dim, double>::AdditionalData
       additional_data;
     additional_data.mapping_update_flags = update_values | update_gradients |
index 32f8e52de4f0c726fb640284cdc4add2fd497c40..ea3060baef709ffbb8125480e6cd1b3312524ed2 100644 (file)
@@ -191,7 +191,7 @@ above. This class adheres to the general manifold interfaces, i.e., given any
 set of points within its domain of definition, it can compute weighted
 averages conforming to the manifold (using a formula that will be given in a
 minute). These weighted averages are used whenever the mesh is refined, or
-when a higher order mapping (such as MappingQGeneric or MappingC1)
+when a higher order mapping (such as MappingQ or MappingC1)
 is evaluated on a given cell
 subject to this manifold. Using this manifold on the shaded cells of the
 coarse grid of the disk (i.e., not only in the outer-most layer of
@@ -374,7 +374,7 @@ curved mesh elements is the same as the degree of the polynomials for the
 numerical solution. If the degree of the geometry is higher or lower than the
 solution, one calls that a super- or sub-parametric geometry representation,
 respectively. In deal.II, the standard class for polynomial representation is
-MappingQGeneric. If, for example, this class is used with polynomial degree $4$ in 3D, a
+MappingQ. If, for example, this class is used with polynomial degree $4$ in 3D, a
 total of 125 (i.e., $(4+1)^3$) points are needed for the
 interpolation. Among these points, 8 are the cell's vertices and already
 available from the mesh, but the other 117 need to be provided by the
@@ -447,6 +447,6 @@ linear system for solving the Poisson equation with a jumping coefficient, its
 solution with a simple iterative method, computation of some numerical error
 with VectorTools::integrate_difference() as well as an error estimator. We
 record timings for each section and run the code twice. In the first run, we
-hand a MappingQGeneric object to each stage of the program separately, where
+hand a MappingQ object to each stage of the program separately, where
 points get re-computed over and over again. In the second run, we use
 MappingQCache instead.
index fd3e9389d2a13a6300b4ac0df6f423bd7c56c866..f4e2920d8a03af42d18ee49ae3996bb7fff3d61b 100644 (file)
@@ -14,7 +14,7 @@ Scanning dependencies of target \step-65
 [ 66%] Built target \step-65
 [100%] Run \step-65 with Release configuration
 
-====== Running with the basic MappingQGeneric class ======
+====== Running with the basic MappingQ class ======
 
    Number of active cells:       6656
    Number of degrees of freedom: 181609
@@ -83,7 +83,7 @@ impressive for a linear stationary problem, and cost savings would indeed be
 much more prominent for time-dependent and nonlinear problems where assembly
 is called several times. If we look into the individual components, we get a
 clearer picture of what is going on and why the cache is so efficient: In the
-MappingQGeneric case, essentially every operation that involves a mapping take
+MappingQ case, essentially every operation that involves a mapping take
 at least 5 seconds to run. The norm computation runs two
 VectorTools::integrate_difference() functions, which each take almost 5
 seconds. (The computation of constraints is cheaper because it only evaluates
@@ -91,9 +91,9 @@ the mapping in cells at the boundary for the interpolation of boundary
 conditions.) If we compare these 5 seconds to the time it takes to fill the
 MappingQCache, which is 5.2 seconds (for all cells, not just the active ones),
 it becomes obvious that the computation of the mapping support points
-dominates over everything else in the MappingQGeneric case. Perhaps the most
+dominates over everything else in the MappingQ case. Perhaps the most
 striking result is the time for the error estimator, labeled "Compute error
-estimator", where the MappingQGeneric implementation takes 17.3 seconds and
+estimator", where the MappingQ implementation takes 17.3 seconds and
 the MappingQCache variant less than 0.5 seconds. The reason why the former is
 so expensive (three times more expensive than the assembly, for instance) is
 that the error estimation involves evaluation of quantities over faces, where
index 111086142d6e348bd602eaad758ff0bf198a27b0..a6e333025d10becd28cfacc9f6c9a77b0d38ffa4 100644 (file)
@@ -37,7 +37,7 @@
 
 #include <deal.II/fe/fe_q.h>
 #include <deal.II/fe/fe_values.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/dofs/dof_handler.h>
 #include <deal.II/dofs/dof_tools.h>
@@ -582,7 +582,7 @@ namespace Step65
   // solver chain, starting from the setup of the equations, the assembly of
   // the linear system, its solution with a simple iterative solver, and the
   // postprocessing discussed above. The two instances differ in the way they
-  // use the mapping. The first uses a conventional MappingQGeneric mapping
+  // use the mapping. The first uses a conventional MappingQ mapping
   // object which we initialize to a degree one more than we use for the
   // finite element &ndash; after all, we expect the geometry representation
   // to be the bottleneck as the analytic solution is only a quadratic
@@ -600,11 +600,11 @@ namespace Step65
 
     {
       std::cout << std::endl
-                << "====== Running with the basic MappingQGeneric class ====== "
+                << "====== Running with the basic MappingQ class ====== "
                 << std::endl
                 << std::endl;
 
-      MappingQGeneric<dim> mapping(fe.degree + 1);
+      MappingQ<dim> mapping(fe.degree + 1);
       setup_system(mapping);
       assemble_system(mapping);
       solve();
@@ -619,7 +619,7 @@ namespace Step65
     // we want it to show the correct degree functionality in other contexts),
     // we fill the cache via the MappingQCache::initialize() function. At this
     // stage, we specify which mapping we want to use (obviously, the same
-    // MappingQGeneric as previously in order to repeat the same computations)
+    // MappingQ as previously in order to repeat the same computations)
     // for the cache, and then run through the same functions again, now
     // handing in the modified mapping. In the end, we again print the
     // accumulated wall times since the reset to see how the times compare to
@@ -633,7 +633,7 @@ namespace Step65
       MappingQCache<dim> mapping(fe.degree + 1);
       {
         TimerOutput::Scope scope(timer, "Initialize mapping cache");
-        mapping.initialize(MappingQGeneric<dim>(fe.degree + 1), triangulation);
+        mapping.initialize(MappingQ<dim>(fe.degree + 1), triangulation);
       }
       std::cout << "   Memory consumption cache:     "
                 << 1e-6 * mapping.memory_consumption() << " MB" << std::endl;
index 7013ad2dcaf5cafb0a08ad0d3896b52cd1d334ba..1429a72988defae5a0e59bdfa411636f2de13ce9 100644 (file)
@@ -279,6 +279,6 @@ As said in step-37, the matrix-free method gets more efficient if we choose a
 higher order finite element space. Since we want to solve the problem on the
 $d$-dimensional unit ball, it would be good to have an appropriate boundary
 approximation to overcome convergence issues. For this reason we use an
-isoparametric approach with the MappingQGeneric class to recover the smooth
+isoparametric approach with the MappingQ class to recover the smooth
 boundary as well as the mapping for inner cells. In addition, to get a good
 triangulation in total we make use of the TransfiniteInterpolationManifold.
index fec47128e48ef42160bf7be21089a3681388c365..323be0ad0e6f76bc9efc1a9995e4c0705b890a7d 100644 (file)
@@ -30,7 +30,7 @@
 #include <deal.II/dofs/dof_tools.h>
 
 #include <deal.II/fe/fe_q.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/grid_out.h>
@@ -403,13 +403,10 @@ namespace Step66
     // SphericalManifold for boundary cells a TransfiniteInterpolationManifold
     // object for the mapping of the inner cells, which takes care of the inner
     // cells. In this example we use an isoparametric finite element approach
-    // and thus use the MappingQGeneric class. Note, that we could also create
-    // an instance of the MappingQ class and set the
-    // <code>use_mapping_q_on_all_cells</code> flags in the contructor call to
-    // <code>true</code>. For further details on the connection of MappingQ and
-    // MappingQGeneric you may read the detailed description of these classes.
+    // and thus use the MappingQ class. For further details you may read the
+    // detailed description of this class.
     parallel::distributed::Triangulation<dim> triangulation;
-    const MappingQGeneric<dim>                mapping;
+    const MappingQ<dim>                       mapping;
 
 
     // As usual we then define the Lagrangian finite elements FE_Q and a
index a7792f36b95c5367663ba3a6eecb9f38162aef57..ed06de80d87304b26380aa883d36a3de7694d32c 100644 (file)
@@ -1776,9 +1776,9 @@ namespace Euler_DG
     Triangulation<dim> triangulation;
 #endif
 
-    FESystem<dim>        fe;
-    MappingQGeneric<dim> mapping;
-    DoFHandler<dim>      dof_handler;
+    FESystem<dim>   fe;
+    MappingQ<dim>   mapping;
+    DoFHandler<dim> dof_handler;
 
     TimerOutput timer;
 
index 3ac15fb3c2f814650a0338612b6ad40e94504244..fb93b5ea495411c7882f7c3b1c6143c3030287f9 100644 (file)
@@ -1203,9 +1203,9 @@ namespace Euler_DG
     Triangulation<dim> triangulation;
 #endif
 
-    FESystem<dim>        fe;
-    MappingQGeneric<dim> mapping;
-    DoFHandler<dim>      dof_handler;
+    FESystem<dim>   fe;
+    MappingQ<dim>   mapping;
+    DoFHandler<dim> dof_handler;
 
     TimerOutput timer;
 
index 19397f97104f134f2f03463386f5c964abd752d8..ad580750d5d821dfa1782223612c32c7a47c229f 100644 (file)
@@ -756,15 +756,15 @@ namespace SAND
     system_rhs    = 0;
 
 
-    MappingQGeneric<dim> mapping(1);
-    QGauss<dim>          quadrature_formula(fe.degree + 1);
-    QGauss<dim - 1>      face_quadrature_formula(fe.degree + 1);
-    FEValues<dim>        fe_values(mapping,
+    MappingQ<dim>     mapping(1);
+    QGauss<dim>       quadrature_formula(fe.degree + 1);
+    QGauss<dim - 1>   face_quadrature_formula(fe.degree + 1);
+    FEValues<dim>     fe_values(mapping,
                             fe,
                             quadrature_formula,
                             update_values | update_gradients |
                               update_quadrature_points | update_JxW_values);
-    FEFaceValues<dim>    fe_face_values(mapping,
+    FEFaceValues<dim> fe_face_values(mapping,
                                      fe,
                                      face_quadrature_formula,
                                      update_values | update_quadrature_points |
@@ -1304,7 +1304,7 @@ namespace SAND
     BlockVector<double> test_rhs;
     test_rhs.reinit(system_rhs);
 
-    MappingQGeneric<dim>  mapping(1);
+    MappingQ<dim>         mapping(1);
     const QGauss<dim>     quadrature_formula(fe.degree + 1);
     const QGauss<dim - 1> face_quadrature_formula(fe.degree + 1);
     FEValues<dim>         fe_values(mapping,
@@ -1630,7 +1630,7 @@ namespace SAND
     // Start with computing the objective function:
     double objective_function_merit = 0;
     {
-      MappingQGeneric<dim>  mapping(1);
+      MappingQ<dim>         mapping(1);
       const QGauss<dim>     quadrature_formula(fe.degree + 1);
       const QGauss<dim - 1> face_quadrature_formula(fe.degree + 1);
       FEValues<dim>         fe_values(mapping,
index ef9c57c6aa22f61b7db2e6002731b9526d97032e..994f49c3c9146c65695df6babe9841d115ab083c 100644 (file)
@@ -4022,7 +4022,7 @@ public:
   /**
    * Constructor. This constructor is equivalent to the other one except that
    * it makes the object use a $Q_1$ mapping (i.e., an object of type
-   * MappingQGeneric(1)) implicitly.
+   * MappingQ(1)) implicitly.
    */
   FEValues(const FiniteElement<dim, spacedim> &fe,
            const Quadrature<dim> &             quadrature,
@@ -4282,7 +4282,7 @@ public:
   /**
    * Constructor. This constructor is equivalent to the other one except that
    * it makes the object use a $Q_1$ mapping (i.e., an object of type
-   * MappingQGeneric(1)) implicitly.
+   * MappingQ(1)) implicitly.
    */
   FEFaceValues(const FiniteElement<dim, spacedim> &fe,
                const Quadrature<dim - 1> &         quadrature,
@@ -4450,7 +4450,7 @@ public:
   /**
    * Constructor. This constructor is equivalent to the other one except that
    * it makes the object use a $Q_1$ mapping (i.e., an object of type
-   * MappingQGeneric(1)) implicitly.
+   * MappingQ(1)) implicitly.
    */
   FESubfaceValues(const FiniteElement<dim, spacedim> &fe,
                   const Quadrature<dim - 1> &         face_quadrature,
index 1b2ef2674934921dc9d52efe68cb0e11620439a4..6c3809987387690265e8dc6c764432f228bd33c7 100644 (file)
@@ -395,8 +395,8 @@ public:
    * triangulation).
    *
    * For example, implementations in derived classes return @p true for
-   * MappingQ, MappingQGeneric, MappingCartesian, but @p false for
-   * MappingQEulerian, MappingQ1Eulerian, and MappingFEField.
+   * MappingQ, MappingCartesian, but @p false for MappingQEulerian,
+   * MappingQ1Eulerian, and MappingFEField.
    */
   virtual bool
   preserves_vertex_locations() const = 0;
@@ -468,7 +468,7 @@ public:
    * points and calling the Mapping::transform_real_to_unit_cell() function
    * for each point individually, but it can be much faster for certain
    * mappings that implement a more specialized version such as
-   * MappingQGeneric. The only difference in behavior is that this function
+   * MappingQ. The only difference in behavior is that this function
    * will never throw an ExcTransformationFailed() exception. If the
    * transformation fails for `real_points[i]`, the returned `unit_points[i]`
    * contains std::numeric_limits<double>::infinity() as the first entry.
index 621d4547d1e30244de21fc78670c3cf5aa56c3dd..f66df033bfc95b5668f8d7afcf4e5ac31fc6f431 100644 (file)
@@ -28,14 +28,14 @@ DEAL_II_NAMESPACE_OPEN
 
 /**
  * Mapping class that uses C1 (continuously differentiable) cubic mappings of
- * the boundary. This class is built atop of MappingQGeneric by simply
+ * the boundary. This class is built atop of MappingQ by simply
  * determining the interpolation points for a cubic mapping of the boundary
  * differently: MappingQ chooses them such that they interpolate the boundary,
  * while this class chooses them such that the discretized boundary is
  * globally continuously differentiable.
  */
 template <int dim, int spacedim = dim>
-class MappingC1 : public MappingQGeneric<dim, spacedim>
+class MappingC1 : public MappingQ<dim, spacedim>
 {
 public:
   /**
index 2ecca19ddb1704b827f1f819f45dc4ed290d7acb..2fba288dd502dab98fa60a6d44e7951f1dceeb58 100644 (file)
@@ -46,7 +46,7 @@ DEAL_II_NAMESPACE_OPEN
  * discretization, one obtains an iso-parametric mapping.
  *
  * If one initializes this class with an FE_Q(degree) object, then this class is
- * equivalent to MappingQGeneric(degree). Please note that no optimizations
+ * equivalent to MappingQ(degree). Please note that no optimizations
  * exploiting tensor-product structures of finite elements have been added here.
  *
  * @note Currently, only implemented for elements with tensor_degree==1 and
index 5c8262aaa472740447c4e80dd350c1609120d32b..6dfe954b3a914d0028d3eac4b72a4c22cf4efefb 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2001 - 2021 by the deal.II authors
+// Copyright (C) 2000 - 2021 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
 
 #include <deal.II/base/config.h>
 
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/base/derivative_form.h>
+#include <deal.II/base/polynomial.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/table.h>
+#include <deal.II/base/vectorization.h>
+
+#include <deal.II/fe/mapping.h>
+
+#include <deal.II/grid/tria_iterator.h>
+
+#include <deal.II/matrix_free/shape_info.h>
+#include <deal.II/matrix_free/tensor_product_kernels.h>
+
+#include <array>
+#include <cmath>
 
 DEAL_II_NAMESPACE_OPEN
 
+template <int, int>
+class MappingQ;
+
+template <int, int>
+class MappingQCache;
+
+
 /*!@addtogroup mapping */
 /*@{*/
 
+
 /**
- * A class that implements a polynomial mapping $Q_p$ of degree $p$ on all
- * cells. This class is completely equivalent to the MappingQGeneric class.
+ * This class implements the functionality for polynomial mappings $Q_p$ of
+ * polynomial degree $p$ that will be used on all cells of the mesh.  In order
+ * to get a genuine higher-order mapping for all cells, it is important to
+ * provide information about how interior edges and faces of the mesh should
+ * be curved. This is typically done by associating a Manifold with interior
+ * cells and edges. A simple example of this is discussed in the "Results"
+ * section of step-6; a full discussion of manifolds is provided in
+ * step-53. If manifolds are only attached to the boundaries of a domain, the
+ * current class with higher polynomial degrees will provide the same
+ * information as a mere MappingQ1 object. If you are working on meshes that
+ * describe a (curved) manifold embedded in higher space dimensions, i.e., if
+ * dim!=spacedim, then every cell is at the boundary of the domain you will
+ * likely already have attached a manifold object to all cells that can then
+ * also be used by the mapping classes for higher order mappings.
+ *
+ * <h4>Behavior along curved boundaries and with different manifolds</h4>
+ *
+ * For a number of applications, one only knows a manifold description of a
+ * surface but not the interior of the computational domain. In such a case, a
+ * FlatManifold object will be assigned to the interior entities that
+ * describes a usual planar coordinate system where the additional points for
+ * the higher order mapping are placed exactly according to a bi-/trilinear
+ * mapping. When combined with a non-flat manifold on the boundary, for
+ * example a circle bulging into the interior of a square cell, the two
+ * manifold descriptions are in general incompatible. For example, a
+ * FlatManifold defined solely through the cell's vertices would put an
+ * interior point located at some small distance epsilon away from the
+ * boundary along a straight line and thus in general outside the concave part
+ * of a circle. If the polynomial degree of MappingQ is sufficiently high, the
+ * transformation from the reference cell to such a cell would in general
+ * contain inverted regions close to the boundary.
+ *
+ * In order to avoid this situation, this class applies an algorithm for
+ * making this transition smooth using a so-called transfinite interpolation
+ * that is essentially a linear blend between the descriptions along the
+ * surrounding entities. In the algorithm that computes additional points, the
+ * compute_mapping_support_points() method, all the entities of the cells are
+ * passed through hierarchically, starting from the lines to the quads and
+ * finally hexes. Points on objects higher up in the hierarchy are obtained
+ * from the manifold associated with that object, taking into account all the
+ * points previously computed by the manifolds associated with the
+ * lower-dimensional objects, not just the vertices. If only a line is
+ * assigned a curved boundary but the adjacent quad is on a flat manifold, the
+ * flat manifold on the quad will take the points on the deformed line into
+ * account when interpolating the position of the additional points inside the
+ * quad and thus always result in a well-defined transformation.
+ *
+ * The interpolation scheme used in this class makes sure that curved
+ * descriptions can go over to flat descriptions within a single layer of
+ * elements, maintaining the overall optimal convergence rates of the finite
+ * element interpolation. However, this only helps as long as opposite faces
+ * of a cell are far enough away from each other: If a curved part is indeed
+ * curved to the extent that it would come close or even intersect some of the
+ * other faces, as is often the case with long and sliver cells, the current
+ * approach still leads to bad mesh quality. Therefore, the recommended way is
+ * to spread the transition between curved boundaries and flat interior
+ * domains over a larger range as the mesh is refined. This is provided by the
+ * special manifold TransfiniteInterpolationManifold.
  */
 template <int dim, int spacedim = dim>
-class MappingQ : public MappingQGeneric<dim, spacedim>
+class MappingQ : public Mapping<dim, spacedim>
 {
 public:
   /**
    * Constructor.  @p polynomial_degree denotes the polynomial degree of the
-   * polynomials that are used to map cells boundary.
+   * polynomials that are used to map cells from the reference to the real
+   * cell.
    */
   MappingQ(const unsigned int polynomial_degree);
 
@@ -53,10 +132,805 @@ public:
    * Copy constructor.
    */
   MappingQ(const MappingQ<dim, spacedim> &mapping);
+
+  // for documentation, see the Mapping base class
+  virtual std::unique_ptr<Mapping<dim, spacedim>>
+  clone() const override;
+
+  /**
+   * Return the degree of the mapping, i.e. the value which was passed to the
+   * constructor.
+   */
+  unsigned int
+  get_degree() const;
+
+  /**
+   * Always returns @p true because the default implementation of functions in
+   * this class preserves vertex locations.
+   */
+  virtual bool
+  preserves_vertex_locations() const override;
+
+  // for documentation, see the Mapping base class
+  virtual BoundingBox<spacedim>
+  get_bounding_box(const typename Triangulation<dim, spacedim>::cell_iterator
+                     &cell) const override;
+
+  virtual bool
+  is_compatible_with(const ReferenceCell &reference_cell) const override;
+
+  /**
+   * @name Mapping points between reference and real cells
+   * @{
+   */
+
+  // for documentation, see the Mapping base class
+  virtual Point<spacedim>
+  transform_unit_to_real_cell(
+    const typename Triangulation<dim, spacedim>::cell_iterator &cell,
+    const Point<dim> &p) const override;
+
+  // for documentation, see the Mapping base class
+  virtual Point<dim>
+  transform_real_to_unit_cell(
+    const typename Triangulation<dim, spacedim>::cell_iterator &cell,
+    const Point<spacedim> &p) const override;
+
+  // for documentation, see the Mapping base class
+  virtual void
+  transform_points_real_to_unit_cell(
+    const typename Triangulation<dim, spacedim>::cell_iterator &cell,
+    const ArrayView<const Point<spacedim>> &                    real_points,
+    const ArrayView<Point<dim>> &unit_points) const override;
+
+  /**
+   * @}
+   */
+
+  /**
+   * @name Functions to transform tensors from reference to real coordinates
+   * @{
+   */
+
+  // for documentation, see the Mapping base class
+  virtual void
+  transform(const ArrayView<const Tensor<1, dim>> &                  input,
+            const MappingKind                                        kind,
+            const typename Mapping<dim, spacedim>::InternalDataBase &internal,
+            const ArrayView<Tensor<1, spacedim>> &output) const override;
+
+  // for documentation, see the Mapping base class
+  virtual void
+  transform(const ArrayView<const DerivativeForm<1, dim, spacedim>> &input,
+            const MappingKind                                        kind,
+            const typename Mapping<dim, spacedim>::InternalDataBase &internal,
+            const ArrayView<Tensor<2, spacedim>> &output) const override;
+
+  // for documentation, see the Mapping base class
+  virtual void
+  transform(const ArrayView<const Tensor<2, dim>> &                  input,
+            const MappingKind                                        kind,
+            const typename Mapping<dim, spacedim>::InternalDataBase &internal,
+            const ArrayView<Tensor<2, spacedim>> &output) const override;
+
+  // for documentation, see the Mapping base class
+  virtual void
+  transform(const ArrayView<const DerivativeForm<2, dim, spacedim>> &input,
+            const MappingKind                                        kind,
+            const typename Mapping<dim, spacedim>::InternalDataBase &internal,
+            const ArrayView<Tensor<3, spacedim>> &output) const override;
+
+  // for documentation, see the Mapping base class
+  virtual void
+  transform(const ArrayView<const Tensor<3, dim>> &                  input,
+            const MappingKind                                        kind,
+            const typename Mapping<dim, spacedim>::InternalDataBase &internal,
+            const ArrayView<Tensor<3, spacedim>> &output) const override;
+
+  /**
+   * @}
+   */
+
+  /**
+   * @name Interface with FEValues and friends
+   * @{
+   */
+
+  /**
+   * Storage for internal data of polynomial mappings. See
+   * Mapping::InternalDataBase for an extensive description.
+   *
+   * For the current class, the InternalData class stores data that is
+   * computed once when the object is created (in get_data()) as well as data
+   * the class wants to store from between the call to fill_fe_values(),
+   * fill_fe_face_values(), or fill_fe_subface_values() until possible later
+   * calls from the finite element to functions such as transform(). The
+   * latter class of member variables are marked as 'mutable'.
+   */
+  class InternalData : public Mapping<dim, spacedim>::InternalDataBase
+  {
+  public:
+    /**
+     * Constructor. The argument denotes the polynomial degree of the mapping
+     * to which this object will correspond.
+     */
+    InternalData(const unsigned int polynomial_degree);
+
+    /**
+     * Initialize the object's member variables related to cell data based on
+     * the given arguments.
+     *
+     * The function also calls compute_shape_function_values() to actually set
+     * the member variables related to the values and derivatives of the
+     * mapping shape functions.
+     */
+    void
+    initialize(const UpdateFlags      update_flags,
+               const Quadrature<dim> &quadrature,
+               const unsigned int     n_original_q_points);
+
+    /**
+     * Initialize the object's member variables related to cell and face data
+     * based on the given arguments. In order to initialize cell data, this
+     * function calls initialize().
+     */
+    void
+    initialize_face(const UpdateFlags      update_flags,
+                    const Quadrature<dim> &quadrature,
+                    const unsigned int     n_original_q_points);
+
+    /**
+     * Compute the values and/or derivatives of the shape functions used for
+     * the mapping.
+     *
+     * Which values, derivatives, or higher order derivatives are computed is
+     * determined by which of the member arrays have nonzero sizes. They are
+     * typically set to their appropriate sizes by the initialize() and
+     * initialize_face() functions, which indeed call this function
+     * internally. However, it is possible (and at times useful) to do the
+     * resizing by hand and then call this function directly. An example is in
+     * a Newton iteration where we update the location of a quadrature point
+     * (e.g., in MappingQ::transform_real_to_uni_cell()) and need to re-
+     * compute the mapping and its derivatives at this location, but have
+     * already sized all internal arrays correctly.
+     */
+    void
+    compute_shape_function_values(const std::vector<Point<dim>> &unit_points);
+
+    /**
+     * Shape function at quadrature point. Shape functions are in tensor
+     * product order, so vertices must be reordered to obtain transformation.
+     */
+    const double &
+    shape(const unsigned int qpoint, const unsigned int shape_nr) const;
+
+    /**
+     * Shape function at quadrature point. See above.
+     */
+    double &
+    shape(const unsigned int qpoint, const unsigned int shape_nr);
+
+    /**
+     * Gradient of shape function in quadrature point. See above.
+     */
+    const Tensor<1, dim> &
+    derivative(const unsigned int qpoint, const unsigned int shape_nr) const;
+
+    /**
+     * Gradient of shape function in quadrature point. See above.
+     */
+    Tensor<1, dim> &
+    derivative(const unsigned int qpoint, const unsigned int shape_nr);
+
+    /**
+     * Second derivative of shape function in quadrature point. See above.
+     */
+    const Tensor<2, dim> &
+    second_derivative(const unsigned int qpoint,
+                      const unsigned int shape_nr) const;
+
+    /**
+     * Second derivative of shape function in quadrature point. See above.
+     */
+    Tensor<2, dim> &
+    second_derivative(const unsigned int qpoint, const unsigned int shape_nr);
+
+    /**
+     * third derivative of shape function in quadrature point. See above.
+     */
+    const Tensor<3, dim> &
+    third_derivative(const unsigned int qpoint,
+                     const unsigned int shape_nr) const;
+
+    /**
+     * third derivative of shape function in quadrature point. See above.
+     */
+    Tensor<3, dim> &
+    third_derivative(const unsigned int qpoint, const unsigned int shape_nr);
+
+    /**
+     * fourth derivative of shape function in quadrature point. See above.
+     */
+    const Tensor<4, dim> &
+    fourth_derivative(const unsigned int qpoint,
+                      const unsigned int shape_nr) const;
+
+    /**
+     * fourth derivative of shape function in quadrature point. See above.
+     */
+    Tensor<4, dim> &
+    fourth_derivative(const unsigned int qpoint, const unsigned int shape_nr);
+
+    /**
+     * Return an estimate (in bytes) for the memory consumption of this object.
+     */
+    virtual std::size_t
+    memory_consumption() const override;
+
+    /**
+     * Values of shape functions. Access by function @p shape.
+     *
+     * Computed once.
+     */
+    AlignedVector<double> shape_values;
+
+    /**
+     * Values of shape function derivatives. Access by function @p derivative.
+     *
+     * Computed once.
+     */
+    AlignedVector<Tensor<1, dim>> shape_derivatives;
+
+    /**
+     * Values of shape function second derivatives. Access by function @p
+     * second_derivative.
+     *
+     * Computed once.
+     */
+    AlignedVector<Tensor<2, dim>> shape_second_derivatives;
+
+    /**
+     * Values of shape function third derivatives. Access by function @p
+     * second_derivative.
+     *
+     * Computed once.
+     */
+    AlignedVector<Tensor<3, dim>> shape_third_derivatives;
+
+    /**
+     * Values of shape function fourth derivatives. Access by function @p
+     * second_derivative.
+     *
+     * Computed once.
+     */
+    AlignedVector<Tensor<4, dim>> shape_fourth_derivatives;
+
+    /**
+     * Unit tangential vectors. Used for the computation of boundary forms and
+     * normal vectors.
+     *
+     * This array has `(dim-1) * GeometryInfo::faces_per_cell` entries. The
+     * first GeometryInfo::faces_per_cell contain the vectors in the first
+     * tangential direction for each face; the second set of
+     * GeometryInfo::faces_per_cell entries contain the vectors in the second
+     * tangential direction (only in 3d, since there we have 2 tangential
+     * directions per face), etc.
+     *
+     * Filled once.
+     */
+    std::array<std::vector<Tensor<1, dim>>,
+               GeometryInfo<dim>::faces_per_cell *(dim - 1)>
+      unit_tangentials;
+
+    /**
+     * The polynomial degree of the mapping. Since the objects here are also
+     * used (with minor adjustments) by MappingQ, we need to store this.
+     */
+    const unsigned int polynomial_degree;
+
+    /**
+     * Number of shape functions. If this is a Q1 mapping, then it is simply
+     * the number of vertices per cell. However, since also derived classes
+     * use this class (e.g. the Mapping_Q() class), the number of shape
+     * functions may also be different.
+     *
+     * In general, it is $(p+1)^\text{dim}$, where $p$ is the polynomial
+     * degree of the mapping.
+     */
+    const unsigned int n_shape_functions;
+
+    /*
+     * The default line support points. Is used in when the shape function
+     * values are computed.
+     *
+     * The number of quadrature points depends on the degree of this
+     * class, and it matches the number of degrees of freedom of an
+     * FE_Q<1>(this->degree).
+     */
+    QGaussLobatto<1> line_support_points;
+
+    /**
+     * In case the quadrature rule given represents a tensor product
+     * we need to store the evaluations of the 1d polynomials at
+     * the 1d quadrature points. That is what this variable is for.
+     */
+    internal::MatrixFreeFunctions::ShapeInfo<VectorizedArray<double>>
+      shape_info;
+
+    /**
+     * In case the quadrature rule given represents a tensor product
+     * we need to store temporary data in this object.
+     */
+    mutable AlignedVector<VectorizedArray<double>> scratch;
+
+    /**
+     * In case the quadrature rule given represents a tensor product
+     * the values at the mapped support points are stored in this object.
+     */
+    mutable AlignedVector<VectorizedArray<double>> values_dofs;
+
+    /**
+     * In case the quadrature rule given represents a tensor product
+     * the values at the quadrature points are stored in this object.
+     */
+    mutable AlignedVector<VectorizedArray<double>> values_quad;
+
+    /**
+     * In case the quadrature rule given represents a tensor product
+     * the gradients at the quadrature points are stored in this object.
+     */
+    mutable AlignedVector<VectorizedArray<double>> gradients_quad;
+
+    /**
+     * In case the quadrature rule given represents a tensor product
+     * the hessians at the quadrature points are stored in this object.
+     */
+    mutable AlignedVector<VectorizedArray<double>> hessians_quad;
+
+    /**
+     * Indicates whether the given Quadrature object is a tensor product.
+     */
+    bool tensor_product_quadrature;
+
+    /**
+     * Tensors of covariant transformation at each of the quadrature points.
+     * The matrix stored is the Jacobian * G^{-1}, where G = Jacobian^{t} *
+     * Jacobian, is the first fundamental form of the map; if dim=spacedim
+     * then it reduces to the transpose of the inverse of the Jacobian matrix,
+     * which itself is stored in the @p contravariant field of this structure.
+     *
+     * Computed on each cell.
+     */
+    mutable AlignedVector<DerivativeForm<1, dim, spacedim>> covariant;
+
+    /**
+     * Tensors of contravariant transformation at each of the quadrature
+     * points. The contravariant matrix is the Jacobian of the transformation,
+     * i.e. $J_{ij}=dx_i/d\hat x_j$.
+     *
+     * Computed on each cell.
+     */
+    mutable AlignedVector<DerivativeForm<1, dim, spacedim>> contravariant;
+
+    /**
+     * Auxiliary vectors for internal use.
+     */
+    mutable std::vector<AlignedVector<Tensor<1, spacedim>>> aux;
+
+    /**
+     * Stores the support points of the mapping shape functions on the @p
+     * cell_of_current_support_points.
+     */
+    mutable std::vector<Point<spacedim>> mapping_support_points;
+
+    /**
+     * Stores the cell of which the @p mapping_support_points are stored.
+     */
+    mutable typename Triangulation<dim, spacedim>::cell_iterator
+      cell_of_current_support_points;
+
+    /**
+     * The determinant of the Jacobian in each quadrature point. Filled if
+     * #update_volume_elements.
+     */
+    mutable AlignedVector<double> volume_elements;
+  };
+
+
+  // documentation can be found in Mapping::requires_update_flags()
+  virtual UpdateFlags
+  requires_update_flags(const UpdateFlags update_flags) const override;
+
+  // documentation can be found in Mapping::get_data()
+  virtual std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase>
+  get_data(const UpdateFlags, const Quadrature<dim> &quadrature) const override;
+
+  using Mapping<dim, spacedim>::get_face_data;
+
+  // documentation can be found in Mapping::get_face_data()
+  virtual std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase>
+  get_face_data(const UpdateFlags               flags,
+                const hp::QCollection<dim - 1> &quadrature) const override;
+
+  // documentation can be found in Mapping::get_subface_data()
+  virtual std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase>
+  get_subface_data(const UpdateFlags          flags,
+                   const Quadrature<dim - 1> &quadrature) const override;
+
+  // documentation can be found in Mapping::fill_fe_values()
+  virtual CellSimilarity::Similarity
+  fill_fe_values(
+    const typename Triangulation<dim, spacedim>::cell_iterator &cell,
+    const CellSimilarity::Similarity                            cell_similarity,
+    const Quadrature<dim> &                                     quadrature,
+    const typename Mapping<dim, spacedim>::InternalDataBase &   internal_data,
+    dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
+      &output_data) const override;
+
+  using Mapping<dim, spacedim>::fill_fe_face_values;
+
+  // documentation can be found in Mapping::fill_fe_face_values()
+  virtual void
+  fill_fe_face_values(
+    const typename Triangulation<dim, spacedim>::cell_iterator &cell,
+    const unsigned int                                          face_no,
+    const hp::QCollection<dim - 1> &                            quadrature,
+    const typename Mapping<dim, spacedim>::InternalDataBase &   internal_data,
+    dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
+      &output_data) const override;
+
+  // documentation can be found in Mapping::fill_fe_subface_values()
+  virtual void
+  fill_fe_subface_values(
+    const typename Triangulation<dim, spacedim>::cell_iterator &cell,
+    const unsigned int                                          face_no,
+    const unsigned int                                          subface_no,
+    const Quadrature<dim - 1> &                                 quadrature,
+    const typename Mapping<dim, spacedim>::InternalDataBase &   internal_data,
+    dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
+      &output_data) const override;
+
+
+  /**
+   * As opposed to the other fill_fe_values() and fill_fe_face_values()
+   * functions that rely on pre-computed information of InternalDataBase, this
+   * function chooses the flexible evaluation path on the cell and points
+   * passed in to the current function.
+   *
+   * @param[in] cell The cell where to evaluate the mapping
+   *
+   * @param[in] unit_points The points in reference coordinates where the
+   * transformation (Jacobians, positions) should be computed.
+   *
+   * @param[in] update_flags The kind of information that should be computed.
+   *
+   * @param[out] output_data A struct containing the evaluated quantities such
+   * as the Jacobian resulting from application of the mapping on the given
+   * cell with its underlying manifolds.
+   */
+  void
+  fill_mapping_data_for_generic_points(
+    const typename Triangulation<dim, spacedim>::cell_iterator &cell,
+    const ArrayView<const Point<dim>> &                         unit_points,
+    const UpdateFlags                                           update_flags,
+    dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
+      &output_data) const;
+
+  /**
+   * @}
+   */
+
+protected:
+  /**
+   * The degree of the polynomials used as shape functions for the mapping of
+   * cells.
+   */
+  const unsigned int polynomial_degree;
+
+  /*
+   * The default line support points. These are used when computing the
+   * location in real space of the support points on lines and quads, which
+   * are needed by the Manifold<dim,spacedim> class.
+   *
+   * The number of points depends on the degree of this class, and it matches
+   * the number of degrees of freedom of an FE_Q<1>(this->degree).
+   */
+  const std::vector<Point<1>> line_support_points;
+
+  /*
+   * The one-dimensional polynomials defined as Lagrange polynomials from the
+   * line support points. These are used for point evaluations and match the
+   * polynomial space of an FE_Q<1>(this->degree).
+   */
+  const std::vector<Polynomials::Polynomial<double>> polynomials_1d;
+
+  /*
+   * The numbering from the lexicographic to the hierarchical ordering used
+   * when expanding the tensor product with the mapping support points (which
+   * come in hierarchical numbers).
+   */
+  const std::vector<unsigned int> renumber_lexicographic_to_hierarchic;
+
+  /*
+   * The support points in reference coordinates. These are used for
+   * constructing approximations of the output of
+   * compute_mapping_support_points() when evaluating the mapping on the fly,
+   * rather than going through the FEValues interface provided by
+   * InternalData.
+   *
+   * The number of points depends on the degree of this class, and it matches
+   * the number of degrees of freedom of an FE_Q<dim>(this->degree).
+   */
+  const std::vector<Point<dim>> unit_cell_support_points;
+
+  /**
+   * A vector of tables of weights by which we multiply the locations of the
+   * support points on the perimeter of an object (line, quad, hex) to get the
+   * location of interior support points.
+   *
+   * Access into this table is by @p [structdim-1], i.e., use 0 to access the
+   * support point weights on a line (i.e., the interior points of the
+   * GaussLobatto quadrature), use 1 to access the support point weights from
+   * to perimeter to the interior of a quad, and use 2 to access the support
+   * point weights from the perimeter to the interior of a hex.
+   *
+   * The table itself contains as many columns as there are surrounding points
+   * to a particular object (2 for a line, <code>4 + 4*(degree-1)</code> for
+   * a quad, <code>8 + 12*(degree-1) + 6*(degree-1)*(degree-1)</code> for a
+   * hex) and as many rows as there are strictly interior points.
+   *
+   * For the definition of this table see equation (8) of the `mapping'
+   * report.
+   */
+  const std::vector<Table<2, double>>
+    support_point_weights_perimeter_to_interior;
+
+  /**
+   * A table of weights by which we multiply the locations of the vertex
+   * points of the cell to get the location of all additional support points,
+   * both on lines, quads, and hexes (as appropriate). This data structure is
+   * used when we fill all support points at once, which is the case if the
+   * same manifold is attached to all sub-entities of a cell. This way, we can
+   * avoid some of the overhead in transforming data for mappings.
+   *
+   * The table has as many rows as there are vertices to the cell (2 in 1D, 4
+   * in 2D, 8 in 3D), and as many rows as there are additional support points
+   * in the mapping, i.e., <code>(degree+1)^dim - 2^dim</code>.
+   */
+  const Table<2, double> support_point_weights_cell;
+
+  /**
+   * Return the locations of support points for the mapping. For example, for
+   * $Q_1$ mappings these are the vertices, and for higher order polynomial
+   * mappings they are the vertices plus interior points on edges, faces, and
+   * the cell interior that are placed in consultation with the Manifold
+   * description of the domain and its boundary. However, other classes may
+   * override this function differently. In particular, the MappingQ1Eulerian
+   * class does exactly this by not computing the support points from the
+   * geometry of the current cell but instead evaluating an externally given
+   * displacement field in addition to the geometry of the cell.
+   *
+   * The default implementation of this function is appropriate for most
+   * cases. It takes the locations of support points on the boundary of the
+   * cell from the underlying manifold. Interior support points (ie. support
+   * points in quads for 2d, in hexes for 3d) are then computed using an
+   * interpolation from the lower-dimensional entities (lines, quads) in order
+   * to make the transformation as smooth as possible without introducing
+   * additional boundary layers within the cells due to the placement of
+   * support points.
+   *
+   * The function works its way from the vertices (which it takes from the
+   * given cell) via the support points on the line (for which it calls the
+   * add_line_support_points() function) and the support points on the quad
+   * faces (in 3d, for which it calls the add_quad_support_points() function).
+   * It then adds interior support points that are either computed by
+   * interpolation from the surrounding points using weights for transfinite
+   * interpolation, or if dim<spacedim, it asks the underlying manifold for
+   * the locations of interior points.
+   */
+  virtual std::vector<Point<spacedim>>
+  compute_mapping_support_points(
+    const typename Triangulation<dim, spacedim>::cell_iterator &cell) const;
+
+  /**
+   * Transform the point @p p on the real cell to the corresponding point on
+   * the unit cell @p cell by a Newton iteration.
+   */
+  Point<dim>
+  transform_real_to_unit_cell_internal(
+    const typename Triangulation<dim, spacedim>::cell_iterator &cell,
+    const Point<spacedim> &                                     p,
+    const Point<dim> &initial_p_unit) const;
+
+  /**
+   * Append the support points of all shape functions located on bounding
+   * lines of the given cell to the vector @p a. Points located on the
+   * vertices of a line are not included.
+   *
+   * This function uses the underlying manifold object of the line (or, if
+   * none is set, of the cell) for the location of the requested points. This
+   * function is usually called by compute_mapping_support_points() function.
+   *
+   * This function is made virtual in order to allow derived classes to choose
+   * shape function support points differently than the present class, which
+   * chooses the points as interpolation points on the boundary.
+   */
+  virtual void
+  add_line_support_points(
+    const typename Triangulation<dim, spacedim>::cell_iterator &cell,
+    std::vector<Point<spacedim>> &                              a) const;
+
+  /**
+   * Append the support points of all shape functions located on bounding
+   * faces (quads in 3d) of the given cell to the vector @p a. This function
+   * is only defined for <tt>dim=3</tt>. Points located on the vertices or
+   * lines of a quad are not included.
+   *
+   * This function uses the underlying manifold object of the quad (or, if
+   * none is set, of the cell) for the location of the requested points. This
+   * function is usually called by compute_mapping_support_points().
+   *
+   * This function is made virtual in order to allow derived classes to choose
+   * shape function support points differently than the present class, which
+   * chooses the points as interpolation points on the boundary.
+   */
+  virtual void
+  add_quad_support_points(
+    const typename Triangulation<dim, spacedim>::cell_iterator &cell,
+    std::vector<Point<spacedim>> &                              a) const;
+
+  // Make MappingQCache a friend since it needs to call the
+  // compute_mapping_support_points() function.
+  template <int, int>
+  friend class MappingQCache;
 };
 
+
+
+/**
+ * A class that implements a polynomial mapping $Q_p$ of degree $p$ on all
+ * cells. This class is completely equivalent to the MappingQ class and there
+ * for backward compatibility.
+ */
+template <int dim, int spacedim = dim>
+using MappingQGeneric = MappingQ<dim, spacedim>;
+
 /*@}*/
 
+
+/*----------------------------------------------------------------------*/
+
+#ifndef DOXYGEN
+
+template <int dim, int spacedim>
+inline const double &
+MappingQ<dim, spacedim>::InternalData::shape(const unsigned int qpoint,
+                                             const unsigned int shape_nr) const
+{
+  AssertIndexRange(qpoint * n_shape_functions + shape_nr, shape_values.size());
+  return shape_values[qpoint * n_shape_functions + shape_nr];
+}
+
+
+
+template <int dim, int spacedim>
+inline double &
+MappingQ<dim, spacedim>::InternalData::shape(const unsigned int qpoint,
+                                             const unsigned int shape_nr)
+{
+  AssertIndexRange(qpoint * n_shape_functions + shape_nr, shape_values.size());
+  return shape_values[qpoint * n_shape_functions + shape_nr];
+}
+
+
+template <int dim, int spacedim>
+inline const Tensor<1, dim> &
+MappingQ<dim, spacedim>::InternalData::derivative(
+  const unsigned int qpoint,
+  const unsigned int shape_nr) const
+{
+  AssertIndexRange(qpoint * n_shape_functions + shape_nr,
+                   shape_derivatives.size());
+  return shape_derivatives[qpoint * n_shape_functions + shape_nr];
+}
+
+
+
+template <int dim, int spacedim>
+inline Tensor<1, dim> &
+MappingQ<dim, spacedim>::InternalData::derivative(const unsigned int qpoint,
+                                                  const unsigned int shape_nr)
+{
+  AssertIndexRange(qpoint * n_shape_functions + shape_nr,
+                   shape_derivatives.size());
+  return shape_derivatives[qpoint * n_shape_functions + shape_nr];
+}
+
+
+template <int dim, int spacedim>
+inline const Tensor<2, dim> &
+MappingQ<dim, spacedim>::InternalData::second_derivative(
+  const unsigned int qpoint,
+  const unsigned int shape_nr) const
+{
+  AssertIndexRange(qpoint * n_shape_functions + shape_nr,
+                   shape_second_derivatives.size());
+  return shape_second_derivatives[qpoint * n_shape_functions + shape_nr];
+}
+
+
+template <int dim, int spacedim>
+inline Tensor<2, dim> &
+MappingQ<dim, spacedim>::InternalData::second_derivative(
+  const unsigned int qpoint,
+  const unsigned int shape_nr)
+{
+  AssertIndexRange(qpoint * n_shape_functions + shape_nr,
+                   shape_second_derivatives.size());
+  return shape_second_derivatives[qpoint * n_shape_functions + shape_nr];
+}
+
+template <int dim, int spacedim>
+inline const Tensor<3, dim> &
+MappingQ<dim, spacedim>::InternalData::third_derivative(
+  const unsigned int qpoint,
+  const unsigned int shape_nr) const
+{
+  AssertIndexRange(qpoint * n_shape_functions + shape_nr,
+                   shape_third_derivatives.size());
+  return shape_third_derivatives[qpoint * n_shape_functions + shape_nr];
+}
+
+
+template <int dim, int spacedim>
+inline Tensor<3, dim> &
+MappingQ<dim, spacedim>::InternalData::third_derivative(
+  const unsigned int qpoint,
+  const unsigned int shape_nr)
+{
+  AssertIndexRange(qpoint * n_shape_functions + shape_nr,
+                   shape_third_derivatives.size());
+  return shape_third_derivatives[qpoint * n_shape_functions + shape_nr];
+}
+
+
+template <int dim, int spacedim>
+inline const Tensor<4, dim> &
+MappingQ<dim, spacedim>::InternalData::fourth_derivative(
+  const unsigned int qpoint,
+  const unsigned int shape_nr) const
+{
+  AssertIndexRange(qpoint * n_shape_functions + shape_nr,
+                   shape_fourth_derivatives.size());
+  return shape_fourth_derivatives[qpoint * n_shape_functions + shape_nr];
+}
+
+
+template <int dim, int spacedim>
+inline Tensor<4, dim> &
+MappingQ<dim, spacedim>::InternalData::fourth_derivative(
+  const unsigned int qpoint,
+  const unsigned int shape_nr)
+{
+  AssertIndexRange(qpoint * n_shape_functions + shape_nr,
+                   shape_fourth_derivatives.size());
+  return shape_fourth_derivatives[qpoint * n_shape_functions + shape_nr];
+}
+
+
+
+template <int dim, int spacedim>
+inline bool
+MappingQ<dim, spacedim>::preserves_vertex_locations() const
+{
+  return true;
+}
+
+#endif // DOXYGEN
+
+/* -------------- declaration of explicit specializations ------------- */
+
+
 DEAL_II_NAMESPACE_CLOSE
 
 #endif
index dc9acd4ce08ac254e06e7b78acd06732c33456d4..cccdec4f2757641a2a22b1ae7657d71e50c94eb8 100644 (file)
@@ -19,7 +19,7 @@
 
 #include <deal.II/base/config.h>
 
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <cmath>
 
@@ -40,7 +40,7 @@ DEAL_II_NAMESPACE_OPEN
  * polyhedral domains. It is also the mapping used throughout deal.II for many
  * functions that come in two variants, one that allows to pass a mapping
  * argument explicitly and one that simply falls back to the MappingQ1 class
- * declared here. (Or, in fact, to an object of kind MappingQGeneric(1), which
+ * declared here. (Or, in fact, to an object of kind MappingQ(1), which
  * implements exactly the functionality of this class.)
  *
  * The shape functions for this mapping are the same as for the finite element
@@ -48,10 +48,10 @@ DEAL_II_NAMESPACE_OPEN
  * isoparametric element.
  *
  * @note This class is, in all reality, nothing more than a different name for
- * calling MappingQGeneric with a polynomial degree of one as argument.
+ * calling MappingQ with a polynomial degree of one as argument.
  */
 template <int dim, int spacedim = dim>
-class MappingQ1 : public MappingQGeneric<dim, spacedim>
+class MappingQ1 : public MappingQ<dim, spacedim>
 {
 public:
   /**
@@ -70,7 +70,7 @@ public:
  * Many places in the library by default use (bi-,tri-)linear mappings unless
  * users explicitly provide a different mapping to use. In these cases, the
  * called function has to create a $Q_1$ mapping object, i.e., an object of
- * kind MappingQGeneric(1). This is costly. It would also be costly to create
+ * kind MappingQ(1). This is costly. It would also be costly to create
  * such objects as static objects in the affected functions, because static
  * objects are never destroyed throughout the lifetime of a program, even
  * though they only have to be created once the first time code runs through a
@@ -94,7 +94,7 @@ struct StaticMappingQ1
    * The static $Q_1$ mapping object discussed in the documentation of this
    * class.
    */
-  static MappingQGeneric<dim, spacedim> mapping;
+  static MappingQ<dim, spacedim> mapping;
 };
 
 
index 4431a5bf80e85b7901b61d098c1ca32d4d742cce..1313d4aadf5b1a6cc4fb538ee777d017d490732e 100644 (file)
@@ -90,7 +90,7 @@ class Vector;
  * the documentation of FiniteElement or the one of Triangulation.
  */
 template <int dim, typename VectorType = Vector<double>, int spacedim = dim>
-class MappingQ1Eulerian : public MappingQGeneric<dim, spacedim>
+class MappingQ1Eulerian : public MappingQ<dim, spacedim>
 {
 public:
   /**
@@ -164,7 +164,7 @@ protected:
   /**
    * Compute the support points of the mapping. For the current class, these
    * are the vertices, as obtained by calling Mapping::get_vertices(). See the
-   * documentation of MappingQGeneric::compute_mapping_support_points() for
+   * documentation of MappingQ::compute_mapping_support_points() for
    * more information.
    */
   virtual std::vector<Point<spacedim>>
index 2a29154d4cb81498d615467245c9df8a113a3731..96cb1988202cf1247eb6c624b62169c251eaec30 100644 (file)
@@ -22,7 +22,7 @@
 #include <deal.II/base/function.h>
 #include <deal.II/base/mg_level_object.h>
 
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/tria.h>
 
@@ -42,14 +42,14 @@ class DoFHandler;
 
 /**
  * This class implements a caching strategy for objects of the MappingQ family
- * in terms of the MappingQGeneric::compute_mapping_support_points() function,
- * which is used in all operations of MappingQGeneric. The information of the
+ * in terms of the MappingQ::compute_mapping_support_points() function,
+ * which is used in all operations of MappingQ. The information of the
  * mapping is pre-computed by the MappingQCache::initialize() function.
  *
  * The use of this class is discussed extensively in step-65.
  */
 template <int dim, int spacedim = dim>
-class MappingQCache : public MappingQGeneric<dim, spacedim>
+class MappingQCache : public MappingQ<dim, spacedim>
 {
 public:
   /**
@@ -103,8 +103,8 @@ public:
    * @deprecated Use initialize() version above instead.
    */
   DEAL_II_DEPRECATED void
-  initialize(const Triangulation<dim, spacedim> &  triangulation,
-             const MappingQGeneric<dim, spacedim> &mapping);
+  initialize(const Triangulation<dim, spacedim> &triangulation,
+             const MappingQ<dim, spacedim> &     mapping);
 
   /**
    * Initialize the data cache by letting the function given as an argument
@@ -219,7 +219,7 @@ public:
 
 protected:
   /**
-   * This is the main function overridden from the base class MappingQGeneric.
+   * This is the main function overridden from the base class MappingQ.
    */
   virtual std::vector<Point<spacedim>>
   compute_mapping_support_points(
index bd1a4686e61d8f661c0e77bbd6e4a146b0597e70..dc34260652d3b6914811c1b28a6387c1fa2ba906 100644 (file)
@@ -90,7 +90,7 @@ class Vector;
  * of the vector can be specified as template parameter <tt>VectorType</tt>.
  */
 template <int dim, typename VectorType = Vector<double>, int spacedim = dim>
-class MappingQEulerian : public MappingQGeneric<dim, spacedim>
+class MappingQEulerian : public MappingQ<dim, spacedim>
 {
 public:
   /**
index bb8a58f4c980c9d4beeffcac5121d1d875a3f2fb..67bd8edf2e18fc9966c639ff57b6a861e38d7b84 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2000 - 2021 by the deal.II authors
+// Copyright (C) 2001 - 2021 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
 
 #include <deal.II/base/config.h>
 
-#include <deal.II/base/derivative_form.h>
-#include <deal.II/base/polynomial.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/table.h>
-#include <deal.II/base/vectorization.h>
+#include <deal.II/fe/mapping_q.h>
 
-#include <deal.II/fe/mapping.h>
-
-#include <deal.II/grid/tria_iterator.h>
-
-#include <deal.II/matrix_free/shape_info.h>
-#include <deal.II/matrix_free/tensor_product_kernels.h>
-
-#include <array>
-#include <cmath>
-
-DEAL_II_NAMESPACE_OPEN
-
-template <int, int>
-class MappingQ;
-
-template <int, int>
-class MappingQCache;
-
-
-/*!@addtogroup mapping */
-/*@{*/
-
-
-/**
- * This class implements the functionality for polynomial mappings $Q_p$ of
- * polynomial degree $p$ that will be used on all cells of the mesh. The
- * MappingQ1 and MappingQ classes specialize this behavior slightly.
- *
- * The class is poorly named. It should really have been called MappingQ
- * because it consistently uses $Q_p$ mappings on all cells of a
- * triangulation. However, the name MappingQ was already taken when we rewrote
- * the entire class hierarchy for mappings. One might argue that one should
- * always use MappingQGeneric over the existing class MappingQ (which, unless
- * explicitly specified during the construction of the object, only uses
- * mappings of degree $p$ <i>on cells at the boundary of the domain</i>). On
- * the other hand, there are good reasons to use MappingQ in many situations:
- * in many situations, curved domains are only provided with information about
- * how exactly edges at the boundary are shaped, but we do not know anything
- * about internal edges. Thus, in the absence of other information, we can
- * only assume that internal edges are straight lines, and in that case
- * internal cells may as well be treated is bilinear quadrilaterals or
- * trilinear hexahedra. (An example of how such meshes look is shown in step-1
- * already, but it is also discussed in the "Results" section of step-6.)
- * Because bi-/trilinear mappings are significantly cheaper to compute than
- * higher order mappings, it is advantageous in such situations to use the
- * higher order mapping only on cells at the boundary of the domain -- i.e.,
- * the behavior of MappingQ. Of course, MappingQGeneric also uses bilinear
- * mappings for interior cells as long as it has no knowledge about curvature
- * of interior edges, but it implements this the expensive way: as a general
- * $Q_p$ mapping where the mapping support points just <i>happen</i> to be
- * arranged along linear or bilinear edges or faces.
- *
- * There are a number of special cases worth considering:
- * - If you really want to use a higher order mapping for all cells,
- * you can do this using the current class, but this only makes sense if you
- * can actually provide information about how interior edges and faces of the
- * mesh should be curved. This is typically done by associating a Manifold
- * with interior cells and edges. A simple example of this is discussed in the
- * "Results" section of step-6; a full discussion of manifolds is provided in
- * step-53.
- * - If you are working on meshes that describe a (curved) manifold
- * embedded in higher space dimensions, i.e., if dim!=spacedim, then every
- * cell is at the boundary of the domain you will likely already have attached
- * a manifold object to all cells that can then also be used by the mapping
- * classes for higher order mappings.
- *
- * <h4>Behavior along curved boundaries and with different manifolds</h4>
- *
- * As described above, one often only knows a manifold description of a
- * surface but not the interior of the computational domain. In such a case, a
- * FlatManifold object will be assigned to the interior entities that
- * describes a usual planar coordinate system where the additional points for
- * the higher order mapping are placed exactly according to a bi-/trilinear
- * mapping. When combined with a non-flat manifold on the boundary, for
- * example a circle bulging into the interior of a square cell, the two
- * manifold descriptions are in general incompatible. For example, a
- * FlatManifold defined solely through the cell's vertices would put an
- * interior point located at some small distance epsilon away from the
- * boundary along a straight line and thus in general outside the concave part
- * of a circle. If the polynomial degree of MappingQ is sufficiently high, the
- * transformation from the reference cell to such a cell would in general
- * contain inverted regions close to the boundary.
- *
- * In order to avoid this situation, this class applies an algorithm for
- * making this transition smooth using a so-called transfinite interpolation
- * that is essentially a linear blend between the descriptions along the
- * surrounding entities. In the algorithm that computes additional points, the
- * compute_mapping_support_points() method, all the entities of the cells are
- * passed through hierarchically, starting from the lines to the quads and
- * finally hexes. Points on objects higher up in the hierarchy are obtained
- * from the manifold associated with that object, taking into account all the
- * points previously computed by the manifolds associated with the
- * lower-dimensional objects, not just the vertices. If only a line is
- * assigned a curved boundary but the adjacent quad is on a flat manifold, the
- * flat manifold on the quad will take the points on the deformed line into
- * account when interpolating the position of the additional points inside the
- * quad and thus always result in a well-defined transformation.
- *
- * The interpolation scheme used in this class makes sure that curved
- * descriptions can go over to flat descriptions within a single layer of
- * elements, maintaining the overall optimal convergence rates of the finite
- * element interpolation. However, one does often get better solution
- * qualities if the transition between curved boundaries and flat interior
- * domains is spread over a larger range as the mesh is refined. This is
- * provided by the special manifold TransfiniteInterpolationManifold.
- */
-template <int dim, int spacedim = dim>
-class MappingQGeneric : public Mapping<dim, spacedim>
-{
-public:
-  /**
-   * Constructor.  @p polynomial_degree denotes the polynomial degree of the
-   * polynomials that are used to map cells from the reference to the real
-   * cell.
-   */
-  MappingQGeneric(const unsigned int polynomial_degree);
-
-  /**
-   * Copy constructor.
-   */
-  MappingQGeneric(const MappingQGeneric<dim, spacedim> &mapping);
-
-  // for documentation, see the Mapping base class
-  virtual std::unique_ptr<Mapping<dim, spacedim>>
-  clone() const override;
-
-  /**
-   * Return the degree of the mapping, i.e. the value which was passed to the
-   * constructor.
-   */
-  unsigned int
-  get_degree() const;
-
-  /**
-   * Always returns @p true because the default implementation of functions in
-   * this class preserves vertex locations.
-   */
-  virtual bool
-  preserves_vertex_locations() const override;
-
-  // for documentation, see the Mapping base class
-  virtual BoundingBox<spacedim>
-  get_bounding_box(const typename Triangulation<dim, spacedim>::cell_iterator
-                     &cell) const override;
-
-  virtual bool
-  is_compatible_with(const ReferenceCell &reference_cell) const override;
-
-  /**
-   * @name Mapping points between reference and real cells
-   * @{
-   */
-
-  // for documentation, see the Mapping base class
-  virtual Point<spacedim>
-  transform_unit_to_real_cell(
-    const typename Triangulation<dim, spacedim>::cell_iterator &cell,
-    const Point<dim> &p) const override;
-
-  // for documentation, see the Mapping base class
-  virtual Point<dim>
-  transform_real_to_unit_cell(
-    const typename Triangulation<dim, spacedim>::cell_iterator &cell,
-    const Point<spacedim> &p) const override;
-
-  // for documentation, see the Mapping base class
-  virtual void
-  transform_points_real_to_unit_cell(
-    const typename Triangulation<dim, spacedim>::cell_iterator &cell,
-    const ArrayView<const Point<spacedim>> &                    real_points,
-    const ArrayView<Point<dim>> &unit_points) const override;
-
-  /**
-   * @}
-   */
-
-  /**
-   * @name Functions to transform tensors from reference to real coordinates
-   * @{
-   */
-
-  // for documentation, see the Mapping base class
-  virtual void
-  transform(const ArrayView<const Tensor<1, dim>> &                  input,
-            const MappingKind                                        kind,
-            const typename Mapping<dim, spacedim>::InternalDataBase &internal,
-            const ArrayView<Tensor<1, spacedim>> &output) const override;
-
-  // for documentation, see the Mapping base class
-  virtual void
-  transform(const ArrayView<const DerivativeForm<1, dim, spacedim>> &input,
-            const MappingKind                                        kind,
-            const typename Mapping<dim, spacedim>::InternalDataBase &internal,
-            const ArrayView<Tensor<2, spacedim>> &output) const override;
-
-  // for documentation, see the Mapping base class
-  virtual void
-  transform(const ArrayView<const Tensor<2, dim>> &                  input,
-            const MappingKind                                        kind,
-            const typename Mapping<dim, spacedim>::InternalDataBase &internal,
-            const ArrayView<Tensor<2, spacedim>> &output) const override;
-
-  // for documentation, see the Mapping base class
-  virtual void
-  transform(const ArrayView<const DerivativeForm<2, dim, spacedim>> &input,
-            const MappingKind                                        kind,
-            const typename Mapping<dim, spacedim>::InternalDataBase &internal,
-            const ArrayView<Tensor<3, spacedim>> &output) const override;
-
-  // for documentation, see the Mapping base class
-  virtual void
-  transform(const ArrayView<const Tensor<3, dim>> &                  input,
-            const MappingKind                                        kind,
-            const typename Mapping<dim, spacedim>::InternalDataBase &internal,
-            const ArrayView<Tensor<3, spacedim>> &output) const override;
-
-  /**
-   * @}
-   */
-
-  /**
-   * @name Interface with FEValues and friends
-   * @{
-   */
-
-  /**
-   * Storage for internal data of polynomial mappings. See
-   * Mapping::InternalDataBase for an extensive description.
-   *
-   * For the current class, the InternalData class stores data that is
-   * computed once when the object is created (in get_data()) as well as data
-   * the class wants to store from between the call to fill_fe_values(),
-   * fill_fe_face_values(), or fill_fe_subface_values() until possible later
-   * calls from the finite element to functions such as transform(). The
-   * latter class of member variables are marked as 'mutable'.
-   */
-  class InternalData : public Mapping<dim, spacedim>::InternalDataBase
-  {
-  public:
-    /**
-     * Constructor. The argument denotes the polynomial degree of the mapping
-     * to which this object will correspond.
-     */
-    InternalData(const unsigned int polynomial_degree);
-
-    /**
-     * Initialize the object's member variables related to cell data based on
-     * the given arguments.
-     *
-     * The function also calls compute_shape_function_values() to actually set
-     * the member variables related to the values and derivatives of the
-     * mapping shape functions.
-     */
-    void
-    initialize(const UpdateFlags      update_flags,
-               const Quadrature<dim> &quadrature,
-               const unsigned int     n_original_q_points);
-
-    /**
-     * Initialize the object's member variables related to cell and face data
-     * based on the given arguments. In order to initialize cell data, this
-     * function calls initialize().
-     */
-    void
-    initialize_face(const UpdateFlags      update_flags,
-                    const Quadrature<dim> &quadrature,
-                    const unsigned int     n_original_q_points);
-
-    /**
-     * Compute the values and/or derivatives of the shape functions used for
-     * the mapping.
-     *
-     * Which values, derivatives, or higher order derivatives are computed is
-     * determined by which of the member arrays have nonzero sizes. They are
-     * typically set to their appropriate sizes by the initialize() and
-     * initialize_face() functions, which indeed call this function
-     * internally. However, it is possible (and at times useful) to do the
-     * resizing by hand and then call this function directly. An example is in
-     * a Newton iteration where we update the location of a quadrature point
-     * (e.g., in MappingQ::transform_real_to_uni_cell()) and need to re-
-     * compute the mapping and its derivatives at this location, but have
-     * already sized all internal arrays correctly.
-     */
-    void
-    compute_shape_function_values(const std::vector<Point<dim>> &unit_points);
-
-    /**
-     * Shape function at quadrature point. Shape functions are in tensor
-     * product order, so vertices must be reordered to obtain transformation.
-     */
-    const double &
-    shape(const unsigned int qpoint, const unsigned int shape_nr) const;
-
-    /**
-     * Shape function at quadrature point. See above.
-     */
-    double &
-    shape(const unsigned int qpoint, const unsigned int shape_nr);
-
-    /**
-     * Gradient of shape function in quadrature point. See above.
-     */
-    const Tensor<1, dim> &
-    derivative(const unsigned int qpoint, const unsigned int shape_nr) const;
-
-    /**
-     * Gradient of shape function in quadrature point. See above.
-     */
-    Tensor<1, dim> &
-    derivative(const unsigned int qpoint, const unsigned int shape_nr);
-
-    /**
-     * Second derivative of shape function in quadrature point. See above.
-     */
-    const Tensor<2, dim> &
-    second_derivative(const unsigned int qpoint,
-                      const unsigned int shape_nr) const;
-
-    /**
-     * Second derivative of shape function in quadrature point. See above.
-     */
-    Tensor<2, dim> &
-    second_derivative(const unsigned int qpoint, const unsigned int shape_nr);
-
-    /**
-     * third derivative of shape function in quadrature point. See above.
-     */
-    const Tensor<3, dim> &
-    third_derivative(const unsigned int qpoint,
-                     const unsigned int shape_nr) const;
-
-    /**
-     * third derivative of shape function in quadrature point. See above.
-     */
-    Tensor<3, dim> &
-    third_derivative(const unsigned int qpoint, const unsigned int shape_nr);
-
-    /**
-     * fourth derivative of shape function in quadrature point. See above.
-     */
-    const Tensor<4, dim> &
-    fourth_derivative(const unsigned int qpoint,
-                      const unsigned int shape_nr) const;
-
-    /**
-     * fourth derivative of shape function in quadrature point. See above.
-     */
-    Tensor<4, dim> &
-    fourth_derivative(const unsigned int qpoint, const unsigned int shape_nr);
-
-    /**
-     * Return an estimate (in bytes) for the memory consumption of this object.
-     */
-    virtual std::size_t
-    memory_consumption() const override;
-
-    /**
-     * Values of shape functions. Access by function @p shape.
-     *
-     * Computed once.
-     */
-    AlignedVector<double> shape_values;
-
-    /**
-     * Values of shape function derivatives. Access by function @p derivative.
-     *
-     * Computed once.
-     */
-    AlignedVector<Tensor<1, dim>> shape_derivatives;
-
-    /**
-     * Values of shape function second derivatives. Access by function @p
-     * second_derivative.
-     *
-     * Computed once.
-     */
-    AlignedVector<Tensor<2, dim>> shape_second_derivatives;
-
-    /**
-     * Values of shape function third derivatives. Access by function @p
-     * second_derivative.
-     *
-     * Computed once.
-     */
-    AlignedVector<Tensor<3, dim>> shape_third_derivatives;
-
-    /**
-     * Values of shape function fourth derivatives. Access by function @p
-     * second_derivative.
-     *
-     * Computed once.
-     */
-    AlignedVector<Tensor<4, dim>> shape_fourth_derivatives;
-
-    /**
-     * Unit tangential vectors. Used for the computation of boundary forms and
-     * normal vectors.
-     *
-     * This array has `(dim-1) * GeometryInfo::faces_per_cell` entries. The
-     * first GeometryInfo::faces_per_cell contain the vectors in the first
-     * tangential direction for each face; the second set of
-     * GeometryInfo::faces_per_cell entries contain the vectors in the second
-     * tangential direction (only in 3d, since there we have 2 tangential
-     * directions per face), etc.
-     *
-     * Filled once.
-     */
-    std::array<std::vector<Tensor<1, dim>>,
-               GeometryInfo<dim>::faces_per_cell *(dim - 1)>
-      unit_tangentials;
-
-    /**
-     * The polynomial degree of the mapping. Since the objects here are also
-     * used (with minor adjustments) by MappingQ, we need to store this.
-     */
-    const unsigned int polynomial_degree;
-
-    /**
-     * Number of shape functions. If this is a Q1 mapping, then it is simply
-     * the number of vertices per cell. However, since also derived classes
-     * use this class (e.g. the Mapping_Q() class), the number of shape
-     * functions may also be different.
-     *
-     * In general, it is $(p+1)^\text{dim}$, where $p$ is the polynomial
-     * degree of the mapping.
-     */
-    const unsigned int n_shape_functions;
-
-    /*
-     * The default line support points. Is used in when the shape function
-     * values are computed.
-     *
-     * The number of quadrature points depends on the degree of this
-     * class, and it matches the number of degrees of freedom of an
-     * FE_Q<1>(this->degree).
-     */
-    QGaussLobatto<1> line_support_points;
-
-    /**
-     * In case the quadrature rule given represents a tensor product
-     * we need to store the evaluations of the 1d polynomials at
-     * the 1d quadrature points. That is what this variable is for.
-     */
-    internal::MatrixFreeFunctions::ShapeInfo<VectorizedArray<double>>
-      shape_info;
-
-    /**
-     * In case the quadrature rule given represents a tensor product
-     * we need to store temporary data in this object.
-     */
-    mutable AlignedVector<VectorizedArray<double>> scratch;
-
-    /**
-     * In case the quadrature rule given represents a tensor product
-     * the values at the mapped support points are stored in this object.
-     */
-    mutable AlignedVector<VectorizedArray<double>> values_dofs;
-
-    /**
-     * In case the quadrature rule given represents a tensor product
-     * the values at the quadrature points are stored in this object.
-     */
-    mutable AlignedVector<VectorizedArray<double>> values_quad;
-
-    /**
-     * In case the quadrature rule given represents a tensor product
-     * the gradients at the quadrature points are stored in this object.
-     */
-    mutable AlignedVector<VectorizedArray<double>> gradients_quad;
-
-    /**
-     * In case the quadrature rule given represents a tensor product
-     * the hessians at the quadrature points are stored in this object.
-     */
-    mutable AlignedVector<VectorizedArray<double>> hessians_quad;
-
-    /**
-     * Indicates whether the given Quadrature object is a tensor product.
-     */
-    bool tensor_product_quadrature;
-
-    /**
-     * Tensors of covariant transformation at each of the quadrature points.
-     * The matrix stored is the Jacobian * G^{-1}, where G = Jacobian^{t} *
-     * Jacobian, is the first fundamental form of the map; if dim=spacedim
-     * then it reduces to the transpose of the inverse of the Jacobian matrix,
-     * which itself is stored in the @p contravariant field of this structure.
-     *
-     * Computed on each cell.
-     */
-    mutable AlignedVector<DerivativeForm<1, dim, spacedim>> covariant;
-
-    /**
-     * Tensors of contravariant transformation at each of the quadrature
-     * points. The contravariant matrix is the Jacobian of the transformation,
-     * i.e. $J_{ij}=dx_i/d\hat x_j$.
-     *
-     * Computed on each cell.
-     */
-    mutable AlignedVector<DerivativeForm<1, dim, spacedim>> contravariant;
-
-    /**
-     * Auxiliary vectors for internal use.
-     */
-    mutable std::vector<AlignedVector<Tensor<1, spacedim>>> aux;
-
-    /**
-     * Stores the support points of the mapping shape functions on the @p
-     * cell_of_current_support_points.
-     */
-    mutable std::vector<Point<spacedim>> mapping_support_points;
-
-    /**
-     * Stores the cell of which the @p mapping_support_points are stored.
-     */
-    mutable typename Triangulation<dim, spacedim>::cell_iterator
-      cell_of_current_support_points;
-
-    /**
-     * The determinant of the Jacobian in each quadrature point. Filled if
-     * #update_volume_elements.
-     */
-    mutable AlignedVector<double> volume_elements;
-  };
-
-
-  // documentation can be found in Mapping::requires_update_flags()
-  virtual UpdateFlags
-  requires_update_flags(const UpdateFlags update_flags) const override;
-
-  // documentation can be found in Mapping::get_data()
-  virtual std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase>
-  get_data(const UpdateFlags, const Quadrature<dim> &quadrature) const override;
-
-  using Mapping<dim, spacedim>::get_face_data;
-
-  // documentation can be found in Mapping::get_face_data()
-  virtual std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase>
-  get_face_data(const UpdateFlags               flags,
-                const hp::QCollection<dim - 1> &quadrature) const override;
-
-  // documentation can be found in Mapping::get_subface_data()
-  virtual std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase>
-  get_subface_data(const UpdateFlags          flags,
-                   const Quadrature<dim - 1> &quadrature) const override;
-
-  // documentation can be found in Mapping::fill_fe_values()
-  virtual CellSimilarity::Similarity
-  fill_fe_values(
-    const typename Triangulation<dim, spacedim>::cell_iterator &cell,
-    const CellSimilarity::Similarity                            cell_similarity,
-    const Quadrature<dim> &                                     quadrature,
-    const typename Mapping<dim, spacedim>::InternalDataBase &   internal_data,
-    dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
-      &output_data) const override;
-
-  using Mapping<dim, spacedim>::fill_fe_face_values;
-
-  // documentation can be found in Mapping::fill_fe_face_values()
-  virtual void
-  fill_fe_face_values(
-    const typename Triangulation<dim, spacedim>::cell_iterator &cell,
-    const unsigned int                                          face_no,
-    const hp::QCollection<dim - 1> &                            quadrature,
-    const typename Mapping<dim, spacedim>::InternalDataBase &   internal_data,
-    dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
-      &output_data) const override;
-
-  // documentation can be found in Mapping::fill_fe_subface_values()
-  virtual void
-  fill_fe_subface_values(
-    const typename Triangulation<dim, spacedim>::cell_iterator &cell,
-    const unsigned int                                          face_no,
-    const unsigned int                                          subface_no,
-    const Quadrature<dim - 1> &                                 quadrature,
-    const typename Mapping<dim, spacedim>::InternalDataBase &   internal_data,
-    dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
-      &output_data) const override;
-
-
-  /**
-   * As opposed to the other fill_fe_values() and fill_fe_face_values()
-   * functions that rely on pre-computed information of InternalDataBase, this
-   * function chooses the flexible evaluation path on the cell and points
-   * passed in to the current function.
-   *
-   * @param[in] cell The cell where to evaluate the mapping
-   *
-   * @param[in] unit_points The points in reference coordinates where the
-   * transformation (Jacobians, positions) should be computed.
-   *
-   * @param[in] update_flags The kind of information that should be computed.
-   *
-   * @param[out] output_data A struct containing the evaluated quantities such
-   * as the Jacobian resulting from application of the mapping on the given
-   * cell with its underlying manifolds.
-   */
-  void
-  fill_mapping_data_for_generic_points(
-    const typename Triangulation<dim, spacedim>::cell_iterator &cell,
-    const ArrayView<const Point<dim>> &                         unit_points,
-    const UpdateFlags                                           update_flags,
-    dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
-      &output_data) const;
-
-  /**
-   * @}
-   */
-
-protected:
-  /**
-   * The degree of the polynomials used as shape functions for the mapping of
-   * cells.
-   */
-  const unsigned int polynomial_degree;
-
-  /*
-   * The default line support points. These are used when computing the
-   * location in real space of the support points on lines and quads, which
-   * are needed by the Manifold<dim,spacedim> class.
-   *
-   * The number of points depends on the degree of this class, and it matches
-   * the number of degrees of freedom of an FE_Q<1>(this->degree).
-   */
-  const std::vector<Point<1>> line_support_points;
-
-  /*
-   * The one-dimensional polynomials defined as Lagrange polynomials from the
-   * line support points. These are used for point evaluations and match the
-   * polynomial space of an FE_Q<1>(this->degree).
-   */
-  const std::vector<Polynomials::Polynomial<double>> polynomials_1d;
-
-  /*
-   * The numbering from the lexicographic to the hierarchical ordering used
-   * when expanding the tensor product with the mapping support points (which
-   * come in hierarchical numbers).
-   */
-  const std::vector<unsigned int> renumber_lexicographic_to_hierarchic;
-
-  /*
-   * The support points in reference coordinates. These are used for
-   * constructing approximations of the output of
-   * compute_mapping_support_points() when evaluating the mapping on the fly,
-   * rather than going through the FEValues interface provided by
-   * InternalData.
-   *
-   * The number of points depends on the degree of this class, and it matches
-   * the number of degrees of freedom of an FE_Q<dim>(this->degree).
-   */
-  const std::vector<Point<dim>> unit_cell_support_points;
-
-  /**
-   * A vector of tables of weights by which we multiply the locations of the
-   * support points on the perimeter of an object (line, quad, hex) to get the
-   * location of interior support points.
-   *
-   * Access into this table is by @p [structdim-1], i.e., use 0 to access the
-   * support point weights on a line (i.e., the interior points of the
-   * GaussLobatto quadrature), use 1 to access the support point weights from
-   * to perimeter to the interior of a quad, and use 2 to access the support
-   * point weights from the perimeter to the interior of a hex.
-   *
-   * The table itself contains as many columns as there are surrounding points
-   * to a particular object (2 for a line, <code>4 + 4*(degree-1)</code> for
-   * a quad, <code>8 + 12*(degree-1) + 6*(degree-1)*(degree-1)</code> for a
-   * hex) and as many rows as there are strictly interior points.
-   *
-   * For the definition of this table see equation (8) of the `mapping'
-   * report.
-   */
-  const std::vector<Table<2, double>>
-    support_point_weights_perimeter_to_interior;
-
-  /**
-   * A table of weights by which we multiply the locations of the vertex
-   * points of the cell to get the location of all additional support points,
-   * both on lines, quads, and hexes (as appropriate). This data structure is
-   * used when we fill all support points at once, which is the case if the
-   * same manifold is attached to all sub-entities of a cell. This way, we can
-   * avoid some of the overhead in transforming data for mappings.
-   *
-   * The table has as many rows as there are vertices to the cell (2 in 1D, 4
-   * in 2D, 8 in 3D), and as many rows as there are additional support points
-   * in the mapping, i.e., <code>(degree+1)^dim - 2^dim</code>.
-   */
-  const Table<2, double> support_point_weights_cell;
-
-  /**
-   * Return the locations of support points for the mapping. For example, for
-   * $Q_1$ mappings these are the vertices, and for higher order polynomial
-   * mappings they are the vertices plus interior points on edges, faces, and
-   * the cell interior that are placed in consultation with the Manifold
-   * description of the domain and its boundary. However, other classes may
-   * override this function differently. In particular, the MappingQ1Eulerian
-   * class does exactly this by not computing the support points from the
-   * geometry of the current cell but instead evaluating an externally given
-   * displacement field in addition to the geometry of the cell.
-   *
-   * The default implementation of this function is appropriate for most
-   * cases. It takes the locations of support points on the boundary of the
-   * cell from the underlying manifold. Interior support points (ie. support
-   * points in quads for 2d, in hexes for 3d) are then computed using an
-   * interpolation from the lower-dimensional entities (lines, quads) in order
-   * to make the transformation as smooth as possible without introducing
-   * additional boundary layers within the cells due to the placement of
-   * support points.
-   *
-   * The function works its way from the vertices (which it takes from the
-   * given cell) via the support points on the line (for which it calls the
-   * add_line_support_points() function) and the support points on the quad
-   * faces (in 3d, for which it calls the add_quad_support_points() function).
-   * It then adds interior support points that are either computed by
-   * interpolation from the surrounding points using weights for transfinite
-   * interpolation, or if dim<spacedim, it asks the underlying manifold for
-   * the locations of interior points.
-   */
-  virtual std::vector<Point<spacedim>>
-  compute_mapping_support_points(
-    const typename Triangulation<dim, spacedim>::cell_iterator &cell) const;
-
-  /**
-   * Transform the point @p p on the real cell to the corresponding point on
-   * the unit cell @p cell by a Newton iteration.
-   */
-  Point<dim>
-  transform_real_to_unit_cell_internal(
-    const typename Triangulation<dim, spacedim>::cell_iterator &cell,
-    const Point<spacedim> &                                     p,
-    const Point<dim> &initial_p_unit) const;
-
-  /**
-   * Append the support points of all shape functions located on bounding
-   * lines of the given cell to the vector @p a. Points located on the
-   * vertices of a line are not included.
-   *
-   * This function uses the underlying manifold object of the line (or, if
-   * none is set, of the cell) for the location of the requested points. This
-   * function is usually called by compute_mapping_support_points() function.
-   *
-   * This function is made virtual in order to allow derived classes to choose
-   * shape function support points differently than the present class, which
-   * chooses the points as interpolation points on the boundary.
-   */
-  virtual void
-  add_line_support_points(
-    const typename Triangulation<dim, spacedim>::cell_iterator &cell,
-    std::vector<Point<spacedim>> &                              a) const;
-
-  /**
-   * Append the support points of all shape functions located on bounding
-   * faces (quads in 3d) of the given cell to the vector @p a. This function
-   * is only defined for <tt>dim=3</tt>. Points located on the vertices or
-   * lines of a quad are not included.
-   *
-   * This function uses the underlying manifold object of the quad (or, if
-   * none is set, of the cell) for the location of the requested points. This
-   * function is usually called by compute_mapping_support_points().
-   *
-   * This function is made virtual in order to allow derived classes to choose
-   * shape function support points differently than the present class, which
-   * chooses the points as interpolation points on the boundary.
-   */
-  virtual void
-  add_quad_support_points(
-    const typename Triangulation<dim, spacedim>::cell_iterator &cell,
-    std::vector<Point<spacedim>> &                              a) const;
-
-  // Make MappingQ a friend since it needs to call the fill_fe_values()
-  // functions on its MappingQGeneric(1) sub-object.
-  template <int, int>
-  friend class MappingQ;
-
-  // Make MappingQCache a friend since it needs to call the
-  // compute_mapping_support_points() function.
-  template <int, int>
-  friend class MappingQCache;
-};
-
-
-
-/*@}*/
-
-/*----------------------------------------------------------------------*/
-
-#ifndef DOXYGEN
-
-template <int dim, int spacedim>
-inline const double &
-MappingQGeneric<dim, spacedim>::InternalData::shape(
-  const unsigned int qpoint,
-  const unsigned int shape_nr) const
-{
-  AssertIndexRange(qpoint * n_shape_functions + shape_nr, shape_values.size());
-  return shape_values[qpoint * n_shape_functions + shape_nr];
-}
-
-
-
-template <int dim, int spacedim>
-inline double &
-MappingQGeneric<dim, spacedim>::InternalData::shape(const unsigned int qpoint,
-                                                    const unsigned int shape_nr)
-{
-  AssertIndexRange(qpoint * n_shape_functions + shape_nr, shape_values.size());
-  return shape_values[qpoint * n_shape_functions + shape_nr];
-}
-
-
-template <int dim, int spacedim>
-inline const Tensor<1, dim> &
-MappingQGeneric<dim, spacedim>::InternalData::derivative(
-  const unsigned int qpoint,
-  const unsigned int shape_nr) const
-{
-  AssertIndexRange(qpoint * n_shape_functions + shape_nr,
-                   shape_derivatives.size());
-  return shape_derivatives[qpoint * n_shape_functions + shape_nr];
-}
-
-
-
-template <int dim, int spacedim>
-inline Tensor<1, dim> &
-MappingQGeneric<dim, spacedim>::InternalData::derivative(
-  const unsigned int qpoint,
-  const unsigned int shape_nr)
-{
-  AssertIndexRange(qpoint * n_shape_functions + shape_nr,
-                   shape_derivatives.size());
-  return shape_derivatives[qpoint * n_shape_functions + shape_nr];
-}
-
-
-template <int dim, int spacedim>
-inline const Tensor<2, dim> &
-MappingQGeneric<dim, spacedim>::InternalData::second_derivative(
-  const unsigned int qpoint,
-  const unsigned int shape_nr) const
-{
-  AssertIndexRange(qpoint * n_shape_functions + shape_nr,
-                   shape_second_derivatives.size());
-  return shape_second_derivatives[qpoint * n_shape_functions + shape_nr];
-}
-
-
-template <int dim, int spacedim>
-inline Tensor<2, dim> &
-MappingQGeneric<dim, spacedim>::InternalData::second_derivative(
-  const unsigned int qpoint,
-  const unsigned int shape_nr)
-{
-  AssertIndexRange(qpoint * n_shape_functions + shape_nr,
-                   shape_second_derivatives.size());
-  return shape_second_derivatives[qpoint * n_shape_functions + shape_nr];
-}
-
-template <int dim, int spacedim>
-inline const Tensor<3, dim> &
-MappingQGeneric<dim, spacedim>::InternalData::third_derivative(
-  const unsigned int qpoint,
-  const unsigned int shape_nr) const
-{
-  AssertIndexRange(qpoint * n_shape_functions + shape_nr,
-                   shape_third_derivatives.size());
-  return shape_third_derivatives[qpoint * n_shape_functions + shape_nr];
-}
-
-
-template <int dim, int spacedim>
-inline Tensor<3, dim> &
-MappingQGeneric<dim, spacedim>::InternalData::third_derivative(
-  const unsigned int qpoint,
-  const unsigned int shape_nr)
-{
-  AssertIndexRange(qpoint * n_shape_functions + shape_nr,
-                   shape_third_derivatives.size());
-  return shape_third_derivatives[qpoint * n_shape_functions + shape_nr];
-}
-
-
-template <int dim, int spacedim>
-inline const Tensor<4, dim> &
-MappingQGeneric<dim, spacedim>::InternalData::fourth_derivative(
-  const unsigned int qpoint,
-  const unsigned int shape_nr) const
-{
-  AssertIndexRange(qpoint * n_shape_functions + shape_nr,
-                   shape_fourth_derivatives.size());
-  return shape_fourth_derivatives[qpoint * n_shape_functions + shape_nr];
-}
-
-
-template <int dim, int spacedim>
-inline Tensor<4, dim> &
-MappingQGeneric<dim, spacedim>::InternalData::fourth_derivative(
-  const unsigned int qpoint,
-  const unsigned int shape_nr)
-{
-  AssertIndexRange(qpoint * n_shape_functions + shape_nr,
-                   shape_fourth_derivatives.size());
-  return shape_fourth_derivatives[qpoint * n_shape_functions + shape_nr];
-}
-
-
-
-template <int dim, int spacedim>
-inline bool
-MappingQGeneric<dim, spacedim>::preserves_vertex_locations() const
-{
-  return true;
-}
-
-#endif // DOXYGEN
-
-/* -------------- declaration of explicit specializations ------------- */
-
-
-DEAL_II_NAMESPACE_CLOSE
 
 #endif
index f7140992565d2a71b816339f6bf8c422a86880bc..3f432f3bcd1282f9f854f0693b93b2d253d3213c 100644 (file)
@@ -29,7 +29,7 @@
 #include <deal.II/fe/fe_tools.h>
 #include <deal.II/fe/fe_update_flags.h>
 #include <deal.II/fe/fe_values.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_tools.h>
 
@@ -200,11 +200,11 @@ namespace internal
 
 
   /**
-   * Internal namespace to implement methods of MappingQGeneric, such as the
+   * Internal namespace to implement methods of MappingQ, such as the
    * evaluation of the mapping and the transformation between real and unit
    * cell.
    */
-  namespace MappingQGenericImplementation
+  namespace MappingQImplementation
   {
     /**
      * This function generates the reference cell support points from the 1d
@@ -451,7 +451,7 @@ namespace internal
     template <int dim, int spacedim>
     inline Point<spacedim>
     compute_mapped_location_of_point(
-      const typename dealii::MappingQGeneric<dim, spacedim>::InternalData &data)
+      const typename dealii::MappingQ<dim, spacedim>::InternalData &data)
     {
       AssertDimension(data.shape_values.size(),
                       data.mapping_support_points.size());
@@ -725,8 +725,8 @@ namespace internal
     do_transform_real_to_unit_cell_internal_codim1(
       const typename dealii::Triangulation<dim, dim + 1>::cell_iterator &cell,
       const Point<dim + 1> &                                             p,
-      const Point<dim> &initial_p_unit,
-      typename dealii::MappingQGeneric<dim, dim + 1>::InternalData &mdata)
+      const Point<dim> &                                     initial_p_unit,
+      typename dealii::MappingQ<dim, dim + 1>::InternalData &mdata)
     {
       const unsigned int spacedim = dim + 1;
 
@@ -848,7 +848,7 @@ namespace internal
      * real to unit points by a least-squares fit along the mapping support
      * points. The least squares fit is special in the sense that the
      * approximation is constructed for the inverse function of a
-     * MappingQGeneric, which is generally a rational function. This allows
+     * MappingQ, which is generally a rational function. This allows
      * for a very cheap evaluation of the inverse map by a simple polynomial
      * interpolation, which can be used as a better initial guess for
      * transforming points from real to unit coordinates than an affine
@@ -875,7 +875,7 @@ namespace internal
        *
        * @param real_support_points The position of the mapping support points
        * in real space, queried by
-       * MappingQGeneric::compute_mapping_support_points().
+       * MappingQ::compute_mapping_support_points().
        *
        * @param unit_support_points The location of the support points in
        * reference coordinates $[0, 1]^d$ that map to the mapping support
@@ -1073,7 +1073,7 @@ namespace internal
     inline void
     maybe_update_q_points_Jacobians_and_grads_tensor(
       const CellSimilarity::Similarity cell_similarity,
-      const typename dealii::MappingQGeneric<dim, spacedim>::InternalData &data,
+      const typename dealii::MappingQ<dim, spacedim>::InternalData &data,
       std::vector<Point<spacedim>> &                 quadrature_points,
       std::vector<DerivativeForm<2, dim, spacedim>> &jacobian_grads)
     {
@@ -1256,8 +1256,8 @@ namespace internal
     template <int dim, int spacedim>
     inline void
     maybe_compute_q_points(
-      const typename QProjector<dim>::DataSetDescriptor data_set,
-      const typename dealii::MappingQGeneric<dim, spacedim>::InternalData &data,
+      const typename QProjector<dim>::DataSetDescriptor             data_set,
+      const typename dealii::MappingQ<dim, spacedim>::InternalData &data,
       std::vector<Point<spacedim>> &quadrature_points)
     {
       const UpdateFlags update_flags = data.update_each;
@@ -1290,7 +1290,7 @@ namespace internal
     maybe_update_Jacobians(
       const CellSimilarity::Similarity                          cell_similarity,
       const typename dealii::QProjector<dim>::DataSetDescriptor data_set,
-      const typename dealii::MappingQGeneric<dim, spacedim>::InternalData &data)
+      const typename dealii::MappingQ<dim, spacedim>::InternalData &data)
     {
       const UpdateFlags update_flags = data.update_each;
 
@@ -1369,7 +1369,7 @@ namespace internal
     maybe_update_jacobian_grads(
       const CellSimilarity::Similarity                  cell_similarity,
       const typename QProjector<dim>::DataSetDescriptor data_set,
-      const typename dealii::MappingQGeneric<dim, spacedim>::InternalData &data,
+      const typename dealii::MappingQ<dim, spacedim>::InternalData &data,
       std::vector<DerivativeForm<2, dim, spacedim>> &jacobian_grads)
     {
       const UpdateFlags update_flags = data.update_each;
@@ -1416,7 +1416,7 @@ namespace internal
     maybe_update_jacobian_pushed_forward_grads(
       const CellSimilarity::Similarity                  cell_similarity,
       const typename QProjector<dim>::DataSetDescriptor data_set,
-      const typename dealii::MappingQGeneric<dim, spacedim>::InternalData &data,
+      const typename dealii::MappingQ<dim, spacedim>::InternalData &data,
       std::vector<Tensor<3, spacedim>> &jacobian_pushed_forward_grads)
     {
       const UpdateFlags update_flags = data.update_each;
@@ -1490,7 +1490,7 @@ namespace internal
     maybe_update_jacobian_2nd_derivatives(
       const CellSimilarity::Similarity                  cell_similarity,
       const typename QProjector<dim>::DataSetDescriptor data_set,
-      const typename dealii::MappingQGeneric<dim, spacedim>::InternalData &data,
+      const typename dealii::MappingQ<dim, spacedim>::InternalData &data,
       std::vector<DerivativeForm<3, dim, spacedim>> &jacobian_2nd_derivatives)
     {
       const UpdateFlags update_flags = data.update_each;
@@ -1546,7 +1546,7 @@ namespace internal
     maybe_update_jacobian_pushed_forward_2nd_derivatives(
       const CellSimilarity::Similarity                  cell_similarity,
       const typename QProjector<dim>::DataSetDescriptor data_set,
-      const typename dealii::MappingQGeneric<dim, spacedim>::InternalData &data,
+      const typename dealii::MappingQ<dim, spacedim>::InternalData &data,
       std::vector<Tensor<4, spacedim>> &jacobian_pushed_forward_2nd_derivatives)
     {
       const UpdateFlags update_flags = data.update_each;
@@ -1647,7 +1647,7 @@ namespace internal
     maybe_update_jacobian_3rd_derivatives(
       const CellSimilarity::Similarity                  cell_similarity,
       const typename QProjector<dim>::DataSetDescriptor data_set,
-      const typename dealii::MappingQGeneric<dim, spacedim>::InternalData &data,
+      const typename dealii::MappingQ<dim, spacedim>::InternalData &data,
       std::vector<DerivativeForm<4, dim, spacedim>> &jacobian_3rd_derivatives)
     {
       const UpdateFlags update_flags = data.update_each;
@@ -1706,7 +1706,7 @@ namespace internal
     maybe_update_jacobian_pushed_forward_3rd_derivatives(
       const CellSimilarity::Similarity                  cell_similarity,
       const typename QProjector<dim>::DataSetDescriptor data_set,
-      const typename dealii::MappingQGeneric<dim, spacedim>::InternalData &data,
+      const typename dealii::MappingQ<dim, spacedim>::InternalData &data,
       std::vector<Tensor<5, spacedim>> &jacobian_pushed_forward_3rd_derivatives)
     {
       const UpdateFlags update_flags = data.update_each;
@@ -1831,13 +1831,13 @@ namespace internal
     template <int dim, int spacedim>
     inline void
     maybe_compute_face_data(
-      const dealii::MappingQGeneric<dim, spacedim> &mapping,
+      const dealii::MappingQ<dim, spacedim> &mapping,
       const typename dealii::Triangulation<dim, spacedim>::cell_iterator &cell,
-      const unsigned int         face_no,
-      const unsigned int         subface_no,
-      const unsigned int         n_q_points,
-      const std::vector<double> &weights,
-      const typename dealii::MappingQGeneric<dim, spacedim>::InternalData &data,
+      const unsigned int                                            face_no,
+      const unsigned int                                            subface_no,
+      const unsigned int                                            n_q_points,
+      const std::vector<double> &                                   weights,
+      const typename dealii::MappingQ<dim, spacedim>::InternalData &data,
       internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
         &output_data)
     {
@@ -1987,21 +1987,21 @@ namespace internal
 
 
     /**
-     * Do the work of MappingQGeneric::fill_fe_face_values() and
-     * MappingQGeneric::fill_fe_subface_values() in a generic way,
+     * Do the work of MappingQ::fill_fe_face_values() and
+     * MappingQ::fill_fe_subface_values() in a generic way,
      * using the 'data_set' to differentiate whether we will
      * work on a face (and if so, which one) or subface.
      */
     template <int dim, int spacedim>
     inline void
     do_fill_fe_face_values(
-      const dealii::MappingQGeneric<dim, spacedim> &mapping,
+      const dealii::MappingQ<dim, spacedim> &mapping,
       const typename dealii::Triangulation<dim, spacedim>::cell_iterator &cell,
-      const unsigned int                                face_no,
-      const unsigned int                                subface_no,
-      const typename QProjector<dim>::DataSetDescriptor data_set,
-      const Quadrature<dim - 1> &                       quadrature,
-      const typename dealii::MappingQGeneric<dim, spacedim>::InternalData &data,
+      const unsigned int                                            face_no,
+      const unsigned int                                            subface_no,
+      const typename QProjector<dim>::DataSetDescriptor             data_set,
+      const Quadrature<dim - 1> &                                   quadrature,
+      const typename dealii::MappingQ<dim, spacedim>::InternalData &data,
       internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
         &output_data)
     {
@@ -2063,7 +2063,7 @@ namespace internal
 
 
     /**
-     * Implementation of MappingQGeneric::transform() for generic tensors.
+     * Implementation of MappingQ::transform() for generic tensors.
      */
     template <int dim, int spacedim, int rank>
     inline void
@@ -2074,14 +2074,14 @@ namespace internal
       const ArrayView<Tensor<rank, spacedim>> &                output)
     {
       AssertDimension(input.size(), output.size());
-      Assert((dynamic_cast<const typename dealii::
-                             MappingQGeneric<dim, spacedim>::InternalData *>(
+      Assert((dynamic_cast<
+                const typename dealii::MappingQ<dim, spacedim>::InternalData *>(
                 &mapping_data) != nullptr),
              ExcInternalError());
-      const typename dealii::MappingQGeneric<dim, spacedim>::InternalData
-        &data =
-          static_cast<const typename dealii::MappingQGeneric<dim, spacedim>::
-                        InternalData &>(mapping_data);
+      const typename dealii::MappingQ<dim, spacedim>::InternalData &data =
+        static_cast<
+          const typename dealii::MappingQ<dim, spacedim>::InternalData &>(
+          mapping_data);
 
       switch (mapping_kind)
         {
@@ -2141,7 +2141,7 @@ namespace internal
 
 
     /**
-     * Implementation of MappingQGeneric::transform() for gradients.
+     * Implementation of MappingQ::transform() for gradients.
      */
     template <int dim, int spacedim, int rank>
     inline void
@@ -2152,14 +2152,14 @@ namespace internal
       const ArrayView<Tensor<rank, spacedim>> &                output)
     {
       AssertDimension(input.size(), output.size());
-      Assert((dynamic_cast<const typename dealii::
-                             MappingQGeneric<dim, spacedim>::InternalData *>(
+      Assert((dynamic_cast<
+                const typename dealii::MappingQ<dim, spacedim>::InternalData *>(
                 &mapping_data) != nullptr),
              ExcInternalError());
-      const typename dealii::MappingQGeneric<dim, spacedim>::InternalData
-        &data =
-          static_cast<const typename dealii::MappingQGeneric<dim, spacedim>::
-                        InternalData &>(mapping_data);
+      const typename dealii::MappingQ<dim, spacedim>::InternalData &data =
+        static_cast<
+          const typename dealii::MappingQ<dim, spacedim>::InternalData &>(
+          mapping_data);
 
       switch (mapping_kind)
         {
@@ -2239,7 +2239,7 @@ namespace internal
 
 
     /**
-     * Implementation of MappingQGeneric::transform() for hessians.
+     * Implementation of MappingQ::transform() for hessians.
      */
     template <int dim, int spacedim>
     inline void
@@ -2250,14 +2250,14 @@ namespace internal
       const ArrayView<Tensor<3, spacedim>> &                   output)
     {
       AssertDimension(input.size(), output.size());
-      Assert((dynamic_cast<const typename dealii::
-                             MappingQGeneric<dim, spacedim>::InternalData *>(
+      Assert((dynamic_cast<
+                const typename dealii::MappingQ<dim, spacedim>::InternalData *>(
                 &mapping_data) != nullptr),
              ExcInternalError());
-      const typename dealii::MappingQGeneric<dim, spacedim>::InternalData
-        &data =
-          static_cast<const typename dealii::MappingQGeneric<dim, spacedim>::
-                        InternalData &>(mapping_data);
+      const typename dealii::MappingQ<dim, spacedim>::InternalData &data =
+        static_cast<
+          const typename dealii::MappingQ<dim, spacedim>::InternalData &>(
+          mapping_data);
 
       switch (mapping_kind)
         {
@@ -2405,7 +2405,7 @@ namespace internal
 
 
     /**
-     * Implementation of MappingQGeneric::transform() for DerivativeForm
+     * Implementation of MappingQ::transform() for DerivativeForm
      * arguments.
      */
     template <int dim, int spacedim, int rank>
@@ -2417,14 +2417,14 @@ namespace internal
       const ArrayView<Tensor<rank + 1, spacedim>> &               output)
     {
       AssertDimension(input.size(), output.size());
-      Assert((dynamic_cast<const typename dealii::
-                             MappingQGeneric<dim, spacedim>::InternalData *>(
+      Assert((dynamic_cast<
+                const typename dealii::MappingQ<dim, spacedim>::InternalData *>(
                 &mapping_data) != nullptr),
              ExcInternalError());
-      const typename dealii::MappingQGeneric<dim, spacedim>::InternalData
-        &data =
-          static_cast<const typename dealii::MappingQGeneric<dim, spacedim>::
-                        InternalData &>(mapping_data);
+      const typename dealii::MappingQ<dim, spacedim>::InternalData &data =
+        static_cast<
+          const typename dealii::MappingQ<dim, spacedim>::InternalData &>(
+          mapping_data);
 
       switch (mapping_kind)
         {
@@ -2443,7 +2443,7 @@ namespace internal
             Assert(false, ExcNotImplemented());
         }
     }
-  } // namespace MappingQGenericImplementation
+  } // namespace MappingQImplementation
 } // namespace internal
 
 DEAL_II_NAMESPACE_CLOSE
index 0a8d29ce080d4b48dc6e58509c1cdb1c8438e439..b76fb37852621b768c5a66bca2548adc0bf78c40 100644 (file)
@@ -1511,7 +1511,7 @@ namespace GridGenerator
    * to visualize GNUPLOT output)
    *
    * @code
-   * #include <deal.II/fe/mapping_q_generic.h>
+   * #include <deal.II/fe/mapping_q.h>
    *
    * #include <deal.II/grid/grid_generator.h>
    * #include <deal.II/grid/grid_out.h>
@@ -1535,7 +1535,7 @@ namespace GridGenerator
    *   GridOutFlags::Gnuplot gnuplot_flags(false, 10, true);
    *   grid_out.set_flags(gnuplot_flags);
    *
-   *   const MappingQGeneric<2> mapping(3);
+   *   const MappingQ<2> mapping(3);
    *   std::ofstream out("out.gpl");
    *   grid_out.write_gnuplot(triangulation, out, &mapping);
    * }
index eaf4727d0f257e9ca69d1509ddeaf5d440d706ce..7228bddc2d500e29306357535a93fb170a50c600 100644 (file)
@@ -354,7 +354,7 @@ namespace GridOutFlags
      * the vertices of the face.
      *
      * This number is only used if the mapping used is not simply the standard
-     * $Q_1$ mapping (i.e., an object of kind MappingQGeneric(1)) that may
+     * $Q_1$ mapping (i.e., an object of kind MappingQ(1)) that may
      * describe edges of cells as curved and that will then be approximated
      * using line segments with a number of intermediate points as described
      * by the current variable.
index c7a10d1f2931f0deff86f02df07f6a23f6d43274..99ed0b867dcb38acfe86e540922e055c0b818fea 100644 (file)
@@ -378,7 +378,7 @@ public:
    * In its default implementation, this function simply calls get_new_point()
    * on each row of @p weights and writes those points into the output array
    * @p new_points. However, this function is more efficient if multiple new
-   * points need to be generated like in MappingQGeneric and the manifold does
+   * points need to be generated like in MappingQ and the manifold does
    * expensive transformations between a chart space and the physical space,
    * such as ChartManifold. For this function, the surrounding points need to
    * be transformed back to the chart sparse only once, rather than for every
index ba1fe83e7bf1ff7c168938b5a34266af59bfe5a6..105ccc3f93cd7f46e8b80dc2df606a2d70b32562 100644 (file)
@@ -29,7 +29,7 @@ DEAL_II_NAMESPACE_OPEN
 // forward declaration
 namespace internal
 {
-  namespace MappingQGenericImplementation
+  namespace MappingQImplementation
   {
     template <int, int>
     class InverseQuadraticApproximation;
@@ -863,7 +863,7 @@ private:
  * nature of the manifold that is originally contained in one <i>coarse</i>
  * mesh layer will be applied to more than one <i>fine</i> mesh layer once the
  * mesh gets refined. Note that the mechanisms of
- * TransfiniteInterpolationManifold are also built into the MappingQGeneric
+ * TransfiniteInterpolationManifold are also built into the MappingQ
  * class when only a surface of a cell is subject to a curved description,
  * ensuring that even the default case without this manifold gets optimal
  * convergence rates when applying curved boundary descriptions.
@@ -1148,7 +1148,7 @@ private:
    * A vector of quadratic approximations to the inverse map from real points
    * to chart points for each of the coarse mesh cells.
    */
-  std::vector<internal::MappingQGenericImplementation::
+  std::vector<internal::MappingQImplementation::
                 InverseQuadraticApproximation<dim, spacedim>>
     quadratic_approximation;
 
index 41d53d6c64efac872dd47b63432cd1f459c42423..65298d787d1f7822b592f333bf97519bb6da8171 100644 (file)
@@ -163,7 +163,7 @@ public:
   /**
    * Return a default mapping of degree @p degree matching the current
    * reference cell. If this reference cell is a hypercube, then the returned
-   * mapping is a MappingQGeneric; otherwise, it is an object of type
+   * mapping is a MappingQ; otherwise, it is an object of type
    * MappingFE initialized with FE_SimplexP (if the reference cell is a
    * triangle or tetrahedron), with FE_PyramidP (if the reference
    * cell is a pyramid), or with FE_WedgeP (if the reference cell is
index 0456fbddcd2e9b870f7d0f5c572ef1c1d4813dee..b6f4b145d0536d863041b5d47ab7603545ec6cf6 100644 (file)
@@ -95,7 +95,7 @@ namespace hp
     /**
      * Constructor. This constructor is equivalent to the other one except
      * that it makes the object use a $Q_1$ mapping (i.e., an object of type
-     * MappingQGeneric(1)) implicitly.
+     * MappingQ(1)) implicitly.
      */
     FEValuesBase(
       const FECollection<dim, FEValuesType::space_dimension> &fe_collection,
@@ -332,7 +332,7 @@ namespace hp
     /**
      * Constructor. This constructor is equivalent to the other one except
      * that it makes the object use a $Q_1$ mapping (i.e., an object of type
-     * MappingQGeneric(1)) implicitly.
+     * MappingQ(1)) implicitly.
      */
     FEValues(const FECollection<dim, spacedim> &fe_collection,
              const QCollection<dim> &           q_collection,
@@ -466,7 +466,7 @@ namespace hp
     /**
      * Constructor. This constructor is equivalent to the other one except
      * that it makes the object use a $Q_1$ mapping (i.e., an object of type
-     * MappingQGeneric(1)) implicitly.
+     * MappingQ(1)) implicitly.
      */
     FEFaceValues(const hp::FECollection<dim, spacedim> &fe_collection,
                  const hp::QCollection<dim - 1> &       q_collection,
@@ -610,7 +610,7 @@ namespace hp
     /**
      * Constructor. This constructor is equivalent to the other one except
      * that it makes the object use a $Q_1$ mapping (i.e., an object of type
-     * MappingQGeneric(1)) implicitly.
+     * MappingQ(1)) implicitly.
      */
     FESubfaceValues(const hp::FECollection<dim, spacedim> &fe_collection,
                     const hp::QCollection<dim - 1> &       q_collection,
index 59814074bb2605ef0f55a343d6534942acdd100d..a78059e8f1106573232dfe11baf65b0811699981 100644 (file)
@@ -106,7 +106,7 @@ namespace hp
    * Many places in the library by default use (bi-,tri-)linear mappings
    * unless users explicitly provide a different mapping to use. In these
    * cases, the called function has to create a $Q_1$ mapping object, i.e., an
-   * object of kind MappingQGeneric(1). This is costly. It would also be
+   * object of kind MappingQ(1). This is costly. It would also be
    * costly to create such objects as static objects in the affected
    * functions, because static objects are never destroyed throughout the
    * lifetime of a program, even though they only have to be created once the
index cff1d6c425ae0628d97ad4d7aad35858bcb67e76..e13889563c8a5f169d4d7a446980bdddc8df114b 100644 (file)
@@ -2687,7 +2687,7 @@ public:
   /**
    * Constructor for the reduced functionality. This constructor is equivalent
    * to the other one except that it makes the object use a $Q_1$ mapping
-   * (i.e., an object of type MappingQGeneric(1)) implicitly.
+   * (i.e., an object of type MappingQ(1)) implicitly.
    */
   FEEvaluation(const FiniteElement<dim> &fe,
                const Quadrature<1> &     quadrature,
index f059e9b097e61a867c28a8c994c17b4495cf6f14..1c3c90c3ff8cbfc4f73f45d28862c051d09429eb 100644 (file)
@@ -26,7 +26,7 @@
 #include <deal.II/base/vectorization.h>
 
 #include <deal.II/fe/fe_values.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/matrix_free/evaluation_flags.h>
 #include <deal.II/matrix_free/shape_info.h>
@@ -381,7 +381,7 @@ namespace internal
  * realizations, however, there is a much more efficient implementation that
  * avoids the memory allocation and other expensive start-up cost of
  * FEValues. Currently, the functionality is specialized for mappings derived
- * from MappingQGeneric and for finite elements with tensor product structure
+ * from MappingQ and for finite elements with tensor product structure
  * that work with the @ref matrixfree module. In those cases, the cost implied
  * by this class is similar (or sometimes even somewhat lower) than using
  * `FEValues::reinit(cell)` followed by `FEValues::get_function_gradients`.
@@ -572,10 +572,10 @@ private:
   SmartPointer<const Mapping<dim, spacedim>> mapping;
 
   /**
-   * Pointer to MappingQGeneric class that enables the fast path of this
+   * Pointer to MappingQ class that enables the fast path of this
    * class.
    */
-  const MappingQGeneric<dim, spacedim> *mapping_q_generic;
+  const MappingQ<dim, spacedim> *mapping_q;
 
   /**
    * Pointer to the FiniteElement object passed to the constructor.
@@ -685,8 +685,7 @@ FEPointEvaluation<n_components, dim, spacedim, Number>::FEPointEvaluation(
   const UpdateFlags         update_flags,
   const unsigned int        first_selected_component)
   : mapping(&mapping)
-  , mapping_q_generic(
-      dynamic_cast<const MappingQGeneric<dim, spacedim> *>(&mapping))
+  , mapping_q(dynamic_cast<const MappingQ<dim, spacedim> *>(&mapping))
   , fe(&fe)
   , update_flags(update_flags)
   , update_flags_mapping(update_default)
@@ -708,7 +707,7 @@ FEPointEvaluation<n_components, dim, spacedim, Number>::FEPointEvaluation(
       }
     else
       component += fe.element_multiplicity(base_element_number);
-  if (mapping_q_generic != nullptr &&
+  if (mapping_q != nullptr &&
       internal::FEPointEvaluation::is_fast_path_supported(
         fe, base_element_number) &&
       same_base_element)
@@ -767,8 +766,10 @@ FEPointEvaluation<n_components, dim, spacedim, Number>::reinit(
   std::copy(unit_points.begin(), unit_points.end(), this->unit_points.begin());
 
   if (!poly.empty())
-    mapping_q_generic->fill_mapping_data_for_generic_points(
-      cell, unit_points, update_flags_mapping, mapping_data);
+    mapping_q->fill_mapping_data_for_generic_points(cell,
+                                                    unit_points,
+                                                    update_flags_mapping,
+                                                    mapping_data);
   else
     {
       fe_values = std::make_shared<FEValues<dim, spacedim>>(
@@ -1123,7 +1124,7 @@ inline const typename FEPointEvaluation<n_components, dim, spacedim, Number>::
 {
   Assert(!poly.empty(),
          ExcMessage("Unit gradients are currently only implemented for tensor "
-                    "product finite elements combined with MappingQGeneric "
+                    "product finite elements combined with MappingQ "
                     "mappings"));
   AssertIndexRange(point_index, unit_gradients.size());
   return unit_gradients[point_index];
index d0d988497ae968798a7dc756fd5ec254be41af73..b1c739009053f865034bb5599c4e5a0a433f2d59 100644 (file)
@@ -77,7 +77,7 @@ namespace internal
       /**
        * Constructor. This constructor is equivalent to the other one except
        * that it makes the object use a $Q_1$ mapping (i.e., an object of type
-       * MappingQGeneric(1)) implicitly.
+       * MappingQ(1)) implicitly.
        */
       MappingDataOnTheFly(const Quadrature<1> &quadrature,
                           const UpdateFlags    update_flags);
index 814213751f989d76b1da251cda7cb6bd23ff7b41..b10c90a197a55ed53948d9aa016a50a5ba6bce84 100644 (file)
@@ -26,7 +26,7 @@
 #include <deal.II/fe/fe_dgq.h>
 #include <deal.II/fe/fe_nothing.h>
 #include <deal.II/fe/fe_values.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/matrix_free/evaluation_template_factory.h>
 #include <deal.II/matrix_free/mapping_info.h>
@@ -440,10 +440,10 @@ namespace internal
         }
 
       // In case we have no hp-adaptivity (active_fe_index is empty), we have
-      // cells, and the mapping is MappingQGeneric or a derived class, we can
+      // cells, and the mapping is MappingQ or a derived class, we can
       // use the fast method.
       if (active_fe_index.empty() && !cells.empty() && mapping->size() == 1 &&
-          dynamic_cast<const MappingQGeneric<dim> *>(&mapping->operator[](0)))
+          dynamic_cast<const MappingQ<dim> *>(&mapping->operator[](0)))
         compute_mapping_q(tria, cells, face_info.faces);
       else
         {
@@ -481,7 +481,7 @@ namespace internal
       this->mapping            = &mapping->operator[](0);
 
       if (active_fe_index.empty() && !cells.empty() && mapping->size() == 1 &&
-          dynamic_cast<const MappingQGeneric<dim> *>(&mapping->operator[](0)))
+          dynamic_cast<const MappingQ<dim> *>(&mapping->operator[](0)))
         compute_mapping_q(tria, cells, face_info.faces);
       else
         {
@@ -1213,7 +1213,7 @@ namespace internal
       mapping_q_query_fe_values(
         const unsigned int                                        begin_cell,
         const unsigned int                                        end_cell,
-        const MappingQGeneric<dim> &                              mapping_q,
+        const MappingQ<dim> &                                     mapping_q,
         const dealii::Triangulation<dim> &                        tria,
         const std::vector<std::pair<unsigned int, unsigned int>> &cell_array,
         const double                                              jacobian_size,
@@ -2695,12 +2695,11 @@ namespace internal
       const std::vector<FaceToCellTopology<VectorizedArrayType::size()>> &faces)
     {
       // step 1: extract quadrature point data with the data appropriate for
-      // MappingQGeneric
+      // MappingQ
       AssertDimension(this->mapping_collection->size(), 1);
 
-      const MappingQGeneric<dim> *mapping_q =
-        dynamic_cast<const MappingQGeneric<dim> *>(
-          &this->mapping_collection->operator[](0));
+      const MappingQ<dim> *mapping_q = dynamic_cast<const MappingQ<dim> *>(
+        &this->mapping_collection->operator[](0));
       Assert(mapping_q != nullptr, ExcInternalError());
 
       const unsigned int mapping_degree = mapping_q->get_degree();
index 9474ba5d8b907c6bea63a52ceebd365d57dec6e8..150de9193a170a0561da224352222e619b72adda 100644 (file)
@@ -184,7 +184,7 @@ namespace DerivativeApproximation
                        const unsigned int               component = 0);
 
   /**
-   * Call the function above with <tt>mapping=MappingQGeneric@<dim@>(1)</tt>.
+   * Call the function above with <tt>mapping=MappingQ@<dim@>(1)</tt>.
    */
   template <int dim, class InputVector, int spacedim>
   void
@@ -219,7 +219,7 @@ namespace DerivativeApproximation
                                 const unsigned int component = 0);
 
   /**
-   * Call the function above with <tt>mapping=MappingQGeneric@<dim@>(1)</tt>.
+   * Call the function above with <tt>mapping=MappingQ@<dim@>(1)</tt>.
    */
   template <int dim, class InputVector, int spacedim>
   void
@@ -257,7 +257,7 @@ namespace DerivativeApproximation
     const unsigned int  component = 0);
 
   /**
-   * Same as above, with <tt>mapping=MappingQGeneric@<dim@>(1)</tt>.
+   * Same as above, with <tt>mapping=MappingQ@<dim@>(1)</tt>.
    */
   template <int dim, int spacedim, class InputVector, int order>
   void
index e7e4bf220878a69a53db0506cebec307335bdacc..765065ee1ab54f76ec94234aaf551a3fc2fed73d 100644 (file)
@@ -355,7 +355,7 @@ public:
 
   /**
    * Call the @p estimate function, see above, with
-   * <tt>mapping=MappingQGeneric@<dim@>(1)</tt>.
+   * <tt>mapping=MappingQ@<dim@>(1)</tt>.
    */
   template <typename InputVector>
   static void
@@ -407,7 +407,7 @@ public:
 
   /**
    * Call the @p estimate function, see above, with
-   * <tt>mapping=MappingQGeneric@<dim@>(1)</tt>.
+   * <tt>mapping=MappingQ@<dim@>(1)</tt>.
    */
   template <typename InputVector>
   static void
@@ -641,7 +641,7 @@ public:
 
   /**
    * Call the @p estimate function, see above, with
-   * <tt>mapping=MappingQGeneric1<1>()</tt>.
+   * <tt>mapping=MappingQ1<1>()</tt>.
    */
   template <typename InputVector>
   static void
@@ -693,7 +693,7 @@ public:
 
   /**
    * Call the @p estimate function, see above, with
-   * <tt>mapping=MappingQGeneric1<1>()</tt>.
+   * <tt>mapping=MappingQ1<1>()</tt>.
    */
   template <typename InputVector>
   static void
index 32ab7006e09424c805e2d1eda252117ff12fc49a..21a0c2d25cf501f95e797bc713e89b558dd254e6 100644 (file)
@@ -104,7 +104,7 @@ namespace TrilinosWrappers
  * There exist two versions of almost all functions, one that takes an
  * explicit Mapping argument and one that does not. The second one generally
  * calls the first with an implicit $Q_1$ argument (i.e., with an argument of
- * kind MappingQGeneric(1)). If your intend your code to use a different
+ * kind MappingQ(1)). If your intend your code to use a different
  * mapping than a (bi-/tri-)linear one, then you need to call the functions
  * <b>with</b> mapping argument should be used.
  *
@@ -258,7 +258,7 @@ namespace MatrixCreator
 
   /**
    * Call the create_mass_matrix() function, see above, with
-   * <tt>mapping=MappingQGeneric@<dim@>(1)</tt>.
+   * <tt>mapping=MappingQ@<dim@>(1)</tt>.
    */
   template <int dim, int spacedim, typename number>
   void
@@ -302,7 +302,7 @@ namespace MatrixCreator
 
   /**
    * Call the create_mass_matrix() function, see above, with
-   * <tt>mapping=MappingQGeneric@<dim@>(1)</tt>.
+   * <tt>mapping=MappingQ@<dim@>(1)</tt>.
    */
   template <int dim, int spacedim, typename number>
   void
@@ -412,7 +412,7 @@ namespace MatrixCreator
 
   /**
    * Call the create_boundary_mass_matrix() function, see above, with
-   * <tt>mapping=MappingQGeneric@<dim@>(1)</tt>.
+   * <tt>mapping=MappingQ@<dim@>(1)</tt>.
    */
   template <int dim, int spacedim, typename number>
   void
@@ -491,7 +491,7 @@ namespace MatrixCreator
 
   /**
    * Call the create_laplace_matrix() function, see above, with
-   * <tt>mapping=MappingQGeneric@<dim@>(1)</tt>.
+   * <tt>mapping=MappingQ@<dim@>(1)</tt>.
    */
   template <int dim, int spacedim>
   void
@@ -534,7 +534,7 @@ namespace MatrixCreator
 
   /**
    * Call the create_laplace_matrix() function, see above, with
-   * <tt>mapping=MappingQGeneric@<dim@>(1)</tt>.
+   * <tt>mapping=MappingQ@<dim@>(1)</tt>.
    */
   template <int dim, int spacedim>
   void
index e8a1235ffb01631451b508205bfd35a068751e62..f3624336cdddddbde13c5c31c3fb5223ceed9f15 100644 (file)
@@ -46,7 +46,7 @@ DEAL_II_NAMESPACE_OPEN
  * @note There exist two versions of almost all functions, one that takes an
  * explicit Mapping argument and one that does not. The second one generally
  * calls the first with an implicit $Q_1$ argument (i.e., with an argument of
- * kind MappingQGeneric(1)). If your intend your code to use a different
+ * kind MappingQ(1)). If your intend your code to use a different
  * mapping than a (bi-/tri-)linear one, then you need to call the functions
  * <b>with</b> mapping argument should be used.
  *
index 056d53c9158bda29f26b86cae1745049ac2cd501..55d07a5ef1a707d6877cf7c69633d0ed3a4a061b 100644 (file)
@@ -194,7 +194,7 @@ namespace VectorTools
 
   /**
    * Call the other interpolate_boundary_values() function, see above, with
-   * <tt>mapping=MappingQGeneric@<dim,spacedim@>(1)</tt>. The same comments
+   * <tt>mapping=MappingQ@<dim,spacedim@>(1)</tt>. The same comments
    * apply as for the previous function, in particular about the use of the
    * component mask and the requires size of the function object.
    *
@@ -213,7 +213,7 @@ namespace VectorTools
 
   /**
    * Call the other interpolate_boundary_values() function, see above, with
-   * <tt>mapping=MappingQGeneric@<dim,spacedim@>(1)</tt>. The same comments
+   * <tt>mapping=MappingQ@<dim,spacedim@>(1)</tt>. The same comments
    * apply as for the previous function, in particular about the use of the
    * component mask and the requires size of the function object.
    */
@@ -316,7 +316,7 @@ namespace VectorTools
 
   /**
    * Call the other interpolate_boundary_values() function, see above, with
-   * <tt>mapping=MappingQGeneric@<dim,spacedim@>(1)</tt>. The same comments
+   * <tt>mapping=MappingQ@<dim,spacedim@>(1)</tt>. The same comments
    * apply as for the previous function, in particular about the use of the
    * component mask and the requires size of the function object.
    *
@@ -337,7 +337,7 @@ namespace VectorTools
 
   /**
    * Call the other interpolate_boundary_values() function, see above, with
-   * <tt>mapping=MappingQGeneric@<dim,spacedim@>(1)</tt>. The same comments
+   * <tt>mapping=MappingQ@<dim,spacedim@>(1)</tt>. The same comments
    * apply as for the previous function, in particular about the use of the
    * component mask and the requires size of the function object.
    *
@@ -443,7 +443,7 @@ namespace VectorTools
 
   /**
    * Call the project_boundary_values() function, see above, with
-   * <tt>mapping=MappingQGeneric@<dim,spacedim@>(1)</tt>.
+   * <tt>mapping=MappingQ@<dim,spacedim@>(1)</tt>.
    */
   template <int dim, int spacedim, typename number>
   void
@@ -471,7 +471,7 @@ namespace VectorTools
 
   /**
    * Call the project_boundary_values() function, see above, with
-   * <tt>mapping=MappingQGeneric@<dim,spacedim@>(1)</tt>.
+   * <tt>mapping=MappingQ@<dim,spacedim@>(1)</tt>.
    */
   template <int dim, int spacedim, typename number>
   void
@@ -534,7 +534,7 @@ namespace VectorTools
 
   /**
    * Call the project_boundary_values() function, see above, with
-   * <tt>mapping=MappingQGeneric@<dim,spacedim@>(1)</tt>.
+   * <tt>mapping=MappingQ@<dim,spacedim@>(1)</tt>.
    *
    * @ingroup constraints
    */
index d890b1a7d0c8b3310a1e77ace61d9afbffa22529..ff7b6a7a3c2dada2be7c5c10ff4e9dd5f596eed1 100644 (file)
@@ -136,7 +136,7 @@ namespace VectorTools
    * </p>
    *
    * Here, we have two cells that use a bilinear mapping (i.e.,
-   * MappingQGeneric(1)). Consequently, for each of the cells, the normal
+   * MappingQ(1)). Consequently, for each of the cells, the normal
    * vector is perpendicular to the straight edge. If the two edges at the top
    * and right are meant to approximate a curved boundary (as indicated by the
    * dashed line), then neither of the two computed normal vectors are equal
index 5420516083826f080223c1e60b74f4e8d8535664..64248847ed87efa81e1c3fa538d24e6faeed15ec 100644 (file)
@@ -151,7 +151,7 @@ namespace VectorTools
 
   /**
    * Call the integrate_difference() function, see above, with
-   * <tt>mapping=MappingQGeneric@<dim@>(1)</tt>.
+   * <tt>mapping=MappingQ@<dim@>(1)</tt>.
    */
   template <int dim, class InVector, class OutVector, int spacedim>
   void
@@ -183,7 +183,7 @@ namespace VectorTools
 
   /**
    * Call the integrate_difference() function, see above, with
-   * <tt>mapping=MappingQGeneric@<dim@>(1)</tt>.
+   * <tt>mapping=MappingQ@<dim@>(1)</tt>.
    */
   template <int dim, class InVector, class OutVector, int spacedim>
   void
index 3e5e63754cac0fcb4d73644cd72f17e38f8155ac..c0c00718fb063c3bfb5db664aba58b79458ceccf 100644 (file)
@@ -87,7 +87,7 @@ namespace VectorTools
 
   /**
    * Call the @p interpolate() function above with
-   * <tt>mapping=MappingQGeneric@<dim,spacedim@>(1)</tt>.
+   * <tt>mapping=MappingQ@<dim,spacedim@>(1)</tt>.
    */
   template <int dim, int spacedim, typename VectorType>
   void
index bade75be1baac4d9b47b843df17dbde07a2c004d..15a45479c81daa8609f62ab3759709c75aff63ea 100644 (file)
@@ -120,7 +120,7 @@ namespace VectorTools
 
   /**
    * Call the other compute_mean_value() function, see above, with
-   * <tt>mapping=MappingQGeneric@<dim@>(1)</tt>.
+   * <tt>mapping=MappingQ@<dim@>(1)</tt>.
    */
   template <int dim, typename VectorType, int spacedim>
   typename VectorType::value_type
index 5f2eba5186a36b198a6bf91a07b5d8fd0aa4e9e3..f9d7a2395a37db744a86d1cddb916988834615dc 100644 (file)
@@ -152,7 +152,7 @@ namespace VectorTools
 
   /**
    * Call the project() function above, with
-   * <tt>mapping=MappingQGeneric@<dim@>(1)</tt>.
+   * <tt>mapping=MappingQ@<dim@>(1)</tt>.
    */
   template <int dim, typename VectorType, int spacedim>
   void
index 18a06632f7742c9f269ca7e6819381bce578584d..07dd0f421a9547c55f8c1ec1dae42e225265117f 100644 (file)
@@ -67,7 +67,7 @@ namespace VectorTools
 
   /**
    * Call the create_right_hand_side() function, see above, with
-   * <tt>mapping=MappingQGeneric@<dim@>(1)</tt>.
+   * <tt>mapping=MappingQ@<dim@>(1)</tt>.
    */
   template <int dim, int spacedim, typename VectorType>
   void
@@ -128,7 +128,7 @@ namespace VectorTools
 
   /**
    * Call the create_boundary_right_hand_side() function, see above, with
-   * <tt>mapping=MappingQGeneric@<dim@>(1)</tt>.
+   * <tt>mapping=MappingQ@<dim@>(1)</tt>.
    *
    * @see
    * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
index 7cbd87bb8791a0a7b2a8f57b826c690a12d13389..f3a9205deb40a869c72d5f58ad78691564fcf7d6 100644 (file)
@@ -55,10 +55,12 @@ SET(_unity_include_src
   fe_simplex_p.cc
   fe_simplex_p_bubbles.cc
   fe_trace.cc
+  fe_values_extractors.cc
   fe_wedge_p.cc
   mapping_c1.cc
   mapping_cartesian.cc
   mapping.cc
+  mapping_fe.cc
   mapping_q1.cc
   mapping_q.cc
   mapping_q_cache.cc
@@ -67,7 +69,6 @@ SET(_unity_include_src
 
 SET(_separate_src
   fe_values.cc
-  fe_values_extractors.cc
   fe_values_inst2.cc
   fe_values_inst3.cc
   fe_values_inst4.cc
@@ -78,8 +79,6 @@ SET(_separate_src
   fe_tools.cc
   fe_tools_interpolate.cc
   fe_tools_extrapolate.cc
-  mapping_fe.cc
-  mapping_q_generic.cc
   mapping_q1_eulerian.cc
   mapping_q_eulerian.cc
   )
@@ -141,7 +140,6 @@ SET(_inst
   mapping.inst.in
   mapping_fe.inst.in
   mapping_fe_field.inst.in
-  mapping_q_generic.inst.in
   mapping_q1_eulerian.inst.in
   mapping_q1.inst.in
   mapping_q_cache.inst.in
index d5165e3887835e7da046ae1eb6fd70f6dc975a41..14bb90181f6a67dde5f8fea41dda07388c020785 100644 (file)
@@ -29,7 +29,7 @@ DEAL_II_NAMESPACE_OPEN
 
 template <int dim, int spacedim>
 MappingC1<dim, spacedim>::MappingC1()
-  : MappingQGeneric<dim, spacedim>(3)
+  : MappingQ<dim, spacedim>(3)
 {
   Assert(dim > 1, ExcImpossibleInDim(dim));
 }
index aaf181dd8f92c56873b76bca5adee54c5d556031..2f4c30aeb45def22039e1cb1229a820479be7f16 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2001 - 2021 by the deal.II authors
+// Copyright (C) 2000 - 2021 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
 //
 // ---------------------------------------------------------------------
 
+
 #include <deal.II/base/array_view.h>
+#include <deal.II/base/derivative_form.h>
 #include <deal.II/base/memory_consumption.h>
-#include <deal.II/base/polynomial.h>
+#include <deal.II/base/qprojector.h>
 #include <deal.II/base/quadrature.h>
 #include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/table.h>
 #include <deal.II/base/tensor_product_polynomials.h>
-#include <deal.II/base/utilities.h>
-
-#include <deal.II/dofs/dof_accessor.h>
 
-#include <deal.II/fe/fe_q.h>
+#include <deal.II/fe/fe_dgq.h>
+#include <deal.II/fe/fe_tools.h>
 #include <deal.II/fe/fe_values.h>
 #include <deal.II/fe/mapping_q.h>
+#include <deal.II/fe/mapping_q1.h>
+#include <deal.II/fe/mapping_q_internal.h>
 
+#include <deal.II/grid/manifold_lib.h>
+#include <deal.II/grid/tria.h>
 #include <deal.II/grid/tria_iterator.h>
 
-#include <deal.II/lac/full_matrix.h>
+DEAL_II_DISABLE_EXTRA_DIAGNOSTICS
+#include <boost/container/small_vector.hpp>
+DEAL_II_ENABLE_EXTRA_DIAGNOSTICS
 
+#include <algorithm>
+#include <array>
+#include <cmath>
 #include <memory>
 #include <numeric>
 
+
 DEAL_II_NAMESPACE_OPEN
 
 
 template <int dim, int spacedim>
-MappingQ<dim, spacedim>::MappingQ(const unsigned int degree)
-  : MappingQGeneric<dim, spacedim>(degree)
+MappingQ<dim, spacedim>::InternalData::InternalData(
+  const unsigned int polynomial_degree)
+  : polynomial_degree(polynomial_degree)
+  , n_shape_functions(Utilities::fixed_power<dim>(polynomial_degree + 1))
+  , line_support_points(QGaussLobatto<1>(polynomial_degree + 1))
+  , tensor_product_quadrature(false)
 {}
 
 
 
 template <int dim, int spacedim>
-MappingQ<dim, spacedim>::MappingQ(const unsigned int degree, const bool)
-  : MappingQGeneric<dim, spacedim>(degree)
-{}
+std::size_t
+MappingQ<dim, spacedim>::InternalData::memory_consumption() const
+{
+  return (
+    Mapping<dim, spacedim>::InternalDataBase::memory_consumption() +
+    MemoryConsumption::memory_consumption(shape_values) +
+    MemoryConsumption::memory_consumption(shape_derivatives) +
+    MemoryConsumption::memory_consumption(covariant) +
+    MemoryConsumption::memory_consumption(contravariant) +
+    MemoryConsumption::memory_consumption(unit_tangentials) +
+    MemoryConsumption::memory_consumption(aux) +
+    MemoryConsumption::memory_consumption(mapping_support_points) +
+    MemoryConsumption::memory_consumption(cell_of_current_support_points) +
+    MemoryConsumption::memory_consumption(volume_elements) +
+    MemoryConsumption::memory_consumption(polynomial_degree) +
+    MemoryConsumption::memory_consumption(n_shape_functions));
+}
+
+
+
+template <int dim, int spacedim>
+void
+MappingQ<dim, spacedim>::InternalData::initialize(
+  const UpdateFlags      update_flags,
+  const Quadrature<dim> &q,
+  const unsigned int     n_original_q_points)
+{
+  // store the flags in the internal data object so we can access them
+  // in fill_fe_*_values()
+  this->update_each = update_flags;
+
+  const unsigned int n_q_points = q.size();
+
+  const bool needs_higher_order_terms =
+    this->update_each &
+    (update_jacobian_pushed_forward_grads | update_jacobian_2nd_derivatives |
+     update_jacobian_pushed_forward_2nd_derivatives |
+     update_jacobian_3rd_derivatives |
+     update_jacobian_pushed_forward_3rd_derivatives);
+
+  if (this->update_each & update_covariant_transformation)
+    covariant.resize(n_original_q_points);
+
+  if (this->update_each & update_contravariant_transformation)
+    contravariant.resize(n_original_q_points);
+
+  if (this->update_each & update_volume_elements)
+    volume_elements.resize(n_original_q_points);
+
+  tensor_product_quadrature = q.is_tensor_product();
+
+  // use of MatrixFree only for higher order elements and with more than one
+  // point where tensor products do not make sense
+  if (polynomial_degree < 2 || n_q_points == 1)
+    tensor_product_quadrature = false;
+
+  if (dim > 1)
+    {
+      // find out if the one-dimensional formula is the same
+      // in all directions
+      if (tensor_product_quadrature)
+        {
+          const std::array<Quadrature<1>, dim> quad_array =
+            q.get_tensor_basis();
+          for (unsigned int i = 1; i < dim && tensor_product_quadrature; ++i)
+            {
+              if (quad_array[i - 1].size() != quad_array[i].size())
+                {
+                  tensor_product_quadrature = false;
+                  break;
+                }
+              else
+                {
+                  const std::vector<Point<1>> &points_1 =
+                    quad_array[i - 1].get_points();
+                  const std::vector<Point<1>> &points_2 =
+                    quad_array[i].get_points();
+                  const std::vector<double> &weights_1 =
+                    quad_array[i - 1].get_weights();
+                  const std::vector<double> &weights_2 =
+                    quad_array[i].get_weights();
+                  for (unsigned int j = 0; j < quad_array[i].size(); ++j)
+                    {
+                      if (std::abs(points_1[j][0] - points_2[j][0]) > 1.e-10 ||
+                          std::abs(weights_1[j] - weights_2[j]) > 1.e-10)
+                        {
+                          tensor_product_quadrature = false;
+                          break;
+                        }
+                    }
+                }
+            }
+
+          if (tensor_product_quadrature)
+            {
+              // use a 1D FE_DGQ and adjust the hierarchic -> lexicographic
+              // numbering manually (building an FE_Q<dim> is relatively
+              // expensive due to constraints)
+              const FE_DGQ<1> fe(polynomial_degree);
+              shape_info.reinit(q.get_tensor_basis()[0], fe);
+              shape_info.lexicographic_numbering =
+                FETools::lexicographic_to_hierarchic_numbering<dim>(
+                  polynomial_degree);
+              shape_info.n_q_points = q.size();
+              shape_info.dofs_per_component_on_cell =
+                Utilities::pow(polynomial_degree + 1, dim);
+            }
+        }
+    }
+
+  // Only fill the big arrays on demand in case we cannot use the tensor
+  // product quadrature code path
+  if (dim == 1 || !tensor_product_quadrature || needs_higher_order_terms)
+    {
+      // see if we need the (transformation) shape function values
+      // and/or gradients and resize the necessary arrays
+      if (this->update_each & update_quadrature_points)
+        shape_values.resize(n_shape_functions * n_q_points);
+
+      if (this->update_each &
+          (update_covariant_transformation |
+           update_contravariant_transformation | update_JxW_values |
+           update_boundary_forms | update_normal_vectors | update_jacobians |
+           update_jacobian_grads | update_inverse_jacobians |
+           update_jacobian_pushed_forward_grads |
+           update_jacobian_2nd_derivatives |
+           update_jacobian_pushed_forward_2nd_derivatives |
+           update_jacobian_3rd_derivatives |
+           update_jacobian_pushed_forward_3rd_derivatives))
+        shape_derivatives.resize(n_shape_functions * n_q_points);
+
+      if (this->update_each &
+          (update_jacobian_grads | update_jacobian_pushed_forward_grads))
+        shape_second_derivatives.resize(n_shape_functions * n_q_points);
+
+      if (this->update_each & (update_jacobian_2nd_derivatives |
+                               update_jacobian_pushed_forward_2nd_derivatives))
+        shape_third_derivatives.resize(n_shape_functions * n_q_points);
+
+      if (this->update_each & (update_jacobian_3rd_derivatives |
+                               update_jacobian_pushed_forward_3rd_derivatives))
+        shape_fourth_derivatives.resize(n_shape_functions * n_q_points);
+
+      // now also fill the various fields with their correct values
+      compute_shape_function_values(q.get_points());
+    }
+}
+
+
+
+template <int dim, int spacedim>
+void
+MappingQ<dim, spacedim>::InternalData::initialize_face(
+  const UpdateFlags      update_flags,
+  const Quadrature<dim> &q,
+  const unsigned int     n_original_q_points)
+{
+  initialize(update_flags, q, n_original_q_points);
+
+  if (dim > 1 && tensor_product_quadrature)
+    {
+      constexpr unsigned int facedim = dim - 1;
+      const FE_DGQ<1>        fe(polynomial_degree);
+      shape_info.reinit(q.get_tensor_basis()[0], fe);
+      shape_info.lexicographic_numbering =
+        FETools::lexicographic_to_hierarchic_numbering<facedim>(
+          polynomial_degree);
+      shape_info.n_q_points = n_original_q_points;
+      shape_info.dofs_per_component_on_cell =
+        Utilities::pow(polynomial_degree + 1, dim);
+    }
+
+  if (dim > 1)
+    {
+      if (this->update_each &
+          (update_boundary_forms | update_normal_vectors | update_jacobians |
+           update_JxW_values | update_inverse_jacobians))
+        {
+          aux.resize(dim - 1,
+                     AlignedVector<Tensor<1, spacedim>>(n_original_q_points));
+
+          // Compute tangentials to the unit cell.
+          for (const unsigned int i : GeometryInfo<dim>::face_indices())
+            {
+              unit_tangentials[i].resize(n_original_q_points);
+              std::fill(unit_tangentials[i].begin(),
+                        unit_tangentials[i].end(),
+                        GeometryInfo<dim>::unit_tangential_vectors[i][0]);
+              if (dim > 2)
+                {
+                  unit_tangentials[GeometryInfo<dim>::faces_per_cell + i]
+                    .resize(n_original_q_points);
+                  std::fill(
+                    unit_tangentials[GeometryInfo<dim>::faces_per_cell + i]
+                      .begin(),
+                    unit_tangentials[GeometryInfo<dim>::faces_per_cell + i]
+                      .end(),
+                    GeometryInfo<dim>::unit_tangential_vectors[i][1]);
+                }
+            }
+        }
+    }
+}
+
+
+
+template <int dim, int spacedim>
+void
+MappingQ<dim, spacedim>::InternalData::compute_shape_function_values(
+  const std::vector<Point<dim>> &unit_points)
+{
+  const unsigned int n_points = unit_points.size();
+
+  // Construct the tensor product polynomials used as shape functions for
+  // the Qp mapping of cells at the boundary.
+  const TensorProductPolynomials<dim> tensor_pols(
+    Polynomials::generate_complete_Lagrange_basis(
+      line_support_points.get_points()));
+  Assert(n_shape_functions == tensor_pols.n(), ExcInternalError());
+
+  // then also construct the mapping from lexicographic to the Qp shape
+  // function numbering
+  const std::vector<unsigned int> renumber =
+    FETools::hierarchic_to_lexicographic_numbering<dim>(polynomial_degree);
+
+  std::vector<double>         values;
+  std::vector<Tensor<1, dim>> grads;
+  if (shape_values.size() != 0)
+    {
+      Assert(shape_values.size() == n_shape_functions * n_points,
+             ExcInternalError());
+      values.resize(n_shape_functions);
+    }
+  if (shape_derivatives.size() != 0)
+    {
+      Assert(shape_derivatives.size() == n_shape_functions * n_points,
+             ExcInternalError());
+      grads.resize(n_shape_functions);
+    }
+
+  std::vector<Tensor<2, dim>> grad2;
+  if (shape_second_derivatives.size() != 0)
+    {
+      Assert(shape_second_derivatives.size() == n_shape_functions * n_points,
+             ExcInternalError());
+      grad2.resize(n_shape_functions);
+    }
+
+  std::vector<Tensor<3, dim>> grad3;
+  if (shape_third_derivatives.size() != 0)
+    {
+      Assert(shape_third_derivatives.size() == n_shape_functions * n_points,
+             ExcInternalError());
+      grad3.resize(n_shape_functions);
+    }
+
+  std::vector<Tensor<4, dim>> grad4;
+  if (shape_fourth_derivatives.size() != 0)
+    {
+      Assert(shape_fourth_derivatives.size() == n_shape_functions * n_points,
+             ExcInternalError());
+      grad4.resize(n_shape_functions);
+    }
+
+
+  if (shape_values.size() != 0 || shape_derivatives.size() != 0 ||
+      shape_second_derivatives.size() != 0 ||
+      shape_third_derivatives.size() != 0 ||
+      shape_fourth_derivatives.size() != 0)
+    for (unsigned int point = 0; point < n_points; ++point)
+      {
+        tensor_pols.evaluate(
+          unit_points[point], values, grads, grad2, grad3, grad4);
+
+        if (shape_values.size() != 0)
+          for (unsigned int i = 0; i < n_shape_functions; ++i)
+            shape(point, i) = values[renumber[i]];
+
+        if (shape_derivatives.size() != 0)
+          for (unsigned int i = 0; i < n_shape_functions; ++i)
+            derivative(point, i) = grads[renumber[i]];
+
+        if (shape_second_derivatives.size() != 0)
+          for (unsigned int i = 0; i < n_shape_functions; ++i)
+            second_derivative(point, i) = grad2[renumber[i]];
+
+        if (shape_third_derivatives.size() != 0)
+          for (unsigned int i = 0; i < n_shape_functions; ++i)
+            third_derivative(point, i) = grad3[renumber[i]];
+
+        if (shape_fourth_derivatives.size() != 0)
+          for (unsigned int i = 0; i < n_shape_functions; ++i)
+            fourth_derivative(point, i) = grad4[renumber[i]];
+      }
+}
+
+
+
+template <int dim, int spacedim>
+MappingQ<dim, spacedim>::MappingQ(const unsigned int p)
+  : polynomial_degree(p)
+  , line_support_points(
+      QGaussLobatto<1>(this->polynomial_degree + 1).get_points())
+  , polynomials_1d(
+      Polynomials::generate_complete_Lagrange_basis(line_support_points))
+  , renumber_lexicographic_to_hierarchic(
+      FETools::lexicographic_to_hierarchic_numbering<dim>(p))
+  , unit_cell_support_points(
+      internal::MappingQImplementation::unit_support_points<dim>(
+        line_support_points,
+        renumber_lexicographic_to_hierarchic))
+  , support_point_weights_perimeter_to_interior(
+      internal::MappingQImplementation::
+        compute_support_point_weights_perimeter_to_interior(
+          this->polynomial_degree,
+          dim))
+  , support_point_weights_cell(
+      internal::MappingQImplementation::compute_support_point_weights_cell<dim>(
+        this->polynomial_degree))
+{
+  Assert(p >= 1,
+         ExcMessage("It only makes sense to create polynomial mappings "
+                    "with a polynomial degree greater or equal to one."));
+}
+
+
+
+template <int dim, int spacedim>
+MappingQ<dim, spacedim>::MappingQ(const unsigned int p, const bool)
+  : polynomial_degree(p)
+  , line_support_points(
+      QGaussLobatto<1>(this->polynomial_degree + 1).get_points())
+  , polynomials_1d(
+      Polynomials::generate_complete_Lagrange_basis(line_support_points))
+  , renumber_lexicographic_to_hierarchic(
+      FETools::lexicographic_to_hierarchic_numbering<dim>(p))
+  , unit_cell_support_points(
+      internal::MappingQImplementation::unit_support_points<dim>(
+        line_support_points,
+        renumber_lexicographic_to_hierarchic))
+  , support_point_weights_perimeter_to_interior(
+      internal::MappingQImplementation::
+        compute_support_point_weights_perimeter_to_interior(
+          this->polynomial_degree,
+          dim))
+  , support_point_weights_cell(
+      internal::MappingQImplementation::compute_support_point_weights_cell<dim>(
+        this->polynomial_degree))
+{
+  Assert(p >= 1,
+         ExcMessage("It only makes sense to create polynomial mappings "
+                    "with a polynomial degree greater or equal to one."));
+}
 
 
 
 template <int dim, int spacedim>
 MappingQ<dim, spacedim>::MappingQ(const MappingQ<dim, spacedim> &mapping)
-  : MappingQGeneric<dim, spacedim>(mapping)
+  : polynomial_degree(mapping.polynomial_degree)
+  , line_support_points(mapping.line_support_points)
+  , polynomials_1d(mapping.polynomials_1d)
+  , renumber_lexicographic_to_hierarchic(
+      mapping.renumber_lexicographic_to_hierarchic)
+  , support_point_weights_perimeter_to_interior(
+      mapping.support_point_weights_perimeter_to_interior)
+  , support_point_weights_cell(mapping.support_point_weights_cell)
 {}
 
 
-// explicit instantiations
+
+template <int dim, int spacedim>
+std::unique_ptr<Mapping<dim, spacedim>>
+MappingQ<dim, spacedim>::clone() const
+{
+  return std::make_unique<MappingQ<dim, spacedim>>(*this);
+}
+
+
+
+template <int dim, int spacedim>
+unsigned int
+MappingQ<dim, spacedim>::get_degree() const
+{
+  return polynomial_degree;
+}
+
+
+
+template <int dim, int spacedim>
+Point<spacedim>
+MappingQ<dim, spacedim>::transform_unit_to_real_cell(
+  const typename Triangulation<dim, spacedim>::cell_iterator &cell,
+  const Point<dim> &                                          p) const
+{
+  return Point<spacedim>(internal::evaluate_tensor_product_value_and_gradient(
+                           polynomials_1d,
+                           this->compute_mapping_support_points(cell),
+                           p,
+                           polynomials_1d.size() == 2,
+                           renumber_lexicographic_to_hierarchic)
+                           .first);
+}
+
+
+// In the code below, GCC tries to instantiate MappingQ<3,4> when
+// seeing which of the overloaded versions of
+// do_transform_real_to_unit_cell_internal() to call. This leads to bad
+// error messages and, generally, nothing very good. Avoid this by ensuring
+// that this class exists, but does not have an inner InternalData
+// type, thereby ruling out the codim-1 version of the function
+// below when doing overload resolution.
+template <>
+class MappingQ<3, 4>
+{};
+
+
+
+// visual studio freaks out when trying to determine if
+// do_transform_real_to_unit_cell_internal with dim=3 and spacedim=4 is a good
+// candidate. So instead of letting the compiler pick the correct overload, we
+// use template specialization to make sure we pick up the right function to
+// call:
+
+template <int dim, int spacedim>
+Point<dim>
+MappingQ<dim, spacedim>::transform_real_to_unit_cell_internal(
+  const typename Triangulation<dim, spacedim>::cell_iterator &,
+  const Point<spacedim> &,
+  const Point<dim> &) const
+{
+  // default implementation (should never be called)
+  Assert(false, ExcInternalError());
+  return {};
+}
+
+
+
+template <>
+Point<1>
+MappingQ<1, 1>::transform_real_to_unit_cell_internal(
+  const Triangulation<1, 1>::cell_iterator &cell,
+  const Point<1> &                          p,
+  const Point<1> &                          initial_p_unit) const
+{
+  // dispatch to the various specializations for spacedim=dim,
+  // spacedim=dim+1, etc
+  return internal::MappingQImplementation::
+    do_transform_real_to_unit_cell_internal<1>(
+      p,
+      initial_p_unit,
+      this->compute_mapping_support_points(cell),
+      polynomials_1d,
+      renumber_lexicographic_to_hierarchic);
+}
+
+
+
+template <>
+Point<2>
+MappingQ<2, 2>::transform_real_to_unit_cell_internal(
+  const Triangulation<2, 2>::cell_iterator &cell,
+  const Point<2> &                          p,
+  const Point<2> &                          initial_p_unit) const
+{
+  return internal::MappingQImplementation::
+    do_transform_real_to_unit_cell_internal<2>(
+      p,
+      initial_p_unit,
+      this->compute_mapping_support_points(cell),
+      polynomials_1d,
+      renumber_lexicographic_to_hierarchic);
+}
+
+
+
+template <>
+Point<3>
+MappingQ<3, 3>::transform_real_to_unit_cell_internal(
+  const Triangulation<3, 3>::cell_iterator &cell,
+  const Point<3> &                          p,
+  const Point<3> &                          initial_p_unit) const
+{
+  return internal::MappingQImplementation::
+    do_transform_real_to_unit_cell_internal<3>(
+      p,
+      initial_p_unit,
+      this->compute_mapping_support_points(cell),
+      polynomials_1d,
+      renumber_lexicographic_to_hierarchic);
+}
+
+
+
+template <>
+Point<1>
+MappingQ<1, 2>::transform_real_to_unit_cell_internal(
+  const Triangulation<1, 2>::cell_iterator &cell,
+  const Point<2> &                          p,
+  const Point<1> &                          initial_p_unit) const
+{
+  const int dim      = 1;
+  const int spacedim = 2;
+
+  const Quadrature<dim> point_quadrature(initial_p_unit);
+
+  UpdateFlags update_flags = update_quadrature_points | update_jacobians;
+  if (spacedim > dim)
+    update_flags |= update_jacobian_grads;
+  auto mdata = Utilities::dynamic_unique_cast<InternalData>(
+    get_data(update_flags, point_quadrature));
+
+  mdata->mapping_support_points = this->compute_mapping_support_points(cell);
+
+  // dispatch to the various specializations for spacedim=dim,
+  // spacedim=dim+1, etc
+  return internal::MappingQImplementation::
+    do_transform_real_to_unit_cell_internal_codim1<1>(cell,
+                                                      p,
+                                                      initial_p_unit,
+                                                      *mdata);
+}
+
+
+
+template <>
+Point<2>
+MappingQ<2, 3>::transform_real_to_unit_cell_internal(
+  const Triangulation<2, 3>::cell_iterator &cell,
+  const Point<3> &                          p,
+  const Point<2> &                          initial_p_unit) const
+{
+  const int dim      = 2;
+  const int spacedim = 3;
+
+  const Quadrature<dim> point_quadrature(initial_p_unit);
+
+  UpdateFlags update_flags = update_quadrature_points | update_jacobians;
+  if (spacedim > dim)
+    update_flags |= update_jacobian_grads;
+  auto mdata = Utilities::dynamic_unique_cast<InternalData>(
+    get_data(update_flags, point_quadrature));
+
+  mdata->mapping_support_points = this->compute_mapping_support_points(cell);
+
+  // dispatch to the various specializations for spacedim=dim,
+  // spacedim=dim+1, etc
+  return internal::MappingQImplementation::
+    do_transform_real_to_unit_cell_internal_codim1<2>(cell,
+                                                      p,
+                                                      initial_p_unit,
+                                                      *mdata);
+}
+
+template <>
+Point<1>
+MappingQ<1, 3>::transform_real_to_unit_cell_internal(
+  const Triangulation<1, 3>::cell_iterator &,
+  const Point<3> &,
+  const Point<1> &) const
+{
+  Assert(false, ExcNotImplemented());
+  return {};
+}
+
+
+
+template <int dim, int spacedim>
+Point<dim>
+MappingQ<dim, spacedim>::transform_real_to_unit_cell(
+  const typename Triangulation<dim, spacedim>::cell_iterator &cell,
+  const Point<spacedim> &                                     p) const
+{
+  // Use an exact formula if one is available. this is only the case
+  // for Q1 mappings in 1d, and in 2d if dim==spacedim
+  if (this->preserves_vertex_locations() && (polynomial_degree == 1) &&
+      ((dim == 1) || ((dim == 2) && (dim == spacedim))))
+    {
+      // The dimension-dependent algorithms are much faster (about 25-45x in
+      // 2D) but fail most of the time when the given point (p) is not in the
+      // cell. The dimension-independent Newton algorithm given below is
+      // slower, but more robust (though it still sometimes fails). Therefore
+      // this function implements the following strategy based on the
+      // p's dimension:
+      //
+      // * In 1D this mapping is linear, so the mapping is always invertible
+      //   (and the exact formula is known) as long as the cell has non-zero
+      //   length.
+      // * In 2D the exact (quadratic) formula is called first. If either the
+      //   exact formula does not succeed (negative discriminant in the
+      //   quadratic formula) or succeeds but finds a solution outside of the
+      //   unit cell, then the Newton solver is called. The rationale for the
+      //   second choice is that the exact formula may provide two different
+      //   answers when mapping a point outside of the real cell, but the
+      //   Newton solver (if it converges) will only return one answer.
+      //   Otherwise the exact formula successfully found a point in the unit
+      //   cell and that value is returned.
+      // * In 3D there is no (known to the authors) exact formula, so the Newton
+      //   algorithm is used.
+      const auto vertices_ = this->get_vertices(cell);
+
+      std::array<Point<spacedim>, GeometryInfo<dim>::vertices_per_cell>
+        vertices;
+      for (unsigned int i = 0; i < vertices.size(); ++i)
+        vertices[i] = vertices_[i];
+
+      try
+        {
+          switch (dim)
+            {
+              case 1:
+                {
+                  // formula not subject to any issues in 1d
+                  if (spacedim == 1)
+                    return internal::MappingQ1::transform_real_to_unit_cell(
+                      vertices, p);
+                  else
+                    break;
+                }
+
+              case 2:
+                {
+                  const Point<dim> point =
+                    internal::MappingQ1::transform_real_to_unit_cell(vertices,
+                                                                     p);
+
+                  // formula not guaranteed to work for points outside of
+                  // the cell. only take the computed point if it lies
+                  // inside the reference cell
+                  const double eps = 1e-15;
+                  if (-eps <= point(1) && point(1) <= 1 + eps &&
+                      -eps <= point(0) && point(0) <= 1 + eps)
+                    {
+                      return point;
+                    }
+                  else
+                    break;
+                }
+
+              default:
+                {
+                  // we should get here, based on the if-condition at the top
+                  Assert(false, ExcInternalError());
+                }
+            }
+        }
+      catch (
+        const typename Mapping<spacedim, spacedim>::ExcTransformationFailed &)
+        {
+          // simply fall through and continue on to the standard Newton code
+        }
+    }
+  else
+    {
+      // we can't use an explicit formula,
+    }
+
+
+  // Find the initial value for the Newton iteration by a normal
+  // projection to the least square plane determined by the vertices
+  // of the cell
+  Point<dim> initial_p_unit;
+  if (this->preserves_vertex_locations())
+    {
+      initial_p_unit = cell->real_to_unit_cell_affine_approximation(p);
+      // in 1d with spacedim > 1 the affine approximation is exact
+      if (dim == 1 && polynomial_degree == 1)
+        return initial_p_unit;
+    }
+  else
+    {
+      // else, we simply use the mid point
+      for (unsigned int d = 0; d < dim; ++d)
+        initial_p_unit[d] = 0.5;
+    }
+
+  // perform the Newton iteration and return the result. note that this
+  // statement may throw an exception, which we simply pass up to the caller
+  const Point<dim> p_unit =
+    this->transform_real_to_unit_cell_internal(cell, p, initial_p_unit);
+  if (p_unit[0] == std::numeric_limits<double>::infinity())
+    AssertThrow(false,
+                (typename Mapping<dim, spacedim>::ExcTransformationFailed()));
+  return p_unit;
+}
+
+
+
+template <int dim, int spacedim>
+void
+MappingQ<dim, spacedim>::transform_points_real_to_unit_cell(
+  const typename Triangulation<dim, spacedim>::cell_iterator &cell,
+  const ArrayView<const Point<spacedim>> &                    real_points,
+  const ArrayView<Point<dim>> &                               unit_points) const
+{
+  // Go to base class functions for dim < spacedim because it is not yet
+  // implemented with optimized code.
+  if (dim < spacedim)
+    {
+      Mapping<dim, spacedim>::transform_points_real_to_unit_cell(cell,
+                                                                 real_points,
+                                                                 unit_points);
+      return;
+    }
+
+  AssertDimension(real_points.size(), unit_points.size());
+  const std::vector<Point<spacedim>> support_points =
+    this->compute_mapping_support_points(cell);
+
+  // From the given (high-order) support points, now only pick the first
+  // 2^dim points and construct an affine approximation from those.
+  internal::MappingQImplementation::InverseQuadraticApproximation<dim, spacedim>
+    inverse_approximation(support_points, unit_cell_support_points);
+
+  const unsigned int n_points = real_points.size();
+  const unsigned int n_lanes  = VectorizedArray<double>::size();
+
+  // Use the more heavy VectorizedArray code path if there is more than
+  // one point left to compute
+  for (unsigned int i = 0; i < n_points; i += n_lanes)
+    if (n_points - i > 1)
+      {
+        Point<spacedim, VectorizedArray<double>> p_vec;
+        for (unsigned int j = 0; j < n_lanes; ++j)
+          if (i + j < n_points)
+            for (unsigned int d = 0; d < spacedim; ++d)
+              p_vec[d][j] = real_points[i + j][d];
+          else
+            for (unsigned int d = 0; d < spacedim; ++d)
+              p_vec[d][j] = real_points[i][d];
+
+        Point<dim, VectorizedArray<double>> unit_point =
+          internal::MappingQImplementation::
+            do_transform_real_to_unit_cell_internal<dim, spacedim>(
+              p_vec,
+              inverse_approximation.compute(p_vec),
+              support_points,
+              polynomials_1d,
+              renumber_lexicographic_to_hierarchic);
+
+        // If the vectorized computation failed, it could be that only some of
+        // the lanes failed but others would have succeeded if we had let them
+        // compute alone without interference (like negative Jacobian
+        // determinants) from other SIMD lanes. Repeat the computation in this
+        // unlikely case with scalar arguments.
+        for (unsigned int j = 0; j < n_lanes && i + j < n_points; ++j)
+          if (unit_point[0][j] == std::numeric_limits<double>::infinity())
+            unit_points[i + j] = internal::MappingQImplementation::
+              do_transform_real_to_unit_cell_internal<dim, spacedim>(
+                real_points[i + j],
+                inverse_approximation.compute(real_points[i + j]),
+                support_points,
+                polynomials_1d,
+                renumber_lexicographic_to_hierarchic);
+          else
+            for (unsigned int d = 0; d < dim; ++d)
+              unit_points[i + j][d] = unit_point[d][j];
+      }
+    else
+      unit_points[i] = internal::MappingQImplementation::
+        do_transform_real_to_unit_cell_internal<dim, spacedim>(
+          real_points[i],
+          inverse_approximation.compute(real_points[i]),
+          support_points,
+          polynomials_1d,
+          renumber_lexicographic_to_hierarchic);
+}
+
+
+
+template <int dim, int spacedim>
+UpdateFlags
+MappingQ<dim, spacedim>::requires_update_flags(const UpdateFlags in) const
+{
+  // add flags if the respective quantities are necessary to compute
+  // what we need. note that some flags appear in both the conditions
+  // and in subsequent set operations. this leads to some circular
+  // logic. the only way to treat this is to iterate. since there are
+  // 5 if-clauses in the loop, it will take at most 5 iterations to
+  // converge. do them:
+  UpdateFlags out = in;
+  for (unsigned int i = 0; i < 5; ++i)
+    {
+      // The following is a little incorrect:
+      // If not applied on a face,
+      // update_boundary_forms does not
+      // make sense. On the other hand,
+      // it is necessary on a
+      // face. Currently,
+      // update_boundary_forms is simply
+      // ignored for the interior of a
+      // cell.
+      if (out & (update_JxW_values | update_normal_vectors))
+        out |= update_boundary_forms;
+
+      if (out & (update_covariant_transformation | update_JxW_values |
+                 update_jacobians | update_jacobian_grads |
+                 update_boundary_forms | update_normal_vectors))
+        out |= update_contravariant_transformation;
+
+      if (out &
+          (update_inverse_jacobians | update_jacobian_pushed_forward_grads |
+           update_jacobian_pushed_forward_2nd_derivatives |
+           update_jacobian_pushed_forward_3rd_derivatives))
+        out |= update_covariant_transformation;
+
+      // The contravariant transformation is used in the Piola
+      // transformation, which requires the determinant of the Jacobi
+      // matrix of the transformation.  Because we have no way of
+      // knowing here whether the finite element wants to use the
+      // contravariant or the Piola transforms, we add the JxW values
+      // to the list of flags to be updated for each cell.
+      if (out & update_contravariant_transformation)
+        out |= update_volume_elements;
+
+      // the same is true when computing normal vectors: they require
+      // the determinant of the Jacobian
+      if (out & update_normal_vectors)
+        out |= update_volume_elements;
+    }
+
+  return out;
+}
+
+
+
+template <int dim, int spacedim>
+std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase>
+MappingQ<dim, spacedim>::get_data(const UpdateFlags      update_flags,
+                                  const Quadrature<dim> &q) const
+{
+  std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
+    std::make_unique<InternalData>(polynomial_degree);
+  auto &data = dynamic_cast<InternalData &>(*data_ptr);
+  data.initialize(this->requires_update_flags(update_flags), q, q.size());
+
+  return data_ptr;
+}
+
+
+
+template <int dim, int spacedim>
+std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase>
+MappingQ<dim, spacedim>::get_face_data(
+  const UpdateFlags               update_flags,
+  const hp::QCollection<dim - 1> &quadrature) const
+{
+  AssertDimension(quadrature.size(), 1);
+
+  std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
+    std::make_unique<InternalData>(polynomial_degree);
+  auto &data = dynamic_cast<InternalData &>(*data_ptr);
+  data.initialize_face(this->requires_update_flags(update_flags),
+                       QProjector<dim>::project_to_all_faces(
+                         ReferenceCells::get_hypercube<dim>(), quadrature[0]),
+                       quadrature[0].size());
+
+  return data_ptr;
+}
+
+
+
+template <int dim, int spacedim>
+std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase>
+MappingQ<dim, spacedim>::get_subface_data(
+  const UpdateFlags          update_flags,
+  const Quadrature<dim - 1> &quadrature) const
+{
+  std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
+    std::make_unique<InternalData>(polynomial_degree);
+  auto &data = dynamic_cast<InternalData &>(*data_ptr);
+  data.initialize_face(this->requires_update_flags(update_flags),
+                       QProjector<dim>::project_to_all_subfaces(
+                         ReferenceCells::get_hypercube<dim>(), quadrature),
+                       quadrature.size());
+
+  return data_ptr;
+}
+
+
+
+template <int dim, int spacedim>
+CellSimilarity::Similarity
+MappingQ<dim, spacedim>::fill_fe_values(
+  const typename Triangulation<dim, spacedim>::cell_iterator &cell,
+  const CellSimilarity::Similarity                            cell_similarity,
+  const Quadrature<dim> &                                     quadrature,
+  const typename Mapping<dim, spacedim>::InternalDataBase &   internal_data,
+  internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
+    &output_data) const
+{
+  // ensure that the following static_cast is really correct:
+  Assert(dynamic_cast<const InternalData *>(&internal_data) != nullptr,
+         ExcInternalError());
+  const InternalData &data = static_cast<const InternalData &>(internal_data);
+
+  const unsigned int n_q_points = quadrature.size();
+
+  // recompute the support points of the transformation of this
+  // cell. we tried to be clever here in an earlier version of the
+  // library by checking whether the cell is the same as the one we
+  // had visited last, but it turns out to be difficult to determine
+  // that because a cell for the purposes of a mapping is
+  // characterized not just by its (triangulation, level, index)
+  // triple, but also by the locations of its vertices, the manifold
+  // object attached to the cell and all of its bounding faces/edges,
+  // etc. to reliably test that the "cell" we are on is, therefore,
+  // not easily done
+  data.mapping_support_points = this->compute_mapping_support_points(cell);
+  data.cell_of_current_support_points = cell;
+
+  // if the order of the mapping is greater than 1, then do not reuse any cell
+  // similarity information. This is necessary because the cell similarity
+  // value is computed with just cell vertices and does not take into account
+  // cell curvature.
+  const CellSimilarity::Similarity computed_cell_similarity =
+    (polynomial_degree == 1 ? cell_similarity : CellSimilarity::none);
+
+  if (dim > 1 && data.tensor_product_quadrature)
+    {
+      internal::MappingQImplementation::
+        maybe_update_q_points_Jacobians_and_grads_tensor<dim, spacedim>(
+          computed_cell_similarity,
+          data,
+          output_data.quadrature_points,
+          output_data.jacobian_grads);
+    }
+  else
+    {
+      internal::MappingQImplementation::maybe_compute_q_points<dim, spacedim>(
+        QProjector<dim>::DataSetDescriptor::cell(),
+        data,
+        output_data.quadrature_points);
+
+      internal::MappingQImplementation::maybe_update_Jacobians<dim, spacedim>(
+        computed_cell_similarity,
+        QProjector<dim>::DataSetDescriptor::cell(),
+        data);
+
+      internal::MappingQImplementation::maybe_update_jacobian_grads<dim,
+                                                                    spacedim>(
+        computed_cell_similarity,
+        QProjector<dim>::DataSetDescriptor::cell(),
+        data,
+        output_data.jacobian_grads);
+    }
+
+  internal::MappingQImplementation::maybe_update_jacobian_pushed_forward_grads<
+    dim,
+    spacedim>(computed_cell_similarity,
+              QProjector<dim>::DataSetDescriptor::cell(),
+              data,
+              output_data.jacobian_pushed_forward_grads);
+
+  internal::MappingQImplementation::maybe_update_jacobian_2nd_derivatives<
+    dim,
+    spacedim>(computed_cell_similarity,
+              QProjector<dim>::DataSetDescriptor::cell(),
+              data,
+              output_data.jacobian_2nd_derivatives);
+
+  internal::MappingQImplementation::
+    maybe_update_jacobian_pushed_forward_2nd_derivatives<dim, spacedim>(
+      computed_cell_similarity,
+      QProjector<dim>::DataSetDescriptor::cell(),
+      data,
+      output_data.jacobian_pushed_forward_2nd_derivatives);
+
+  internal::MappingQImplementation::maybe_update_jacobian_3rd_derivatives<
+    dim,
+    spacedim>(computed_cell_similarity,
+              QProjector<dim>::DataSetDescriptor::cell(),
+              data,
+              output_data.jacobian_3rd_derivatives);
+
+  internal::MappingQImplementation::
+    maybe_update_jacobian_pushed_forward_3rd_derivatives<dim, spacedim>(
+      computed_cell_similarity,
+      QProjector<dim>::DataSetDescriptor::cell(),
+      data,
+      output_data.jacobian_pushed_forward_3rd_derivatives);
+
+  const UpdateFlags          update_flags = data.update_each;
+  const std::vector<double> &weights      = quadrature.get_weights();
+
+  // Multiply quadrature weights by absolute value of Jacobian determinants or
+  // the area element g=sqrt(DX^t DX) in case of codim > 0
+
+  if (update_flags & (update_normal_vectors | update_JxW_values))
+    {
+      AssertDimension(output_data.JxW_values.size(), n_q_points);
+
+      Assert(!(update_flags & update_normal_vectors) ||
+               (output_data.normal_vectors.size() == n_q_points),
+             ExcDimensionMismatch(output_data.normal_vectors.size(),
+                                  n_q_points));
+
+
+      if (computed_cell_similarity != CellSimilarity::translation)
+        for (unsigned int point = 0; point < n_q_points; ++point)
+          {
+            if (dim == spacedim)
+              {
+                const double det = data.contravariant[point].determinant();
+
+                // check for distorted cells.
+
+                // TODO: this allows for anisotropies of up to 1e6 in 3D and
+                // 1e12 in 2D. might want to find a finer
+                // (dimension-independent) criterion
+                Assert(det >
+                         1e-12 * Utilities::fixed_power<dim>(
+                                   cell->diameter() / std::sqrt(double(dim))),
+                       (typename Mapping<dim, spacedim>::ExcDistortedMappedCell(
+                         cell->center(), det, point)));
+
+                output_data.JxW_values[point] = weights[point] * det;
+              }
+            // if dim==spacedim, then there is no cell normal to
+            // compute. since this is for FEValues (and not FEFaceValues),
+            // there are also no face normals to compute
+            else // codim>0 case
+              {
+                Tensor<1, spacedim> DX_t[dim];
+                for (unsigned int i = 0; i < spacedim; ++i)
+                  for (unsigned int j = 0; j < dim; ++j)
+                    DX_t[j][i] = data.contravariant[point][i][j];
+
+                Tensor<2, dim> G; // First fundamental form
+                for (unsigned int i = 0; i < dim; ++i)
+                  for (unsigned int j = 0; j < dim; ++j)
+                    G[i][j] = DX_t[i] * DX_t[j];
+
+                output_data.JxW_values[point] =
+                  std::sqrt(determinant(G)) * weights[point];
+
+                if (computed_cell_similarity ==
+                    CellSimilarity::inverted_translation)
+                  {
+                    // we only need to flip the normal
+                    if (update_flags & update_normal_vectors)
+                      output_data.normal_vectors[point] *= -1.;
+                  }
+                else
+                  {
+                    if (update_flags & update_normal_vectors)
+                      {
+                        Assert(spacedim == dim + 1,
+                               ExcMessage(
+                                 "There is no (unique) cell normal for " +
+                                 Utilities::int_to_string(dim) +
+                                 "-dimensional cells in " +
+                                 Utilities::int_to_string(spacedim) +
+                                 "-dimensional space. This only works if the "
+                                 "space dimension is one greater than the "
+                                 "dimensionality of the mesh cells."));
+
+                        if (dim == 1)
+                          output_data.normal_vectors[point] =
+                            cross_product_2d(-DX_t[0]);
+                        else // dim == 2
+                          output_data.normal_vectors[point] =
+                            cross_product_3d(DX_t[0], DX_t[1]);
+
+                        output_data.normal_vectors[point] /=
+                          output_data.normal_vectors[point].norm();
+
+                        if (cell->direction_flag() == false)
+                          output_data.normal_vectors[point] *= -1.;
+                      }
+                  }
+              } // codim>0 case
+          }
+    }
+
+
+
+  // copy values from InternalData to vector given by reference
+  if (update_flags & update_jacobians)
+    {
+      AssertDimension(output_data.jacobians.size(), n_q_points);
+      if (computed_cell_similarity != CellSimilarity::translation)
+        for (unsigned int point = 0; point < n_q_points; ++point)
+          output_data.jacobians[point] = data.contravariant[point];
+    }
+
+  // copy values from InternalData to vector given by reference
+  if (update_flags & update_inverse_jacobians)
+    {
+      AssertDimension(output_data.inverse_jacobians.size(), n_q_points);
+      if (computed_cell_similarity != CellSimilarity::translation)
+        for (unsigned int point = 0; point < n_q_points; ++point)
+          output_data.inverse_jacobians[point] =
+            data.covariant[point].transpose();
+    }
+
+  return computed_cell_similarity;
+}
+
+
+
+template <int dim, int spacedim>
+void
+MappingQ<dim, spacedim>::fill_fe_face_values(
+  const typename Triangulation<dim, spacedim>::cell_iterator &cell,
+  const unsigned int                                          face_no,
+  const hp::QCollection<dim - 1> &                            quadrature,
+  const typename Mapping<dim, spacedim>::InternalDataBase &   internal_data,
+  internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
+    &output_data) const
+{
+  AssertDimension(quadrature.size(), 1);
+
+  // ensure that the following cast is really correct:
+  Assert((dynamic_cast<const InternalData *>(&internal_data) != nullptr),
+         ExcInternalError());
+  const InternalData &data = static_cast<const InternalData &>(internal_data);
+
+  // if necessary, recompute the support points of the transformation of this
+  // cell (note that we need to first check the triangulation pointer, since
+  // otherwise the second test might trigger an exception if the triangulations
+  // are not the same)
+  if ((data.mapping_support_points.size() == 0) ||
+      (&cell->get_triangulation() !=
+       &data.cell_of_current_support_points->get_triangulation()) ||
+      (cell != data.cell_of_current_support_points))
+    {
+      data.mapping_support_points = this->compute_mapping_support_points(cell);
+      data.cell_of_current_support_points = cell;
+    }
+
+  internal::MappingQImplementation::do_fill_fe_face_values(
+    *this,
+    cell,
+    face_no,
+    numbers::invalid_unsigned_int,
+    QProjector<dim>::DataSetDescriptor::face(
+      ReferenceCells::get_hypercube<dim>(),
+      face_no,
+      cell->face_orientation(face_no),
+      cell->face_flip(face_no),
+      cell->face_rotation(face_no),
+      quadrature[0].size()),
+    quadrature[0],
+    data,
+    output_data);
+}
+
+
+
+template <int dim, int spacedim>
+void
+MappingQ<dim, spacedim>::fill_fe_subface_values(
+  const typename Triangulation<dim, spacedim>::cell_iterator &cell,
+  const unsigned int                                          face_no,
+  const unsigned int                                          subface_no,
+  const Quadrature<dim - 1> &                                 quadrature,
+  const typename Mapping<dim, spacedim>::InternalDataBase &   internal_data,
+  internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
+    &output_data) const
+{
+  // ensure that the following cast is really correct:
+  Assert((dynamic_cast<const InternalData *>(&internal_data) != nullptr),
+         ExcInternalError());
+  const InternalData &data = static_cast<const InternalData &>(internal_data);
+
+  // if necessary, recompute the support points of the transformation of this
+  // cell (note that we need to first check the triangulation pointer, since
+  // otherwise the second test might trigger an exception if the triangulations
+  // are not the same)
+  if ((data.mapping_support_points.size() == 0) ||
+      (&cell->get_triangulation() !=
+       &data.cell_of_current_support_points->get_triangulation()) ||
+      (cell != data.cell_of_current_support_points))
+    {
+      data.mapping_support_points = this->compute_mapping_support_points(cell);
+      data.cell_of_current_support_points = cell;
+    }
+
+  internal::MappingQImplementation::do_fill_fe_face_values(
+    *this,
+    cell,
+    face_no,
+    subface_no,
+    QProjector<dim>::DataSetDescriptor::subface(
+      ReferenceCells::get_hypercube<dim>(),
+      face_no,
+      subface_no,
+      cell->face_orientation(face_no),
+      cell->face_flip(face_no),
+      cell->face_rotation(face_no),
+      quadrature.size(),
+      cell->subface_case(face_no)),
+    quadrature,
+    data,
+    output_data);
+}
+
+
+
+template <int dim, int spacedim>
+void
+MappingQ<dim, spacedim>::fill_mapping_data_for_generic_points(
+  const typename Triangulation<dim, spacedim>::cell_iterator &cell,
+  const ArrayView<const Point<dim>> &                         unit_points,
+  const UpdateFlags                                           update_flags,
+  dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
+    &output_data) const
+{
+  if (update_flags == update_default)
+    return;
+
+  Assert(update_flags & update_inverse_jacobians ||
+           update_flags & update_jacobians ||
+           update_flags & update_quadrature_points,
+         ExcNotImplemented());
+
+  output_data.initialize(unit_points.size(), update_flags);
+  const std::vector<Point<spacedim>> support_points =
+    this->compute_mapping_support_points(cell);
+
+  const unsigned int n_points = unit_points.size();
+  const unsigned int n_lanes  = VectorizedArray<double>::size();
+
+  // Use the more heavy VectorizedArray code path if there is more than
+  // one point left to compute
+  for (unsigned int i = 0; i < n_points; i += n_lanes)
+    if (n_points - i > 1)
+      {
+        Point<dim, VectorizedArray<double>> p_vec;
+        for (unsigned int j = 0; j < n_lanes; ++j)
+          if (i + j < n_points)
+            for (unsigned int d = 0; d < dim; ++d)
+              p_vec[d][j] = unit_points[i + j][d];
+          else
+            for (unsigned int d = 0; d < dim; ++d)
+              p_vec[d][j] = unit_points[i][d];
+
+        const auto result =
+          internal::evaluate_tensor_product_value_and_gradient(
+            polynomials_1d,
+            support_points,
+            p_vec,
+            polynomial_degree == 1,
+            renumber_lexicographic_to_hierarchic);
+
+        if (update_flags & update_quadrature_points)
+          for (unsigned int j = 0; j < n_lanes && i + j < n_points; ++j)
+            for (unsigned int d = 0; d < spacedim; ++d)
+              output_data.quadrature_points[i + j][d] = result.first[d][j];
+
+        if (update_flags & update_jacobians)
+          for (unsigned int j = 0; j < n_lanes && i + j < n_points; ++j)
+            for (unsigned int d = 0; d < spacedim; ++d)
+              for (unsigned int e = 0; e < dim; ++e)
+                output_data.jacobians[i + j][d][e] = result.second[e][d][j];
+
+        if (update_flags & update_inverse_jacobians)
+          {
+            DerivativeForm<1, spacedim, dim, VectorizedArray<double>> jac(
+              result.second);
+            const DerivativeForm<1, spacedim, dim, VectorizedArray<double>>
+              inv_jac = jac.covariant_form();
+            for (unsigned int j = 0; j < n_lanes && i + j < n_points; ++j)
+              for (unsigned int d = 0; d < dim; ++d)
+                for (unsigned int e = 0; e < spacedim; ++e)
+                  output_data.inverse_jacobians[i + j][d][e] = inv_jac[d][e][j];
+          }
+      }
+    else
+      {
+        const auto result =
+          internal::evaluate_tensor_product_value_and_gradient(
+            polynomials_1d,
+            support_points,
+            unit_points[i],
+            polynomial_degree == 1,
+            renumber_lexicographic_to_hierarchic);
+
+        if (update_flags & update_quadrature_points)
+          output_data.quadrature_points[i] = result.first;
+
+        if (update_flags & update_jacobians)
+          {
+            DerivativeForm<1, spacedim, dim> jac = result.second;
+            output_data.jacobians[i]             = jac.transpose();
+          }
+
+        if (update_flags & update_inverse_jacobians)
+          {
+            DerivativeForm<1, spacedim, dim> jac(result.second);
+            DerivativeForm<1, spacedim, dim> inv_jac = jac.covariant_form();
+            for (unsigned int d = 0; d < dim; ++d)
+              for (unsigned int e = 0; e < spacedim; ++e)
+                output_data.inverse_jacobians[i][d][e] = inv_jac[d][e];
+          }
+      }
+}
+
+
+
+template <int dim, int spacedim>
+void
+MappingQ<dim, spacedim>::transform(
+  const ArrayView<const Tensor<1, dim>> &                  input,
+  const MappingKind                                        mapping_kind,
+  const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
+  const ArrayView<Tensor<1, spacedim>> &                   output) const
+{
+  internal::MappingQImplementation::transform_fields(input,
+                                                     mapping_kind,
+                                                     mapping_data,
+                                                     output);
+}
+
+
+
+template <int dim, int spacedim>
+void
+MappingQ<dim, spacedim>::transform(
+  const ArrayView<const DerivativeForm<1, dim, spacedim>> &input,
+  const MappingKind                                        mapping_kind,
+  const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
+  const ArrayView<Tensor<2, spacedim>> &                   output) const
+{
+  internal::MappingQImplementation::transform_differential_forms(input,
+                                                                 mapping_kind,
+                                                                 mapping_data,
+                                                                 output);
+}
+
+
+
+template <int dim, int spacedim>
+void
+MappingQ<dim, spacedim>::transform(
+  const ArrayView<const Tensor<2, dim>> &                  input,
+  const MappingKind                                        mapping_kind,
+  const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
+  const ArrayView<Tensor<2, spacedim>> &                   output) const
+{
+  switch (mapping_kind)
+    {
+      case mapping_contravariant:
+        internal::MappingQImplementation::transform_fields(input,
+                                                           mapping_kind,
+                                                           mapping_data,
+                                                           output);
+        return;
+
+      case mapping_piola_gradient:
+      case mapping_contravariant_gradient:
+      case mapping_covariant_gradient:
+        internal::MappingQImplementation::transform_gradients(input,
+                                                              mapping_kind,
+                                                              mapping_data,
+                                                              output);
+        return;
+      default:
+        Assert(false, ExcNotImplemented());
+    }
+}
+
+
+
+template <int dim, int spacedim>
+void
+MappingQ<dim, spacedim>::transform(
+  const ArrayView<const DerivativeForm<2, dim, spacedim>> &input,
+  const MappingKind                                        mapping_kind,
+  const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
+  const ArrayView<Tensor<3, spacedim>> &                   output) const
+{
+  AssertDimension(input.size(), output.size());
+  Assert(dynamic_cast<const InternalData *>(&mapping_data) != nullptr,
+         ExcInternalError());
+  const InternalData &data = static_cast<const InternalData &>(mapping_data);
+
+  switch (mapping_kind)
+    {
+      case mapping_covariant_gradient:
+        {
+          Assert(data.update_each & update_contravariant_transformation,
+                 typename FEValuesBase<dim>::ExcAccessToUninitializedField(
+                   "update_covariant_transformation"));
+
+          for (unsigned int q = 0; q < output.size(); ++q)
+            for (unsigned int i = 0; i < spacedim; ++i)
+              for (unsigned int j = 0; j < spacedim; ++j)
+                {
+                  double tmp[dim];
+                  for (unsigned int K = 0; K < dim; ++K)
+                    {
+                      tmp[K] = data.covariant[q][j][0] * input[q][i][0][K];
+                      for (unsigned int J = 1; J < dim; ++J)
+                        tmp[K] += data.covariant[q][j][J] * input[q][i][J][K];
+                    }
+                  for (unsigned int k = 0; k < spacedim; ++k)
+                    {
+                      output[q][i][j][k] = data.covariant[q][k][0] * tmp[0];
+                      for (unsigned int K = 1; K < dim; ++K)
+                        output[q][i][j][k] += data.covariant[q][k][K] * tmp[K];
+                    }
+                }
+          return;
+        }
+
+      default:
+        Assert(false, ExcNotImplemented());
+    }
+}
+
+
+
+template <int dim, int spacedim>
+void
+MappingQ<dim, spacedim>::transform(
+  const ArrayView<const Tensor<3, dim>> &                  input,
+  const MappingKind                                        mapping_kind,
+  const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
+  const ArrayView<Tensor<3, spacedim>> &                   output) const
+{
+  switch (mapping_kind)
+    {
+      case mapping_piola_hessian:
+      case mapping_contravariant_hessian:
+      case mapping_covariant_hessian:
+        internal::MappingQImplementation::transform_hessians(input,
+                                                             mapping_kind,
+                                                             mapping_data,
+                                                             output);
+        return;
+      default:
+        Assert(false, ExcNotImplemented());
+    }
+}
+
+
+
+template <int dim, int spacedim>
+void
+MappingQ<dim, spacedim>::add_line_support_points(
+  const typename Triangulation<dim, spacedim>::cell_iterator &cell,
+  std::vector<Point<spacedim>> &                              a) const
+{
+  // if we only need the midpoint, then ask for it.
+  if (this->polynomial_degree == 2)
+    {
+      for (unsigned int line_no = 0;
+           line_no < GeometryInfo<dim>::lines_per_cell;
+           ++line_no)
+        {
+          const typename Triangulation<dim, spacedim>::line_iterator line =
+            (dim == 1 ?
+               static_cast<
+                 typename Triangulation<dim, spacedim>::line_iterator>(cell) :
+               cell->line(line_no));
+
+          const Manifold<dim, spacedim> &manifold =
+            ((line->manifold_id() == numbers::flat_manifold_id) &&
+                 (dim < spacedim) ?
+               cell->get_manifold() :
+               line->get_manifold());
+          a.push_back(manifold.get_new_point_on_line(line));
+        }
+    }
+  else
+    // otherwise call the more complicated functions and ask for inner points
+    // from the manifold description
+    {
+      std::vector<Point<spacedim>> tmp_points;
+      for (unsigned int line_no = 0;
+           line_no < GeometryInfo<dim>::lines_per_cell;
+           ++line_no)
+        {
+          const typename Triangulation<dim, spacedim>::line_iterator line =
+            (dim == 1 ?
+               static_cast<
+                 typename Triangulation<dim, spacedim>::line_iterator>(cell) :
+               cell->line(line_no));
+
+          const Manifold<dim, spacedim> &manifold =
+            ((line->manifold_id() == numbers::flat_manifold_id) &&
+                 (dim < spacedim) ?
+               cell->get_manifold() :
+               line->get_manifold());
+
+          const std::array<Point<spacedim>, 2> vertices{
+            {cell->vertex(GeometryInfo<dim>::line_to_cell_vertices(line_no, 0)),
+             cell->vertex(
+               GeometryInfo<dim>::line_to_cell_vertices(line_no, 1))}};
+
+          const std::size_t n_rows =
+            support_point_weights_perimeter_to_interior[0].size(0);
+          a.resize(a.size() + n_rows);
+          auto a_view = make_array_view(a.end() - n_rows, a.end());
+          manifold.get_new_points(
+            make_array_view(vertices.begin(), vertices.end()),
+            support_point_weights_perimeter_to_interior[0],
+            a_view);
+        }
+    }
+}
+
+
+
+template <>
+void
+MappingQ<3, 3>::add_quad_support_points(
+  const Triangulation<3, 3>::cell_iterator &cell,
+  std::vector<Point<3>> &                   a) const
+{
+  const unsigned int faces_per_cell = GeometryInfo<3>::faces_per_cell;
+
+  // used if face quad at boundary or entirely in the interior of the domain
+  std::vector<Point<3>> tmp_points;
+
+  // loop over all faces and collect points on them
+  for (unsigned int face_no = 0; face_no < faces_per_cell; ++face_no)
+    {
+      const Triangulation<3>::face_iterator face = cell->face(face_no);
+
+#ifdef DEBUG
+      const bool face_orientation          = cell->face_orientation(face_no),
+                 face_flip                 = cell->face_flip(face_no),
+                 face_rotation             = cell->face_rotation(face_no);
+      const unsigned int vertices_per_face = GeometryInfo<3>::vertices_per_face,
+                         lines_per_face    = GeometryInfo<3>::lines_per_face;
+
+      // some sanity checks up front
+      for (unsigned int i = 0; i < vertices_per_face; ++i)
+        Assert(face->vertex_index(i) ==
+                 cell->vertex_index(GeometryInfo<3>::face_to_cell_vertices(
+                   face_no, i, face_orientation, face_flip, face_rotation)),
+               ExcInternalError());
+
+      // indices of the lines that bound a face are given by GeometryInfo<3>::
+      // face_to_cell_lines
+      for (unsigned int i = 0; i < lines_per_face; ++i)
+        Assert(face->line(i) ==
+                 cell->line(GeometryInfo<3>::face_to_cell_lines(
+                   face_no, i, face_orientation, face_flip, face_rotation)),
+               ExcInternalError());
+#endif
+      // extract the points surrounding a quad from the points
+      // already computed. First get the 4 vertices and then the points on
+      // the four lines
+      boost::container::small_vector<Point<3>, 200> tmp_points(
+        GeometryInfo<2>::vertices_per_cell +
+        GeometryInfo<2>::lines_per_cell * (polynomial_degree - 1));
+      for (const unsigned int v : GeometryInfo<2>::vertex_indices())
+        tmp_points[v] = a[GeometryInfo<3>::face_to_cell_vertices(face_no, v)];
+      if (polynomial_degree > 1)
+        for (unsigned int line = 0; line < GeometryInfo<2>::lines_per_cell;
+             ++line)
+          for (unsigned int i = 0; i < polynomial_degree - 1; ++i)
+            tmp_points[4 + line * (polynomial_degree - 1) + i] =
+              a[GeometryInfo<3>::vertices_per_cell +
+                (polynomial_degree - 1) *
+                  GeometryInfo<3>::face_to_cell_lines(face_no, line) +
+                i];
+
+      const std::size_t n_rows =
+        support_point_weights_perimeter_to_interior[1].size(0);
+      a.resize(a.size() + n_rows);
+      auto a_view = make_array_view(a.end() - n_rows, a.end());
+      face->get_manifold().get_new_points(
+        make_array_view(tmp_points.begin(), tmp_points.end()),
+        support_point_weights_perimeter_to_interior[1],
+        a_view);
+    }
+}
+
+
+
+template <>
+void
+MappingQ<2, 3>::add_quad_support_points(
+  const Triangulation<2, 3>::cell_iterator &cell,
+  std::vector<Point<3>> &                   a) const
+{
+  std::array<Point<3>, GeometryInfo<2>::vertices_per_cell> vertices;
+  for (const unsigned int i : GeometryInfo<2>::vertex_indices())
+    vertices[i] = cell->vertex(i);
+
+  Table<2, double> weights(Utilities::fixed_power<2>(polynomial_degree - 1),
+                           GeometryInfo<2>::vertices_per_cell);
+  for (unsigned int q = 0, q2 = 0; q2 < polynomial_degree - 1; ++q2)
+    for (unsigned int q1 = 0; q1 < polynomial_degree - 1; ++q1, ++q)
+      {
+        Point<2> point(line_support_points[q1 + 1][0],
+                       line_support_points[q2 + 1][0]);
+        for (const unsigned int i : GeometryInfo<2>::vertex_indices())
+          weights(q, i) = GeometryInfo<2>::d_linear_shape_function(point, i);
+      }
+
+  const std::size_t n_rows = weights.size(0);
+  a.resize(a.size() + n_rows);
+  auto a_view = make_array_view(a.end() - n_rows, a.end());
+  cell->get_manifold().get_new_points(
+    make_array_view(vertices.begin(), vertices.end()), weights, a_view);
+}
+
+
+
+template <int dim, int spacedim>
+void
+MappingQ<dim, spacedim>::add_quad_support_points(
+  const typename Triangulation<dim, spacedim>::cell_iterator &,
+  std::vector<Point<spacedim>> &) const
+{
+  Assert(false, ExcInternalError());
+}
+
+
+
+template <int dim, int spacedim>
+std::vector<Point<spacedim>>
+MappingQ<dim, spacedim>::compute_mapping_support_points(
+  const typename Triangulation<dim, spacedim>::cell_iterator &cell) const
+{
+  // get the vertices first
+  std::vector<Point<spacedim>> a;
+  a.reserve(Utilities::fixed_power<dim>(polynomial_degree + 1));
+  for (const unsigned int i : GeometryInfo<dim>::vertex_indices())
+    a.push_back(cell->vertex(i));
+
+  if (this->polynomial_degree > 1)
+    {
+      // check if all entities have the same manifold id which is when we can
+      // simply ask the manifold for all points. the transfinite manifold can
+      // do the interpolation better than this class, so if we detect that we
+      // do not have to change anything here
+      Assert(dim <= 3, ExcImpossibleInDim(dim));
+      bool all_manifold_ids_are_equal = (dim == spacedim);
+      if (all_manifold_ids_are_equal &&
+          dynamic_cast<const TransfiniteInterpolationManifold<dim, spacedim> *>(
+            &cell->get_manifold()) == nullptr)
+        {
+          for (auto f : GeometryInfo<dim>::face_indices())
+            if (&cell->face(f)->get_manifold() != &cell->get_manifold())
+              all_manifold_ids_are_equal = false;
+
+          if (dim == 3)
+            for (unsigned int l = 0; l < GeometryInfo<dim>::lines_per_cell; ++l)
+              if (&cell->line(l)->get_manifold() != &cell->get_manifold())
+                all_manifold_ids_are_equal = false;
+        }
+
+      if (all_manifold_ids_are_equal)
+        {
+          const std::size_t n_rows = support_point_weights_cell.size(0);
+          a.resize(a.size() + n_rows);
+          auto a_view = make_array_view(a.end() - n_rows, a.end());
+          cell->get_manifold().get_new_points(make_array_view(a.begin(),
+                                                              a.end() - n_rows),
+                                              support_point_weights_cell,
+                                              a_view);
+        }
+      else
+        switch (dim)
+          {
+            case 1:
+              add_line_support_points(cell, a);
+              break;
+            case 2:
+              // in 2d, add the points on the four bounding lines to the
+              // exterior (outer) points
+              add_line_support_points(cell, a);
+
+              // then get the interior support points
+              if (dim != spacedim)
+                add_quad_support_points(cell, a);
+              else
+                {
+                  const std::size_t n_rows =
+                    support_point_weights_perimeter_to_interior[1].size(0);
+                  a.resize(a.size() + n_rows);
+                  auto a_view = make_array_view(a.end() - n_rows, a.end());
+                  cell->get_manifold().get_new_points(
+                    make_array_view(a.begin(), a.end() - n_rows),
+                    support_point_weights_perimeter_to_interior[1],
+                    a_view);
+                }
+              break;
+
+            case 3:
+              // in 3d also add the points located on the boundary faces
+              add_line_support_points(cell, a);
+              add_quad_support_points(cell, a);
+
+              // then compute the interior points
+              {
+                const std::size_t n_rows =
+                  support_point_weights_perimeter_to_interior[2].size(0);
+                a.resize(a.size() + n_rows);
+                auto a_view = make_array_view(a.end() - n_rows, a.end());
+                cell->get_manifold().get_new_points(
+                  make_array_view(a.begin(), a.end() - n_rows),
+                  support_point_weights_perimeter_to_interior[2],
+                  a_view);
+              }
+              break;
+
+            default:
+              Assert(false, ExcNotImplemented());
+              break;
+          }
+    }
+
+  return a;
+}
+
+
+
+template <int dim, int spacedim>
+BoundingBox<spacedim>
+MappingQ<dim, spacedim>::get_bounding_box(
+  const typename Triangulation<dim, spacedim>::cell_iterator &cell) const
+{
+  return BoundingBox<spacedim>(this->compute_mapping_support_points(cell));
+}
+
+
+
+template <int dim, int spacedim>
+bool
+MappingQ<dim, spacedim>::is_compatible_with(
+  const ReferenceCell &reference_cell) const
+{
+  Assert(dim == reference_cell.get_dimension(),
+         ExcMessage("The dimension of your mapping (" +
+                    Utilities::to_string(dim) +
+                    ") and the reference cell cell_type (" +
+                    Utilities::to_string(reference_cell.get_dimension()) +
+                    " ) do not agree."));
+
+  return reference_cell.is_hyper_cube();
+}
+
+
+
+//--------------------------- Explicit instantiations -----------------------
 #include "mapping_q.inst"
 
 
index 68ce6f44dc3cbbb25aa4d3b60e2fd3e9fe2718fe..1f8aec3bdfb5535ea43233e873ddf89c02ef411b 100644 (file)
@@ -23,7 +23,7 @@ DEAL_II_NAMESPACE_OPEN
 
 template <int dim, int spacedim>
 MappingQ1<dim, spacedim>::MappingQ1()
-  : MappingQGeneric<dim, spacedim>(1)
+  : MappingQ<dim, spacedim>(1)
 {}
 
 
@@ -39,8 +39,8 @@ MappingQ1<dim, spacedim>::clone() const
 
 
 template <int dim, int spacedim>
-MappingQGeneric<dim, spacedim>
-  StaticMappingQ1<dim, spacedim>::mapping = MappingQGeneric<dim, spacedim>(1);
+MappingQ<dim, spacedim>
+  StaticMappingQ1<dim, spacedim>::mapping = MappingQ<dim, spacedim>(1);
 
 
 
index 3d495c32b4776669e09555ffb8b6fc094cbb3c06..84c07d1c95ecadd2e786f1a2785b4f6d88c46ef5 100644 (file)
@@ -42,7 +42,7 @@ template <int dim, class VectorType, int spacedim>
 MappingQ1Eulerian<dim, VectorType, spacedim>::MappingQ1Eulerian(
   const DoFHandler<dim, spacedim> &shiftmap_dof_handler,
   const VectorType &               euler_transform_vectors)
-  : MappingQGeneric<dim, spacedim>(1)
+  : MappingQ<dim, spacedim>(1)
   , euler_transform_vectors(&euler_transform_vectors)
   , shiftmap_dof_handler(&shiftmap_dof_handler)
 {}
@@ -141,12 +141,11 @@ MappingQ1Eulerian<dim, VectorType, spacedim>::fill_fe_values(
   // call the function of the base class, but ignoring
   // any potentially detected cell similarity between
   // the current and the previous cell
-  MappingQGeneric<dim, spacedim>::fill_fe_values(
-    cell,
-    CellSimilarity::invalid_next_cell,
-    quadrature,
-    internal_data,
-    output_data);
+  MappingQ<dim, spacedim>::fill_fe_values(cell,
+                                          CellSimilarity::invalid_next_cell,
+                                          quadrature,
+                                          internal_data,
+                                          output_data);
   // also return the updated flag since any detected
   // similarity wasn't based on the mapped field, but
   // the original vertices which are meaningless
index b28872e246bc7f112ea56cdfcda1bfb20099a0ca..5c106dedcb60561c5f36f094d43a88831c89c187 100644 (file)
@@ -39,7 +39,7 @@ DEAL_II_NAMESPACE_OPEN
 template <int dim, int spacedim>
 MappingQCache<dim, spacedim>::MappingQCache(
   const unsigned int polynomial_degree)
-  : MappingQGeneric<dim, spacedim>(polynomial_degree)
+  : MappingQ<dim, spacedim>(polynomial_degree)
   , uses_level_info(false)
 {}
 
@@ -48,7 +48,7 @@ MappingQCache<dim, spacedim>::MappingQCache(
 template <int dim, int spacedim>
 MappingQCache<dim, spacedim>::MappingQCache(
   const MappingQCache<dim, spacedim> &mapping)
-  : MappingQGeneric<dim, spacedim>(mapping)
+  : MappingQ<dim, spacedim>(mapping)
   , support_point_cache(mapping.support_point_cache)
   , uses_level_info(mapping.uses_level_info)
 {}
@@ -100,12 +100,11 @@ MappingQCache<dim, spacedim>::initialize(
   this->initialize(
     triangulation,
     [&](const typename Triangulation<dim, spacedim>::cell_iterator &cell) {
-      const auto mapping_q_generic =
-        dynamic_cast<const MappingQGeneric<dim, spacedim> *>(&mapping);
-      if (mapping_q_generic != nullptr &&
-          this->get_degree() == mapping_q_generic->get_degree())
+      const auto mapping_q =
+        dynamic_cast<const MappingQ<dim, spacedim> *>(&mapping);
+      if (mapping_q != nullptr && this->get_degree() == mapping_q->get_degree())
         {
-          return mapping_q_generic->compute_mapping_support_points(cell);
+          return mapping_q->compute_mapping_support_points(cell);
         }
       else
         {
@@ -139,8 +138,8 @@ MappingQCache<dim, spacedim>::initialize(
 template <int dim, int spacedim>
 void
 MappingQCache<dim, spacedim>::initialize(
-  const Triangulation<dim, spacedim> &  triangulation,
-  const MappingQGeneric<dim, spacedim> &mapping)
+  const Triangulation<dim, spacedim> &triangulation,
+  const MappingQ<dim, spacedim> &     mapping)
 {
   this->initialize(mapping, triangulation);
 }
@@ -208,13 +207,12 @@ MappingQCache<dim, spacedim>::initialize(
     [&](const typename Triangulation<dim, spacedim>::cell_iterator &cell) {
       std::vector<Point<spacedim>> points;
 
-      const auto mapping_q_generic =
-        dynamic_cast<const MappingQGeneric<dim, spacedim> *>(&mapping);
+      const auto mapping_q =
+        dynamic_cast<const MappingQ<dim, spacedim> *>(&mapping);
 
-      if (mapping_q_generic != nullptr &&
-          this->get_degree() == mapping_q_generic->get_degree())
+      if (mapping_q != nullptr && this->get_degree() == mapping_q->get_degree())
         {
-          points = mapping_q_generic->compute_mapping_support_points(cell);
+          points = mapping_q->compute_mapping_support_points(cell);
         }
       else
         {
@@ -360,15 +358,15 @@ MappingQCache<dim, spacedim>::initialize(
         cell_tria->index(),
         &dof_handler);
 
-      const auto mapping_q_generic =
-        dynamic_cast<const MappingQGeneric<dim, spacedim> *>(&mapping);
+      const auto mapping_q =
+        dynamic_cast<const MappingQ<dim, spacedim> *>(&mapping);
 
       // Step 2a) set up and reinit FEValues (if needed)
       if (
         ((vector_describes_relative_displacement ||
           (is_active_non_artificial_cell == false)) &&
-         ((mapping_q_generic != nullptr &&
-           this->get_degree() == mapping_q_generic->get_degree()) ==
+         ((mapping_q != nullptr &&
+           this->get_degree() == mapping_q->get_degree()) ==
           false)) /*condition 1: points need to be computed via FEValues*/
         ||
         (is_active_non_artificial_cell && interpolation_of_values_is_needed) /*condition 2: interpolation of values is needed*/)
@@ -411,10 +409,9 @@ MappingQCache<dim, spacedim>::initialize(
       if (vector_describes_relative_displacement ||
           is_active_non_artificial_cell == false)
         {
-          if (mapping_q_generic != nullptr &&
-              this->get_degree() == mapping_q_generic->get_degree())
-            result =
-              mapping_q_generic->compute_mapping_support_points(cell_tria);
+          if (mapping_q != nullptr &&
+              this->get_degree() == mapping_q->get_degree())
+            result = mapping_q->compute_mapping_support_points(cell_tria);
           else
             result = fe_values_all.get()->get_quadrature_points();
 
@@ -566,15 +563,15 @@ MappingQCache<dim, spacedim>::initialize(
         cell_tria->index(),
         &dof_handler);
 
-      const auto mapping_q_generic =
-        dynamic_cast<const MappingQGeneric<dim, spacedim> *>(&mapping);
+      const auto mapping_q =
+        dynamic_cast<const MappingQ<dim, spacedim> *>(&mapping);
 
       // Step 2a) set up and reinit FEValues (if needed)
       if (
         ((vector_describes_relative_displacement ||
           (is_non_artificial_cell == false)) &&
-         ((mapping_q_generic != nullptr &&
-           this->get_degree() == mapping_q_generic->get_degree()) ==
+         ((mapping_q != nullptr &&
+           this->get_degree() == mapping_q->get_degree()) ==
           false)) /*condition 1: points need to be computed via FEValues*/
         ||
         (is_non_artificial_cell == true && interpolation_of_values_is_needed) /*condition 2: interpolation of values is needed*/)
@@ -617,10 +614,9 @@ MappingQCache<dim, spacedim>::initialize(
       if (vector_describes_relative_displacement ||
           (is_non_artificial_cell == false))
         {
-          if (mapping_q_generic != nullptr &&
-              this->get_degree() == mapping_q_generic->get_degree())
-            result =
-              mapping_q_generic->compute_mapping_support_points(cell_tria);
+          if (mapping_q != nullptr &&
+              this->get_degree() == mapping_q->get_degree())
+            result = mapping_q->compute_mapping_support_points(cell_tria);
           else
             result = fe_values_all.get()->get_quadrature_points();
 
index 91021526780a25dc7e73a7b7b477bb6ae8cdd20d..d267d0b0ad91ab9c5318cfb3acb3575fef50ca58 100644 (file)
@@ -51,7 +51,7 @@ MappingQEulerian<dim, VectorType, spacedim>::MappingQEulerian(
   const DoFHandler<dim, spacedim> &euler_dof_handler,
   const VectorType &               euler_vector,
   const unsigned int               level)
-  : MappingQGeneric<dim, spacedim>(degree)
+  : MappingQ<dim, spacedim>(degree)
   , euler_vector(&euler_vector)
   , euler_dof_handler(&euler_dof_handler)
   , level(level)
@@ -205,12 +205,11 @@ MappingQEulerian<dim, VectorType, spacedim>::fill_fe_values(
   // call the function of the base class, but ignoring
   // any potentially detected cell similarity between
   // the current and the previous cell
-  MappingQGeneric<dim, spacedim>::fill_fe_values(
-    cell,
-    CellSimilarity::invalid_next_cell,
-    quadrature,
-    internal_data,
-    output_data);
+  MappingQ<dim, spacedim>::fill_fe_values(cell,
+                                          CellSimilarity::invalid_next_cell,
+                                          quadrature,
+                                          internal_data,
+                                          output_data);
   // also return the updated flag since any detected
   // similarity wasn't based on the mapped field, but
   // the original vertices which are meaningless
diff --git a/source/fe/mapping_q_generic.cc b/source/fe/mapping_q_generic.cc
deleted file mode 100644 (file)
index 40f35af..0000000
+++ /dev/null
@@ -1,1778 +0,0 @@
-// ---------------------------------------------------------------------
-//
-// Copyright (C) 2000 - 2021 by the deal.II authors
-//
-// This file is part of the deal.II library.
-//
-// The deal.II library is free software; you can use it, redistribute
-// it, and/or modify it under the terms of the GNU Lesser General
-// Public License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-// The full text of the license can be found in the file LICENSE.md at
-// the top level directory of deal.II.
-//
-// ---------------------------------------------------------------------
-
-
-#include <deal.II/base/array_view.h>
-#include <deal.II/base/derivative_form.h>
-#include <deal.II/base/memory_consumption.h>
-#include <deal.II/base/qprojector.h>
-#include <deal.II/base/quadrature.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/table.h>
-#include <deal.II/base/tensor_product_polynomials.h>
-
-#include <deal.II/fe/fe_dgq.h>
-#include <deal.II/fe/fe_tools.h>
-#include <deal.II/fe/fe_values.h>
-#include <deal.II/fe/mapping_q1.h>
-#include <deal.II/fe/mapping_q_generic.h>
-#include <deal.II/fe/mapping_q_internal.h>
-
-#include <deal.II/grid/manifold_lib.h>
-#include <deal.II/grid/tria.h>
-#include <deal.II/grid/tria_iterator.h>
-
-DEAL_II_DISABLE_EXTRA_DIAGNOSTICS
-#include <boost/container/small_vector.hpp>
-DEAL_II_ENABLE_EXTRA_DIAGNOSTICS
-
-#include <algorithm>
-#include <array>
-#include <cmath>
-#include <memory>
-#include <numeric>
-
-
-DEAL_II_NAMESPACE_OPEN
-
-
-template <int dim, int spacedim>
-MappingQGeneric<dim, spacedim>::InternalData::InternalData(
-  const unsigned int polynomial_degree)
-  : polynomial_degree(polynomial_degree)
-  , n_shape_functions(Utilities::fixed_power<dim>(polynomial_degree + 1))
-  , line_support_points(QGaussLobatto<1>(polynomial_degree + 1))
-  , tensor_product_quadrature(false)
-{}
-
-
-
-template <int dim, int spacedim>
-std::size_t
-MappingQGeneric<dim, spacedim>::InternalData::memory_consumption() const
-{
-  return (
-    Mapping<dim, spacedim>::InternalDataBase::memory_consumption() +
-    MemoryConsumption::memory_consumption(shape_values) +
-    MemoryConsumption::memory_consumption(shape_derivatives) +
-    MemoryConsumption::memory_consumption(covariant) +
-    MemoryConsumption::memory_consumption(contravariant) +
-    MemoryConsumption::memory_consumption(unit_tangentials) +
-    MemoryConsumption::memory_consumption(aux) +
-    MemoryConsumption::memory_consumption(mapping_support_points) +
-    MemoryConsumption::memory_consumption(cell_of_current_support_points) +
-    MemoryConsumption::memory_consumption(volume_elements) +
-    MemoryConsumption::memory_consumption(polynomial_degree) +
-    MemoryConsumption::memory_consumption(n_shape_functions));
-}
-
-
-
-template <int dim, int spacedim>
-void
-MappingQGeneric<dim, spacedim>::InternalData::initialize(
-  const UpdateFlags      update_flags,
-  const Quadrature<dim> &q,
-  const unsigned int     n_original_q_points)
-{
-  // store the flags in the internal data object so we can access them
-  // in fill_fe_*_values()
-  this->update_each = update_flags;
-
-  const unsigned int n_q_points = q.size();
-
-  const bool needs_higher_order_terms =
-    this->update_each &
-    (update_jacobian_pushed_forward_grads | update_jacobian_2nd_derivatives |
-     update_jacobian_pushed_forward_2nd_derivatives |
-     update_jacobian_3rd_derivatives |
-     update_jacobian_pushed_forward_3rd_derivatives);
-
-  if (this->update_each & update_covariant_transformation)
-    covariant.resize(n_original_q_points);
-
-  if (this->update_each & update_contravariant_transformation)
-    contravariant.resize(n_original_q_points);
-
-  if (this->update_each & update_volume_elements)
-    volume_elements.resize(n_original_q_points);
-
-  tensor_product_quadrature = q.is_tensor_product();
-
-  // use of MatrixFree only for higher order elements and with more than one
-  // point where tensor products do not make sense
-  if (polynomial_degree < 2 || n_q_points == 1)
-    tensor_product_quadrature = false;
-
-  if (dim > 1)
-    {
-      // find out if the one-dimensional formula is the same
-      // in all directions
-      if (tensor_product_quadrature)
-        {
-          const std::array<Quadrature<1>, dim> quad_array =
-            q.get_tensor_basis();
-          for (unsigned int i = 1; i < dim && tensor_product_quadrature; ++i)
-            {
-              if (quad_array[i - 1].size() != quad_array[i].size())
-                {
-                  tensor_product_quadrature = false;
-                  break;
-                }
-              else
-                {
-                  const std::vector<Point<1>> &points_1 =
-                    quad_array[i - 1].get_points();
-                  const std::vector<Point<1>> &points_2 =
-                    quad_array[i].get_points();
-                  const std::vector<double> &weights_1 =
-                    quad_array[i - 1].get_weights();
-                  const std::vector<double> &weights_2 =
-                    quad_array[i].get_weights();
-                  for (unsigned int j = 0; j < quad_array[i].size(); ++j)
-                    {
-                      if (std::abs(points_1[j][0] - points_2[j][0]) > 1.e-10 ||
-                          std::abs(weights_1[j] - weights_2[j]) > 1.e-10)
-                        {
-                          tensor_product_quadrature = false;
-                          break;
-                        }
-                    }
-                }
-            }
-
-          if (tensor_product_quadrature)
-            {
-              // use a 1D FE_DGQ and adjust the hierarchic -> lexicographic
-              // numbering manually (building an FE_Q<dim> is relatively
-              // expensive due to constraints)
-              const FE_DGQ<1> fe(polynomial_degree);
-              shape_info.reinit(q.get_tensor_basis()[0], fe);
-              shape_info.lexicographic_numbering =
-                FETools::lexicographic_to_hierarchic_numbering<dim>(
-                  polynomial_degree);
-              shape_info.n_q_points = q.size();
-              shape_info.dofs_per_component_on_cell =
-                Utilities::pow(polynomial_degree + 1, dim);
-            }
-        }
-    }
-
-  // Only fill the big arrays on demand in case we cannot use the tensor
-  // product quadrature code path
-  if (dim == 1 || !tensor_product_quadrature || needs_higher_order_terms)
-    {
-      // see if we need the (transformation) shape function values
-      // and/or gradients and resize the necessary arrays
-      if (this->update_each & update_quadrature_points)
-        shape_values.resize(n_shape_functions * n_q_points);
-
-      if (this->update_each &
-          (update_covariant_transformation |
-           update_contravariant_transformation | update_JxW_values |
-           update_boundary_forms | update_normal_vectors | update_jacobians |
-           update_jacobian_grads | update_inverse_jacobians |
-           update_jacobian_pushed_forward_grads |
-           update_jacobian_2nd_derivatives |
-           update_jacobian_pushed_forward_2nd_derivatives |
-           update_jacobian_3rd_derivatives |
-           update_jacobian_pushed_forward_3rd_derivatives))
-        shape_derivatives.resize(n_shape_functions * n_q_points);
-
-      if (this->update_each &
-          (update_jacobian_grads | update_jacobian_pushed_forward_grads))
-        shape_second_derivatives.resize(n_shape_functions * n_q_points);
-
-      if (this->update_each & (update_jacobian_2nd_derivatives |
-                               update_jacobian_pushed_forward_2nd_derivatives))
-        shape_third_derivatives.resize(n_shape_functions * n_q_points);
-
-      if (this->update_each & (update_jacobian_3rd_derivatives |
-                               update_jacobian_pushed_forward_3rd_derivatives))
-        shape_fourth_derivatives.resize(n_shape_functions * n_q_points);
-
-      // now also fill the various fields with their correct values
-      compute_shape_function_values(q.get_points());
-    }
-}
-
-
-
-template <int dim, int spacedim>
-void
-MappingQGeneric<dim, spacedim>::InternalData::initialize_face(
-  const UpdateFlags      update_flags,
-  const Quadrature<dim> &q,
-  const unsigned int     n_original_q_points)
-{
-  initialize(update_flags, q, n_original_q_points);
-
-  if (dim > 1 && tensor_product_quadrature)
-    {
-      constexpr unsigned int facedim = dim - 1;
-      const FE_DGQ<1>        fe(polynomial_degree);
-      shape_info.reinit(q.get_tensor_basis()[0], fe);
-      shape_info.lexicographic_numbering =
-        FETools::lexicographic_to_hierarchic_numbering<facedim>(
-          polynomial_degree);
-      shape_info.n_q_points = n_original_q_points;
-      shape_info.dofs_per_component_on_cell =
-        Utilities::pow(polynomial_degree + 1, dim);
-    }
-
-  if (dim > 1)
-    {
-      if (this->update_each &
-          (update_boundary_forms | update_normal_vectors | update_jacobians |
-           update_JxW_values | update_inverse_jacobians))
-        {
-          aux.resize(dim - 1,
-                     AlignedVector<Tensor<1, spacedim>>(n_original_q_points));
-
-          // Compute tangentials to the unit cell.
-          for (const unsigned int i : GeometryInfo<dim>::face_indices())
-            {
-              unit_tangentials[i].resize(n_original_q_points);
-              std::fill(unit_tangentials[i].begin(),
-                        unit_tangentials[i].end(),
-                        GeometryInfo<dim>::unit_tangential_vectors[i][0]);
-              if (dim > 2)
-                {
-                  unit_tangentials[GeometryInfo<dim>::faces_per_cell + i]
-                    .resize(n_original_q_points);
-                  std::fill(
-                    unit_tangentials[GeometryInfo<dim>::faces_per_cell + i]
-                      .begin(),
-                    unit_tangentials[GeometryInfo<dim>::faces_per_cell + i]
-                      .end(),
-                    GeometryInfo<dim>::unit_tangential_vectors[i][1]);
-                }
-            }
-        }
-    }
-}
-
-
-
-template <int dim, int spacedim>
-void
-MappingQGeneric<dim, spacedim>::InternalData::compute_shape_function_values(
-  const std::vector<Point<dim>> &unit_points)
-{
-  const unsigned int n_points = unit_points.size();
-
-  // Construct the tensor product polynomials used as shape functions for
-  // the Qp mapping of cells at the boundary.
-  const TensorProductPolynomials<dim> tensor_pols(
-    Polynomials::generate_complete_Lagrange_basis(
-      line_support_points.get_points()));
-  Assert(n_shape_functions == tensor_pols.n(), ExcInternalError());
-
-  // then also construct the mapping from lexicographic to the Qp shape
-  // function numbering
-  const std::vector<unsigned int> renumber =
-    FETools::hierarchic_to_lexicographic_numbering<dim>(polynomial_degree);
-
-  std::vector<double>         values;
-  std::vector<Tensor<1, dim>> grads;
-  if (shape_values.size() != 0)
-    {
-      Assert(shape_values.size() == n_shape_functions * n_points,
-             ExcInternalError());
-      values.resize(n_shape_functions);
-    }
-  if (shape_derivatives.size() != 0)
-    {
-      Assert(shape_derivatives.size() == n_shape_functions * n_points,
-             ExcInternalError());
-      grads.resize(n_shape_functions);
-    }
-
-  std::vector<Tensor<2, dim>> grad2;
-  if (shape_second_derivatives.size() != 0)
-    {
-      Assert(shape_second_derivatives.size() == n_shape_functions * n_points,
-             ExcInternalError());
-      grad2.resize(n_shape_functions);
-    }
-
-  std::vector<Tensor<3, dim>> grad3;
-  if (shape_third_derivatives.size() != 0)
-    {
-      Assert(shape_third_derivatives.size() == n_shape_functions * n_points,
-             ExcInternalError());
-      grad3.resize(n_shape_functions);
-    }
-
-  std::vector<Tensor<4, dim>> grad4;
-  if (shape_fourth_derivatives.size() != 0)
-    {
-      Assert(shape_fourth_derivatives.size() == n_shape_functions * n_points,
-             ExcInternalError());
-      grad4.resize(n_shape_functions);
-    }
-
-
-  if (shape_values.size() != 0 || shape_derivatives.size() != 0 ||
-      shape_second_derivatives.size() != 0 ||
-      shape_third_derivatives.size() != 0 ||
-      shape_fourth_derivatives.size() != 0)
-    for (unsigned int point = 0; point < n_points; ++point)
-      {
-        tensor_pols.evaluate(
-          unit_points[point], values, grads, grad2, grad3, grad4);
-
-        if (shape_values.size() != 0)
-          for (unsigned int i = 0; i < n_shape_functions; ++i)
-            shape(point, i) = values[renumber[i]];
-
-        if (shape_derivatives.size() != 0)
-          for (unsigned int i = 0; i < n_shape_functions; ++i)
-            derivative(point, i) = grads[renumber[i]];
-
-        if (shape_second_derivatives.size() != 0)
-          for (unsigned int i = 0; i < n_shape_functions; ++i)
-            second_derivative(point, i) = grad2[renumber[i]];
-
-        if (shape_third_derivatives.size() != 0)
-          for (unsigned int i = 0; i < n_shape_functions; ++i)
-            third_derivative(point, i) = grad3[renumber[i]];
-
-        if (shape_fourth_derivatives.size() != 0)
-          for (unsigned int i = 0; i < n_shape_functions; ++i)
-            fourth_derivative(point, i) = grad4[renumber[i]];
-      }
-}
-
-
-
-template <int dim, int spacedim>
-MappingQGeneric<dim, spacedim>::MappingQGeneric(const unsigned int p)
-  : polynomial_degree(p)
-  , line_support_points(
-      QGaussLobatto<1>(this->polynomial_degree + 1).get_points())
-  , polynomials_1d(
-      Polynomials::generate_complete_Lagrange_basis(line_support_points))
-  , renumber_lexicographic_to_hierarchic(
-      FETools::lexicographic_to_hierarchic_numbering<dim>(p))
-  , unit_cell_support_points(
-      internal::MappingQGenericImplementation::unit_support_points<dim>(
-        line_support_points,
-        renumber_lexicographic_to_hierarchic))
-  , support_point_weights_perimeter_to_interior(
-      internal::MappingQGenericImplementation::
-        compute_support_point_weights_perimeter_to_interior(
-          this->polynomial_degree,
-          dim))
-  , support_point_weights_cell(
-      internal::MappingQGenericImplementation::
-        compute_support_point_weights_cell<dim>(this->polynomial_degree))
-{
-  Assert(p >= 1,
-         ExcMessage("It only makes sense to create polynomial mappings "
-                    "with a polynomial degree greater or equal to one."));
-}
-
-
-
-template <int dim, int spacedim>
-MappingQGeneric<dim, spacedim>::MappingQGeneric(
-  const MappingQGeneric<dim, spacedim> &mapping)
-  : polynomial_degree(mapping.polynomial_degree)
-  , line_support_points(mapping.line_support_points)
-  , polynomials_1d(mapping.polynomials_1d)
-  , renumber_lexicographic_to_hierarchic(
-      mapping.renumber_lexicographic_to_hierarchic)
-  , support_point_weights_perimeter_to_interior(
-      mapping.support_point_weights_perimeter_to_interior)
-  , support_point_weights_cell(mapping.support_point_weights_cell)
-{}
-
-
-
-template <int dim, int spacedim>
-std::unique_ptr<Mapping<dim, spacedim>>
-MappingQGeneric<dim, spacedim>::clone() const
-{
-  return std::make_unique<MappingQGeneric<dim, spacedim>>(*this);
-}
-
-
-
-template <int dim, int spacedim>
-unsigned int
-MappingQGeneric<dim, spacedim>::get_degree() const
-{
-  return polynomial_degree;
-}
-
-
-
-template <int dim, int spacedim>
-Point<spacedim>
-MappingQGeneric<dim, spacedim>::transform_unit_to_real_cell(
-  const typename Triangulation<dim, spacedim>::cell_iterator &cell,
-  const Point<dim> &                                          p) const
-{
-  return Point<spacedim>(internal::evaluate_tensor_product_value_and_gradient(
-                           polynomials_1d,
-                           this->compute_mapping_support_points(cell),
-                           p,
-                           polynomials_1d.size() == 2,
-                           renumber_lexicographic_to_hierarchic)
-                           .first);
-}
-
-
-// In the code below, GCC tries to instantiate MappingQGeneric<3,4> when
-// seeing which of the overloaded versions of
-// do_transform_real_to_unit_cell_internal() to call. This leads to bad
-// error messages and, generally, nothing very good. Avoid this by ensuring
-// that this class exists, but does not have an inner InternalData
-// type, thereby ruling out the codim-1 version of the function
-// below when doing overload resolution.
-template <>
-class MappingQGeneric<3, 4>
-{};
-
-
-
-// visual studio freaks out when trying to determine if
-// do_transform_real_to_unit_cell_internal with dim=3 and spacedim=4 is a good
-// candidate. So instead of letting the compiler pick the correct overload, we
-// use template specialization to make sure we pick up the right function to
-// call:
-
-template <int dim, int spacedim>
-Point<dim>
-MappingQGeneric<dim, spacedim>::transform_real_to_unit_cell_internal(
-  const typename Triangulation<dim, spacedim>::cell_iterator &,
-  const Point<spacedim> &,
-  const Point<dim> &) const
-{
-  // default implementation (should never be called)
-  Assert(false, ExcInternalError());
-  return {};
-}
-
-
-
-template <>
-Point<1>
-MappingQGeneric<1, 1>::transform_real_to_unit_cell_internal(
-  const Triangulation<1, 1>::cell_iterator &cell,
-  const Point<1> &                          p,
-  const Point<1> &                          initial_p_unit) const
-{
-  // dispatch to the various specializations for spacedim=dim,
-  // spacedim=dim+1, etc
-  return internal::MappingQGenericImplementation::
-    do_transform_real_to_unit_cell_internal<1>(
-      p,
-      initial_p_unit,
-      this->compute_mapping_support_points(cell),
-      polynomials_1d,
-      renumber_lexicographic_to_hierarchic);
-}
-
-
-
-template <>
-Point<2>
-MappingQGeneric<2, 2>::transform_real_to_unit_cell_internal(
-  const Triangulation<2, 2>::cell_iterator &cell,
-  const Point<2> &                          p,
-  const Point<2> &                          initial_p_unit) const
-{
-  return internal::MappingQGenericImplementation::
-    do_transform_real_to_unit_cell_internal<2>(
-      p,
-      initial_p_unit,
-      this->compute_mapping_support_points(cell),
-      polynomials_1d,
-      renumber_lexicographic_to_hierarchic);
-}
-
-
-
-template <>
-Point<3>
-MappingQGeneric<3, 3>::transform_real_to_unit_cell_internal(
-  const Triangulation<3, 3>::cell_iterator &cell,
-  const Point<3> &                          p,
-  const Point<3> &                          initial_p_unit) const
-{
-  return internal::MappingQGenericImplementation::
-    do_transform_real_to_unit_cell_internal<3>(
-      p,
-      initial_p_unit,
-      this->compute_mapping_support_points(cell),
-      polynomials_1d,
-      renumber_lexicographic_to_hierarchic);
-}
-
-
-
-template <>
-Point<1>
-MappingQGeneric<1, 2>::transform_real_to_unit_cell_internal(
-  const Triangulation<1, 2>::cell_iterator &cell,
-  const Point<2> &                          p,
-  const Point<1> &                          initial_p_unit) const
-{
-  const int dim      = 1;
-  const int spacedim = 2;
-
-  const Quadrature<dim> point_quadrature(initial_p_unit);
-
-  UpdateFlags update_flags = update_quadrature_points | update_jacobians;
-  if (spacedim > dim)
-    update_flags |= update_jacobian_grads;
-  auto mdata = Utilities::dynamic_unique_cast<InternalData>(
-    get_data(update_flags, point_quadrature));
-
-  mdata->mapping_support_points = this->compute_mapping_support_points(cell);
-
-  // dispatch to the various specializations for spacedim=dim,
-  // spacedim=dim+1, etc
-  return internal::MappingQGenericImplementation::
-    do_transform_real_to_unit_cell_internal_codim1<1>(cell,
-                                                      p,
-                                                      initial_p_unit,
-                                                      *mdata);
-}
-
-
-
-template <>
-Point<2>
-MappingQGeneric<2, 3>::transform_real_to_unit_cell_internal(
-  const Triangulation<2, 3>::cell_iterator &cell,
-  const Point<3> &                          p,
-  const Point<2> &                          initial_p_unit) const
-{
-  const int dim      = 2;
-  const int spacedim = 3;
-
-  const Quadrature<dim> point_quadrature(initial_p_unit);
-
-  UpdateFlags update_flags = update_quadrature_points | update_jacobians;
-  if (spacedim > dim)
-    update_flags |= update_jacobian_grads;
-  auto mdata = Utilities::dynamic_unique_cast<InternalData>(
-    get_data(update_flags, point_quadrature));
-
-  mdata->mapping_support_points = this->compute_mapping_support_points(cell);
-
-  // dispatch to the various specializations for spacedim=dim,
-  // spacedim=dim+1, etc
-  return internal::MappingQGenericImplementation::
-    do_transform_real_to_unit_cell_internal_codim1<2>(cell,
-                                                      p,
-                                                      initial_p_unit,
-                                                      *mdata);
-}
-
-template <>
-Point<1>
-MappingQGeneric<1, 3>::transform_real_to_unit_cell_internal(
-  const Triangulation<1, 3>::cell_iterator &,
-  const Point<3> &,
-  const Point<1> &) const
-{
-  Assert(false, ExcNotImplemented());
-  return {};
-}
-
-
-
-template <int dim, int spacedim>
-Point<dim>
-MappingQGeneric<dim, spacedim>::transform_real_to_unit_cell(
-  const typename Triangulation<dim, spacedim>::cell_iterator &cell,
-  const Point<spacedim> &                                     p) const
-{
-  // Use an exact formula if one is available. this is only the case
-  // for Q1 mappings in 1d, and in 2d if dim==spacedim
-  if (this->preserves_vertex_locations() && (polynomial_degree == 1) &&
-      ((dim == 1) || ((dim == 2) && (dim == spacedim))))
-    {
-      // The dimension-dependent algorithms are much faster (about 25-45x in
-      // 2D) but fail most of the time when the given point (p) is not in the
-      // cell. The dimension-independent Newton algorithm given below is
-      // slower, but more robust (though it still sometimes fails). Therefore
-      // this function implements the following strategy based on the
-      // p's dimension:
-      //
-      // * In 1D this mapping is linear, so the mapping is always invertible
-      //   (and the exact formula is known) as long as the cell has non-zero
-      //   length.
-      // * In 2D the exact (quadratic) formula is called first. If either the
-      //   exact formula does not succeed (negative discriminant in the
-      //   quadratic formula) or succeeds but finds a solution outside of the
-      //   unit cell, then the Newton solver is called. The rationale for the
-      //   second choice is that the exact formula may provide two different
-      //   answers when mapping a point outside of the real cell, but the
-      //   Newton solver (if it converges) will only return one answer.
-      //   Otherwise the exact formula successfully found a point in the unit
-      //   cell and that value is returned.
-      // * In 3D there is no (known to the authors) exact formula, so the Newton
-      //   algorithm is used.
-      const auto vertices_ = this->get_vertices(cell);
-
-      std::array<Point<spacedim>, GeometryInfo<dim>::vertices_per_cell>
-        vertices;
-      for (unsigned int i = 0; i < vertices.size(); ++i)
-        vertices[i] = vertices_[i];
-
-      try
-        {
-          switch (dim)
-            {
-              case 1:
-                {
-                  // formula not subject to any issues in 1d
-                  if (spacedim == 1)
-                    return internal::MappingQ1::transform_real_to_unit_cell(
-                      vertices, p);
-                  else
-                    break;
-                }
-
-              case 2:
-                {
-                  const Point<dim> point =
-                    internal::MappingQ1::transform_real_to_unit_cell(vertices,
-                                                                     p);
-
-                  // formula not guaranteed to work for points outside of
-                  // the cell. only take the computed point if it lies
-                  // inside the reference cell
-                  const double eps = 1e-15;
-                  if (-eps <= point(1) && point(1) <= 1 + eps &&
-                      -eps <= point(0) && point(0) <= 1 + eps)
-                    {
-                      return point;
-                    }
-                  else
-                    break;
-                }
-
-              default:
-                {
-                  // we should get here, based on the if-condition at the top
-                  Assert(false, ExcInternalError());
-                }
-            }
-        }
-      catch (
-        const typename Mapping<spacedim, spacedim>::ExcTransformationFailed &)
-        {
-          // simply fall through and continue on to the standard Newton code
-        }
-    }
-  else
-    {
-      // we can't use an explicit formula,
-    }
-
-
-  // Find the initial value for the Newton iteration by a normal
-  // projection to the least square plane determined by the vertices
-  // of the cell
-  Point<dim> initial_p_unit;
-  if (this->preserves_vertex_locations())
-    {
-      initial_p_unit = cell->real_to_unit_cell_affine_approximation(p);
-      // in 1d with spacedim > 1 the affine approximation is exact
-      if (dim == 1 && polynomial_degree == 1)
-        return initial_p_unit;
-    }
-  else
-    {
-      // else, we simply use the mid point
-      for (unsigned int d = 0; d < dim; ++d)
-        initial_p_unit[d] = 0.5;
-    }
-
-  // perform the Newton iteration and return the result. note that this
-  // statement may throw an exception, which we simply pass up to the caller
-  const Point<dim> p_unit =
-    this->transform_real_to_unit_cell_internal(cell, p, initial_p_unit);
-  if (p_unit[0] == std::numeric_limits<double>::infinity())
-    AssertThrow(false,
-                (typename Mapping<dim, spacedim>::ExcTransformationFailed()));
-  return p_unit;
-}
-
-
-
-template <int dim, int spacedim>
-void
-MappingQGeneric<dim, spacedim>::transform_points_real_to_unit_cell(
-  const typename Triangulation<dim, spacedim>::cell_iterator &cell,
-  const ArrayView<const Point<spacedim>> &                    real_points,
-  const ArrayView<Point<dim>> &                               unit_points) const
-{
-  // Go to base class functions for dim < spacedim because it is not yet
-  // implemented with optimized code.
-  if (dim < spacedim)
-    {
-      Mapping<dim, spacedim>::transform_points_real_to_unit_cell(cell,
-                                                                 real_points,
-                                                                 unit_points);
-      return;
-    }
-
-  AssertDimension(real_points.size(), unit_points.size());
-  const std::vector<Point<spacedim>> support_points =
-    this->compute_mapping_support_points(cell);
-
-  // From the given (high-order) support points, now only pick the first
-  // 2^dim points and construct an affine approximation from those.
-  internal::MappingQGenericImplementation::
-    InverseQuadraticApproximation<dim, spacedim>
-      inverse_approximation(support_points, unit_cell_support_points);
-
-  const unsigned int n_points = real_points.size();
-  const unsigned int n_lanes  = VectorizedArray<double>::size();
-
-  // Use the more heavy VectorizedArray code path if there is more than
-  // one point left to compute
-  for (unsigned int i = 0; i < n_points; i += n_lanes)
-    if (n_points - i > 1)
-      {
-        Point<spacedim, VectorizedArray<double>> p_vec;
-        for (unsigned int j = 0; j < n_lanes; ++j)
-          if (i + j < n_points)
-            for (unsigned int d = 0; d < spacedim; ++d)
-              p_vec[d][j] = real_points[i + j][d];
-          else
-            for (unsigned int d = 0; d < spacedim; ++d)
-              p_vec[d][j] = real_points[i][d];
-
-        Point<dim, VectorizedArray<double>> unit_point =
-          internal::MappingQGenericImplementation::
-            do_transform_real_to_unit_cell_internal<dim, spacedim>(
-              p_vec,
-              inverse_approximation.compute(p_vec),
-              support_points,
-              polynomials_1d,
-              renumber_lexicographic_to_hierarchic);
-
-        // If the vectorized computation failed, it could be that only some of
-        // the lanes failed but others would have succeeded if we had let them
-        // compute alone without interference (like negative Jacobian
-        // determinants) from other SIMD lanes. Repeat the computation in this
-        // unlikely case with scalar arguments.
-        for (unsigned int j = 0; j < n_lanes && i + j < n_points; ++j)
-          if (unit_point[0][j] == std::numeric_limits<double>::infinity())
-            unit_points[i + j] = internal::MappingQGenericImplementation::
-              do_transform_real_to_unit_cell_internal<dim, spacedim>(
-                real_points[i + j],
-                inverse_approximation.compute(real_points[i + j]),
-                support_points,
-                polynomials_1d,
-                renumber_lexicographic_to_hierarchic);
-          else
-            for (unsigned int d = 0; d < dim; ++d)
-              unit_points[i + j][d] = unit_point[d][j];
-      }
-    else
-      unit_points[i] = internal::MappingQGenericImplementation::
-        do_transform_real_to_unit_cell_internal<dim, spacedim>(
-          real_points[i],
-          inverse_approximation.compute(real_points[i]),
-          support_points,
-          polynomials_1d,
-          renumber_lexicographic_to_hierarchic);
-}
-
-
-
-template <int dim, int spacedim>
-UpdateFlags
-MappingQGeneric<dim, spacedim>::requires_update_flags(
-  const UpdateFlags in) const
-{
-  // add flags if the respective quantities are necessary to compute
-  // what we need. note that some flags appear in both the conditions
-  // and in subsequent set operations. this leads to some circular
-  // logic. the only way to treat this is to iterate. since there are
-  // 5 if-clauses in the loop, it will take at most 5 iterations to
-  // converge. do them:
-  UpdateFlags out = in;
-  for (unsigned int i = 0; i < 5; ++i)
-    {
-      // The following is a little incorrect:
-      // If not applied on a face,
-      // update_boundary_forms does not
-      // make sense. On the other hand,
-      // it is necessary on a
-      // face. Currently,
-      // update_boundary_forms is simply
-      // ignored for the interior of a
-      // cell.
-      if (out & (update_JxW_values | update_normal_vectors))
-        out |= update_boundary_forms;
-
-      if (out & (update_covariant_transformation | update_JxW_values |
-                 update_jacobians | update_jacobian_grads |
-                 update_boundary_forms | update_normal_vectors))
-        out |= update_contravariant_transformation;
-
-      if (out &
-          (update_inverse_jacobians | update_jacobian_pushed_forward_grads |
-           update_jacobian_pushed_forward_2nd_derivatives |
-           update_jacobian_pushed_forward_3rd_derivatives))
-        out |= update_covariant_transformation;
-
-      // The contravariant transformation is used in the Piola
-      // transformation, which requires the determinant of the Jacobi
-      // matrix of the transformation.  Because we have no way of
-      // knowing here whether the finite element wants to use the
-      // contravariant or the Piola transforms, we add the JxW values
-      // to the list of flags to be updated for each cell.
-      if (out & update_contravariant_transformation)
-        out |= update_volume_elements;
-
-      // the same is true when computing normal vectors: they require
-      // the determinant of the Jacobian
-      if (out & update_normal_vectors)
-        out |= update_volume_elements;
-    }
-
-  return out;
-}
-
-
-
-template <int dim, int spacedim>
-std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase>
-MappingQGeneric<dim, spacedim>::get_data(const UpdateFlags      update_flags,
-                                         const Quadrature<dim> &q) const
-{
-  std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
-    std::make_unique<InternalData>(polynomial_degree);
-  auto &data = dynamic_cast<InternalData &>(*data_ptr);
-  data.initialize(this->requires_update_flags(update_flags), q, q.size());
-
-  return data_ptr;
-}
-
-
-
-template <int dim, int spacedim>
-std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase>
-MappingQGeneric<dim, spacedim>::get_face_data(
-  const UpdateFlags               update_flags,
-  const hp::QCollection<dim - 1> &quadrature) const
-{
-  AssertDimension(quadrature.size(), 1);
-
-  std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
-    std::make_unique<InternalData>(polynomial_degree);
-  auto &data = dynamic_cast<InternalData &>(*data_ptr);
-  data.initialize_face(this->requires_update_flags(update_flags),
-                       QProjector<dim>::project_to_all_faces(
-                         ReferenceCells::get_hypercube<dim>(), quadrature[0]),
-                       quadrature[0].size());
-
-  return data_ptr;
-}
-
-
-
-template <int dim, int spacedim>
-std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase>
-MappingQGeneric<dim, spacedim>::get_subface_data(
-  const UpdateFlags          update_flags,
-  const Quadrature<dim - 1> &quadrature) const
-{
-  std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
-    std::make_unique<InternalData>(polynomial_degree);
-  auto &data = dynamic_cast<InternalData &>(*data_ptr);
-  data.initialize_face(this->requires_update_flags(update_flags),
-                       QProjector<dim>::project_to_all_subfaces(
-                         ReferenceCells::get_hypercube<dim>(), quadrature),
-                       quadrature.size());
-
-  return data_ptr;
-}
-
-
-
-template <int dim, int spacedim>
-CellSimilarity::Similarity
-MappingQGeneric<dim, spacedim>::fill_fe_values(
-  const typename Triangulation<dim, spacedim>::cell_iterator &cell,
-  const CellSimilarity::Similarity                            cell_similarity,
-  const Quadrature<dim> &                                     quadrature,
-  const typename Mapping<dim, spacedim>::InternalDataBase &   internal_data,
-  internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
-    &output_data) const
-{
-  // ensure that the following static_cast is really correct:
-  Assert(dynamic_cast<const InternalData *>(&internal_data) != nullptr,
-         ExcInternalError());
-  const InternalData &data = static_cast<const InternalData &>(internal_data);
-
-  const unsigned int n_q_points = quadrature.size();
-
-  // recompute the support points of the transformation of this
-  // cell. we tried to be clever here in an earlier version of the
-  // library by checking whether the cell is the same as the one we
-  // had visited last, but it turns out to be difficult to determine
-  // that because a cell for the purposes of a mapping is
-  // characterized not just by its (triangulation, level, index)
-  // triple, but also by the locations of its vertices, the manifold
-  // object attached to the cell and all of its bounding faces/edges,
-  // etc. to reliably test that the "cell" we are on is, therefore,
-  // not easily done
-  data.mapping_support_points = this->compute_mapping_support_points(cell);
-  data.cell_of_current_support_points = cell;
-
-  // if the order of the mapping is greater than 1, then do not reuse any cell
-  // similarity information. This is necessary because the cell similarity
-  // value is computed with just cell vertices and does not take into account
-  // cell curvature.
-  const CellSimilarity::Similarity computed_cell_similarity =
-    (polynomial_degree == 1 ? cell_similarity : CellSimilarity::none);
-
-  if (dim > 1 && data.tensor_product_quadrature)
-    {
-      internal::MappingQGenericImplementation::
-        maybe_update_q_points_Jacobians_and_grads_tensor<dim, spacedim>(
-          computed_cell_similarity,
-          data,
-          output_data.quadrature_points,
-          output_data.jacobian_grads);
-    }
-  else
-    {
-      internal::MappingQGenericImplementation::maybe_compute_q_points<dim,
-                                                                      spacedim>(
-        QProjector<dim>::DataSetDescriptor::cell(),
-        data,
-        output_data.quadrature_points);
-
-      internal::MappingQGenericImplementation::maybe_update_Jacobians<dim,
-                                                                      spacedim>(
-        computed_cell_similarity,
-        QProjector<dim>::DataSetDescriptor::cell(),
-        data);
-
-      internal::MappingQGenericImplementation::maybe_update_jacobian_grads<
-        dim,
-        spacedim>(computed_cell_similarity,
-                  QProjector<dim>::DataSetDescriptor::cell(),
-                  data,
-                  output_data.jacobian_grads);
-    }
-
-  internal::MappingQGenericImplementation::
-    maybe_update_jacobian_pushed_forward_grads<dim, spacedim>(
-      computed_cell_similarity,
-      QProjector<dim>::DataSetDescriptor::cell(),
-      data,
-      output_data.jacobian_pushed_forward_grads);
-
-  internal::MappingQGenericImplementation::
-    maybe_update_jacobian_2nd_derivatives<dim, spacedim>(
-      computed_cell_similarity,
-      QProjector<dim>::DataSetDescriptor::cell(),
-      data,
-      output_data.jacobian_2nd_derivatives);
-
-  internal::MappingQGenericImplementation::
-    maybe_update_jacobian_pushed_forward_2nd_derivatives<dim, spacedim>(
-      computed_cell_similarity,
-      QProjector<dim>::DataSetDescriptor::cell(),
-      data,
-      output_data.jacobian_pushed_forward_2nd_derivatives);
-
-  internal::MappingQGenericImplementation::
-    maybe_update_jacobian_3rd_derivatives<dim, spacedim>(
-      computed_cell_similarity,
-      QProjector<dim>::DataSetDescriptor::cell(),
-      data,
-      output_data.jacobian_3rd_derivatives);
-
-  internal::MappingQGenericImplementation::
-    maybe_update_jacobian_pushed_forward_3rd_derivatives<dim, spacedim>(
-      computed_cell_similarity,
-      QProjector<dim>::DataSetDescriptor::cell(),
-      data,
-      output_data.jacobian_pushed_forward_3rd_derivatives);
-
-  const UpdateFlags          update_flags = data.update_each;
-  const std::vector<double> &weights      = quadrature.get_weights();
-
-  // Multiply quadrature weights by absolute value of Jacobian determinants or
-  // the area element g=sqrt(DX^t DX) in case of codim > 0
-
-  if (update_flags & (update_normal_vectors | update_JxW_values))
-    {
-      AssertDimension(output_data.JxW_values.size(), n_q_points);
-
-      Assert(!(update_flags & update_normal_vectors) ||
-               (output_data.normal_vectors.size() == n_q_points),
-             ExcDimensionMismatch(output_data.normal_vectors.size(),
-                                  n_q_points));
-
-
-      if (computed_cell_similarity != CellSimilarity::translation)
-        for (unsigned int point = 0; point < n_q_points; ++point)
-          {
-            if (dim == spacedim)
-              {
-                const double det = data.contravariant[point].determinant();
-
-                // check for distorted cells.
-
-                // TODO: this allows for anisotropies of up to 1e6 in 3D and
-                // 1e12 in 2D. might want to find a finer
-                // (dimension-independent) criterion
-                Assert(det >
-                         1e-12 * Utilities::fixed_power<dim>(
-                                   cell->diameter() / std::sqrt(double(dim))),
-                       (typename Mapping<dim, spacedim>::ExcDistortedMappedCell(
-                         cell->center(), det, point)));
-
-                output_data.JxW_values[point] = weights[point] * det;
-              }
-            // if dim==spacedim, then there is no cell normal to
-            // compute. since this is for FEValues (and not FEFaceValues),
-            // there are also no face normals to compute
-            else // codim>0 case
-              {
-                Tensor<1, spacedim> DX_t[dim];
-                for (unsigned int i = 0; i < spacedim; ++i)
-                  for (unsigned int j = 0; j < dim; ++j)
-                    DX_t[j][i] = data.contravariant[point][i][j];
-
-                Tensor<2, dim> G; // First fundamental form
-                for (unsigned int i = 0; i < dim; ++i)
-                  for (unsigned int j = 0; j < dim; ++j)
-                    G[i][j] = DX_t[i] * DX_t[j];
-
-                output_data.JxW_values[point] =
-                  std::sqrt(determinant(G)) * weights[point];
-
-                if (computed_cell_similarity ==
-                    CellSimilarity::inverted_translation)
-                  {
-                    // we only need to flip the normal
-                    if (update_flags & update_normal_vectors)
-                      output_data.normal_vectors[point] *= -1.;
-                  }
-                else
-                  {
-                    if (update_flags & update_normal_vectors)
-                      {
-                        Assert(spacedim == dim + 1,
-                               ExcMessage(
-                                 "There is no (unique) cell normal for " +
-                                 Utilities::int_to_string(dim) +
-                                 "-dimensional cells in " +
-                                 Utilities::int_to_string(spacedim) +
-                                 "-dimensional space. This only works if the "
-                                 "space dimension is one greater than the "
-                                 "dimensionality of the mesh cells."));
-
-                        if (dim == 1)
-                          output_data.normal_vectors[point] =
-                            cross_product_2d(-DX_t[0]);
-                        else // dim == 2
-                          output_data.normal_vectors[point] =
-                            cross_product_3d(DX_t[0], DX_t[1]);
-
-                        output_data.normal_vectors[point] /=
-                          output_data.normal_vectors[point].norm();
-
-                        if (cell->direction_flag() == false)
-                          output_data.normal_vectors[point] *= -1.;
-                      }
-                  }
-              } // codim>0 case
-          }
-    }
-
-
-
-  // copy values from InternalData to vector given by reference
-  if (update_flags & update_jacobians)
-    {
-      AssertDimension(output_data.jacobians.size(), n_q_points);
-      if (computed_cell_similarity != CellSimilarity::translation)
-        for (unsigned int point = 0; point < n_q_points; ++point)
-          output_data.jacobians[point] = data.contravariant[point];
-    }
-
-  // copy values from InternalData to vector given by reference
-  if (update_flags & update_inverse_jacobians)
-    {
-      AssertDimension(output_data.inverse_jacobians.size(), n_q_points);
-      if (computed_cell_similarity != CellSimilarity::translation)
-        for (unsigned int point = 0; point < n_q_points; ++point)
-          output_data.inverse_jacobians[point] =
-            data.covariant[point].transpose();
-    }
-
-  return computed_cell_similarity;
-}
-
-
-
-template <int dim, int spacedim>
-void
-MappingQGeneric<dim, spacedim>::fill_fe_face_values(
-  const typename Triangulation<dim, spacedim>::cell_iterator &cell,
-  const unsigned int                                          face_no,
-  const hp::QCollection<dim - 1> &                            quadrature,
-  const typename Mapping<dim, spacedim>::InternalDataBase &   internal_data,
-  internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
-    &output_data) const
-{
-  AssertDimension(quadrature.size(), 1);
-
-  // ensure that the following cast is really correct:
-  Assert((dynamic_cast<const InternalData *>(&internal_data) != nullptr),
-         ExcInternalError());
-  const InternalData &data = static_cast<const InternalData &>(internal_data);
-
-  // if necessary, recompute the support points of the transformation of this
-  // cell (note that we need to first check the triangulation pointer, since
-  // otherwise the second test might trigger an exception if the triangulations
-  // are not the same)
-  if ((data.mapping_support_points.size() == 0) ||
-      (&cell->get_triangulation() !=
-       &data.cell_of_current_support_points->get_triangulation()) ||
-      (cell != data.cell_of_current_support_points))
-    {
-      data.mapping_support_points = this->compute_mapping_support_points(cell);
-      data.cell_of_current_support_points = cell;
-    }
-
-  internal::MappingQGenericImplementation::do_fill_fe_face_values(
-    *this,
-    cell,
-    face_no,
-    numbers::invalid_unsigned_int,
-    QProjector<dim>::DataSetDescriptor::face(
-      ReferenceCells::get_hypercube<dim>(),
-      face_no,
-      cell->face_orientation(face_no),
-      cell->face_flip(face_no),
-      cell->face_rotation(face_no),
-      quadrature[0].size()),
-    quadrature[0],
-    data,
-    output_data);
-}
-
-
-
-template <int dim, int spacedim>
-void
-MappingQGeneric<dim, spacedim>::fill_fe_subface_values(
-  const typename Triangulation<dim, spacedim>::cell_iterator &cell,
-  const unsigned int                                          face_no,
-  const unsigned int                                          subface_no,
-  const Quadrature<dim - 1> &                                 quadrature,
-  const typename Mapping<dim, spacedim>::InternalDataBase &   internal_data,
-  internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
-    &output_data) const
-{
-  // ensure that the following cast is really correct:
-  Assert((dynamic_cast<const InternalData *>(&internal_data) != nullptr),
-         ExcInternalError());
-  const InternalData &data = static_cast<const InternalData &>(internal_data);
-
-  // if necessary, recompute the support points of the transformation of this
-  // cell (note that we need to first check the triangulation pointer, since
-  // otherwise the second test might trigger an exception if the triangulations
-  // are not the same)
-  if ((data.mapping_support_points.size() == 0) ||
-      (&cell->get_triangulation() !=
-       &data.cell_of_current_support_points->get_triangulation()) ||
-      (cell != data.cell_of_current_support_points))
-    {
-      data.mapping_support_points = this->compute_mapping_support_points(cell);
-      data.cell_of_current_support_points = cell;
-    }
-
-  internal::MappingQGenericImplementation::do_fill_fe_face_values(
-    *this,
-    cell,
-    face_no,
-    subface_no,
-    QProjector<dim>::DataSetDescriptor::subface(
-      ReferenceCells::get_hypercube<dim>(),
-      face_no,
-      subface_no,
-      cell->face_orientation(face_no),
-      cell->face_flip(face_no),
-      cell->face_rotation(face_no),
-      quadrature.size(),
-      cell->subface_case(face_no)),
-    quadrature,
-    data,
-    output_data);
-}
-
-
-
-template <int dim, int spacedim>
-inline void
-MappingQGeneric<dim, spacedim>::fill_mapping_data_for_generic_points(
-  const typename Triangulation<dim, spacedim>::cell_iterator &cell,
-  const ArrayView<const Point<dim>> &                         unit_points,
-  const UpdateFlags                                           update_flags,
-  dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim>
-    &output_data) const
-{
-  if (update_flags == update_default)
-    return;
-
-  Assert(update_flags & update_inverse_jacobians ||
-           update_flags & update_jacobians ||
-           update_flags & update_quadrature_points,
-         ExcNotImplemented());
-
-  output_data.initialize(unit_points.size(), update_flags);
-  const std::vector<Point<spacedim>> support_points =
-    this->compute_mapping_support_points(cell);
-
-  const unsigned int n_points = unit_points.size();
-  const unsigned int n_lanes  = VectorizedArray<double>::size();
-
-  // Use the more heavy VectorizedArray code path if there is more than
-  // one point left to compute
-  for (unsigned int i = 0; i < n_points; i += n_lanes)
-    if (n_points - i > 1)
-      {
-        Point<dim, VectorizedArray<double>> p_vec;
-        for (unsigned int j = 0; j < n_lanes; ++j)
-          if (i + j < n_points)
-            for (unsigned int d = 0; d < dim; ++d)
-              p_vec[d][j] = unit_points[i + j][d];
-          else
-            for (unsigned int d = 0; d < dim; ++d)
-              p_vec[d][j] = unit_points[i][d];
-
-        const auto result =
-          internal::evaluate_tensor_product_value_and_gradient(
-            polynomials_1d,
-            support_points,
-            p_vec,
-            polynomial_degree == 1,
-            renumber_lexicographic_to_hierarchic);
-
-        if (update_flags & update_quadrature_points)
-          for (unsigned int j = 0; j < n_lanes && i + j < n_points; ++j)
-            for (unsigned int d = 0; d < spacedim; ++d)
-              output_data.quadrature_points[i + j][d] = result.first[d][j];
-
-        if (update_flags & update_jacobians)
-          for (unsigned int j = 0; j < n_lanes && i + j < n_points; ++j)
-            for (unsigned int d = 0; d < spacedim; ++d)
-              for (unsigned int e = 0; e < dim; ++e)
-                output_data.jacobians[i + j][d][e] = result.second[e][d][j];
-
-        if (update_flags & update_inverse_jacobians)
-          {
-            DerivativeForm<1, spacedim, dim, VectorizedArray<double>> jac(
-              result.second);
-            const DerivativeForm<1, spacedim, dim, VectorizedArray<double>>
-              inv_jac = jac.covariant_form();
-            for (unsigned int j = 0; j < n_lanes && i + j < n_points; ++j)
-              for (unsigned int d = 0; d < dim; ++d)
-                for (unsigned int e = 0; e < spacedim; ++e)
-                  output_data.inverse_jacobians[i + j][d][e] = inv_jac[d][e][j];
-          }
-      }
-    else
-      {
-        const auto result =
-          internal::evaluate_tensor_product_value_and_gradient(
-            polynomials_1d,
-            support_points,
-            unit_points[i],
-            polynomial_degree == 1,
-            renumber_lexicographic_to_hierarchic);
-
-        if (update_flags & update_quadrature_points)
-          output_data.quadrature_points[i] = result.first;
-
-        if (update_flags & update_jacobians)
-          {
-            DerivativeForm<1, spacedim, dim> jac = result.second;
-            output_data.jacobians[i]             = jac.transpose();
-          }
-
-        if (update_flags & update_inverse_jacobians)
-          {
-            DerivativeForm<1, spacedim, dim> jac(result.second);
-            DerivativeForm<1, spacedim, dim> inv_jac = jac.covariant_form();
-            for (unsigned int d = 0; d < dim; ++d)
-              for (unsigned int e = 0; e < spacedim; ++e)
-                output_data.inverse_jacobians[i][d][e] = inv_jac[d][e];
-          }
-      }
-}
-
-
-
-template <int dim, int spacedim>
-void
-MappingQGeneric<dim, spacedim>::transform(
-  const ArrayView<const Tensor<1, dim>> &                  input,
-  const MappingKind                                        mapping_kind,
-  const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
-  const ArrayView<Tensor<1, spacedim>> &                   output) const
-{
-  internal::MappingQGenericImplementation::transform_fields(input,
-                                                            mapping_kind,
-                                                            mapping_data,
-                                                            output);
-}
-
-
-
-template <int dim, int spacedim>
-void
-MappingQGeneric<dim, spacedim>::transform(
-  const ArrayView<const DerivativeForm<1, dim, spacedim>> &input,
-  const MappingKind                                        mapping_kind,
-  const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
-  const ArrayView<Tensor<2, spacedim>> &                   output) const
-{
-  internal::MappingQGenericImplementation::transform_differential_forms(
-    input, mapping_kind, mapping_data, output);
-}
-
-
-
-template <int dim, int spacedim>
-void
-MappingQGeneric<dim, spacedim>::transform(
-  const ArrayView<const Tensor<2, dim>> &                  input,
-  const MappingKind                                        mapping_kind,
-  const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
-  const ArrayView<Tensor<2, spacedim>> &                   output) const
-{
-  switch (mapping_kind)
-    {
-      case mapping_contravariant:
-        internal::MappingQGenericImplementation::transform_fields(input,
-                                                                  mapping_kind,
-                                                                  mapping_data,
-                                                                  output);
-        return;
-
-      case mapping_piola_gradient:
-      case mapping_contravariant_gradient:
-      case mapping_covariant_gradient:
-        internal::MappingQGenericImplementation::transform_gradients(
-          input, mapping_kind, mapping_data, output);
-        return;
-      default:
-        Assert(false, ExcNotImplemented());
-    }
-}
-
-
-
-template <int dim, int spacedim>
-void
-MappingQGeneric<dim, spacedim>::transform(
-  const ArrayView<const DerivativeForm<2, dim, spacedim>> &input,
-  const MappingKind                                        mapping_kind,
-  const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
-  const ArrayView<Tensor<3, spacedim>> &                   output) const
-{
-  AssertDimension(input.size(), output.size());
-  Assert(dynamic_cast<const InternalData *>(&mapping_data) != nullptr,
-         ExcInternalError());
-  const InternalData &data = static_cast<const InternalData &>(mapping_data);
-
-  switch (mapping_kind)
-    {
-      case mapping_covariant_gradient:
-        {
-          Assert(data.update_each & update_contravariant_transformation,
-                 typename FEValuesBase<dim>::ExcAccessToUninitializedField(
-                   "update_covariant_transformation"));
-
-          for (unsigned int q = 0; q < output.size(); ++q)
-            for (unsigned int i = 0; i < spacedim; ++i)
-              for (unsigned int j = 0; j < spacedim; ++j)
-                {
-                  double tmp[dim];
-                  for (unsigned int K = 0; K < dim; ++K)
-                    {
-                      tmp[K] = data.covariant[q][j][0] * input[q][i][0][K];
-                      for (unsigned int J = 1; J < dim; ++J)
-                        tmp[K] += data.covariant[q][j][J] * input[q][i][J][K];
-                    }
-                  for (unsigned int k = 0; k < spacedim; ++k)
-                    {
-                      output[q][i][j][k] = data.covariant[q][k][0] * tmp[0];
-                      for (unsigned int K = 1; K < dim; ++K)
-                        output[q][i][j][k] += data.covariant[q][k][K] * tmp[K];
-                    }
-                }
-          return;
-        }
-
-      default:
-        Assert(false, ExcNotImplemented());
-    }
-}
-
-
-
-template <int dim, int spacedim>
-void
-MappingQGeneric<dim, spacedim>::transform(
-  const ArrayView<const Tensor<3, dim>> &                  input,
-  const MappingKind                                        mapping_kind,
-  const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
-  const ArrayView<Tensor<3, spacedim>> &                   output) const
-{
-  switch (mapping_kind)
-    {
-      case mapping_piola_hessian:
-      case mapping_contravariant_hessian:
-      case mapping_covariant_hessian:
-        internal::MappingQGenericImplementation::transform_hessians(
-          input, mapping_kind, mapping_data, output);
-        return;
-      default:
-        Assert(false, ExcNotImplemented());
-    }
-}
-
-
-
-template <int dim, int spacedim>
-void
-MappingQGeneric<dim, spacedim>::add_line_support_points(
-  const typename Triangulation<dim, spacedim>::cell_iterator &cell,
-  std::vector<Point<spacedim>> &                              a) const
-{
-  // if we only need the midpoint, then ask for it.
-  if (this->polynomial_degree == 2)
-    {
-      for (unsigned int line_no = 0;
-           line_no < GeometryInfo<dim>::lines_per_cell;
-           ++line_no)
-        {
-          const typename Triangulation<dim, spacedim>::line_iterator line =
-            (dim == 1 ?
-               static_cast<
-                 typename Triangulation<dim, spacedim>::line_iterator>(cell) :
-               cell->line(line_no));
-
-          const Manifold<dim, spacedim> &manifold =
-            ((line->manifold_id() == numbers::flat_manifold_id) &&
-                 (dim < spacedim) ?
-               cell->get_manifold() :
-               line->get_manifold());
-          a.push_back(manifold.get_new_point_on_line(line));
-        }
-    }
-  else
-    // otherwise call the more complicated functions and ask for inner points
-    // from the manifold description
-    {
-      std::vector<Point<spacedim>> tmp_points;
-      for (unsigned int line_no = 0;
-           line_no < GeometryInfo<dim>::lines_per_cell;
-           ++line_no)
-        {
-          const typename Triangulation<dim, spacedim>::line_iterator line =
-            (dim == 1 ?
-               static_cast<
-                 typename Triangulation<dim, spacedim>::line_iterator>(cell) :
-               cell->line(line_no));
-
-          const Manifold<dim, spacedim> &manifold =
-            ((line->manifold_id() == numbers::flat_manifold_id) &&
-                 (dim < spacedim) ?
-               cell->get_manifold() :
-               line->get_manifold());
-
-          const std::array<Point<spacedim>, 2> vertices{
-            {cell->vertex(GeometryInfo<dim>::line_to_cell_vertices(line_no, 0)),
-             cell->vertex(
-               GeometryInfo<dim>::line_to_cell_vertices(line_no, 1))}};
-
-          const std::size_t n_rows =
-            support_point_weights_perimeter_to_interior[0].size(0);
-          a.resize(a.size() + n_rows);
-          auto a_view = make_array_view(a.end() - n_rows, a.end());
-          manifold.get_new_points(
-            make_array_view(vertices.begin(), vertices.end()),
-            support_point_weights_perimeter_to_interior[0],
-            a_view);
-        }
-    }
-}
-
-
-
-template <>
-void
-MappingQGeneric<3, 3>::add_quad_support_points(
-  const Triangulation<3, 3>::cell_iterator &cell,
-  std::vector<Point<3>> &                   a) const
-{
-  const unsigned int faces_per_cell = GeometryInfo<3>::faces_per_cell;
-
-  // used if face quad at boundary or entirely in the interior of the domain
-  std::vector<Point<3>> tmp_points;
-
-  // loop over all faces and collect points on them
-  for (unsigned int face_no = 0; face_no < faces_per_cell; ++face_no)
-    {
-      const Triangulation<3>::face_iterator face = cell->face(face_no);
-
-#ifdef DEBUG
-      const bool face_orientation          = cell->face_orientation(face_no),
-                 face_flip                 = cell->face_flip(face_no),
-                 face_rotation             = cell->face_rotation(face_no);
-      const unsigned int vertices_per_face = GeometryInfo<3>::vertices_per_face,
-                         lines_per_face    = GeometryInfo<3>::lines_per_face;
-
-      // some sanity checks up front
-      for (unsigned int i = 0; i < vertices_per_face; ++i)
-        Assert(face->vertex_index(i) ==
-                 cell->vertex_index(GeometryInfo<3>::face_to_cell_vertices(
-                   face_no, i, face_orientation, face_flip, face_rotation)),
-               ExcInternalError());
-
-      // indices of the lines that bound a face are given by GeometryInfo<3>::
-      // face_to_cell_lines
-      for (unsigned int i = 0; i < lines_per_face; ++i)
-        Assert(face->line(i) ==
-                 cell->line(GeometryInfo<3>::face_to_cell_lines(
-                   face_no, i, face_orientation, face_flip, face_rotation)),
-               ExcInternalError());
-#endif
-      // extract the points surrounding a quad from the points
-      // already computed. First get the 4 vertices and then the points on
-      // the four lines
-      boost::container::small_vector<Point<3>, 200> tmp_points(
-        GeometryInfo<2>::vertices_per_cell +
-        GeometryInfo<2>::lines_per_cell * (polynomial_degree - 1));
-      for (const unsigned int v : GeometryInfo<2>::vertex_indices())
-        tmp_points[v] = a[GeometryInfo<3>::face_to_cell_vertices(face_no, v)];
-      if (polynomial_degree > 1)
-        for (unsigned int line = 0; line < GeometryInfo<2>::lines_per_cell;
-             ++line)
-          for (unsigned int i = 0; i < polynomial_degree - 1; ++i)
-            tmp_points[4 + line * (polynomial_degree - 1) + i] =
-              a[GeometryInfo<3>::vertices_per_cell +
-                (polynomial_degree - 1) *
-                  GeometryInfo<3>::face_to_cell_lines(face_no, line) +
-                i];
-
-      const std::size_t n_rows =
-        support_point_weights_perimeter_to_interior[1].size(0);
-      a.resize(a.size() + n_rows);
-      auto a_view = make_array_view(a.end() - n_rows, a.end());
-      face->get_manifold().get_new_points(
-        make_array_view(tmp_points.begin(), tmp_points.end()),
-        support_point_weights_perimeter_to_interior[1],
-        a_view);
-    }
-}
-
-
-
-template <>
-void
-MappingQGeneric<2, 3>::add_quad_support_points(
-  const Triangulation<2, 3>::cell_iterator &cell,
-  std::vector<Point<3>> &                   a) const
-{
-  std::array<Point<3>, GeometryInfo<2>::vertices_per_cell> vertices;
-  for (const unsigned int i : GeometryInfo<2>::vertex_indices())
-    vertices[i] = cell->vertex(i);
-
-  Table<2, double> weights(Utilities::fixed_power<2>(polynomial_degree - 1),
-                           GeometryInfo<2>::vertices_per_cell);
-  for (unsigned int q = 0, q2 = 0; q2 < polynomial_degree - 1; ++q2)
-    for (unsigned int q1 = 0; q1 < polynomial_degree - 1; ++q1, ++q)
-      {
-        Point<2> point(line_support_points[q1 + 1][0],
-                       line_support_points[q2 + 1][0]);
-        for (const unsigned int i : GeometryInfo<2>::vertex_indices())
-          weights(q, i) = GeometryInfo<2>::d_linear_shape_function(point, i);
-      }
-
-  const std::size_t n_rows = weights.size(0);
-  a.resize(a.size() + n_rows);
-  auto a_view = make_array_view(a.end() - n_rows, a.end());
-  cell->get_manifold().get_new_points(
-    make_array_view(vertices.begin(), vertices.end()), weights, a_view);
-}
-
-
-
-template <int dim, int spacedim>
-void
-MappingQGeneric<dim, spacedim>::add_quad_support_points(
-  const typename Triangulation<dim, spacedim>::cell_iterator &,
-  std::vector<Point<spacedim>> &) const
-{
-  Assert(false, ExcInternalError());
-}
-
-
-
-template <int dim, int spacedim>
-std::vector<Point<spacedim>>
-MappingQGeneric<dim, spacedim>::compute_mapping_support_points(
-  const typename Triangulation<dim, spacedim>::cell_iterator &cell) const
-{
-  // get the vertices first
-  std::vector<Point<spacedim>> a;
-  a.reserve(Utilities::fixed_power<dim>(polynomial_degree + 1));
-  for (const unsigned int i : GeometryInfo<dim>::vertex_indices())
-    a.push_back(cell->vertex(i));
-
-  if (this->polynomial_degree > 1)
-    {
-      // check if all entities have the same manifold id which is when we can
-      // simply ask the manifold for all points. the transfinite manifold can
-      // do the interpolation better than this class, so if we detect that we
-      // do not have to change anything here
-      Assert(dim <= 3, ExcImpossibleInDim(dim));
-      bool all_manifold_ids_are_equal = (dim == spacedim);
-      if (all_manifold_ids_are_equal &&
-          dynamic_cast<const TransfiniteInterpolationManifold<dim, spacedim> *>(
-            &cell->get_manifold()) == nullptr)
-        {
-          for (auto f : GeometryInfo<dim>::face_indices())
-            if (&cell->face(f)->get_manifold() != &cell->get_manifold())
-              all_manifold_ids_are_equal = false;
-
-          if (dim == 3)
-            for (unsigned int l = 0; l < GeometryInfo<dim>::lines_per_cell; ++l)
-              if (&cell->line(l)->get_manifold() != &cell->get_manifold())
-                all_manifold_ids_are_equal = false;
-        }
-
-      if (all_manifold_ids_are_equal)
-        {
-          const std::size_t n_rows = support_point_weights_cell.size(0);
-          a.resize(a.size() + n_rows);
-          auto a_view = make_array_view(a.end() - n_rows, a.end());
-          cell->get_manifold().get_new_points(make_array_view(a.begin(),
-                                                              a.end() - n_rows),
-                                              support_point_weights_cell,
-                                              a_view);
-        }
-      else
-        switch (dim)
-          {
-            case 1:
-              add_line_support_points(cell, a);
-              break;
-            case 2:
-              // in 2d, add the points on the four bounding lines to the
-              // exterior (outer) points
-              add_line_support_points(cell, a);
-
-              // then get the interior support points
-              if (dim != spacedim)
-                add_quad_support_points(cell, a);
-              else
-                {
-                  const std::size_t n_rows =
-                    support_point_weights_perimeter_to_interior[1].size(0);
-                  a.resize(a.size() + n_rows);
-                  auto a_view = make_array_view(a.end() - n_rows, a.end());
-                  cell->get_manifold().get_new_points(
-                    make_array_view(a.begin(), a.end() - n_rows),
-                    support_point_weights_perimeter_to_interior[1],
-                    a_view);
-                }
-              break;
-
-            case 3:
-              // in 3d also add the points located on the boundary faces
-              add_line_support_points(cell, a);
-              add_quad_support_points(cell, a);
-
-              // then compute the interior points
-              {
-                const std::size_t n_rows =
-                  support_point_weights_perimeter_to_interior[2].size(0);
-                a.resize(a.size() + n_rows);
-                auto a_view = make_array_view(a.end() - n_rows, a.end());
-                cell->get_manifold().get_new_points(
-                  make_array_view(a.begin(), a.end() - n_rows),
-                  support_point_weights_perimeter_to_interior[2],
-                  a_view);
-              }
-              break;
-
-            default:
-              Assert(false, ExcNotImplemented());
-              break;
-          }
-    }
-
-  return a;
-}
-
-
-
-template <int dim, int spacedim>
-BoundingBox<spacedim>
-MappingQGeneric<dim, spacedim>::get_bounding_box(
-  const typename Triangulation<dim, spacedim>::cell_iterator &cell) const
-{
-  return BoundingBox<spacedim>(this->compute_mapping_support_points(cell));
-}
-
-
-
-template <int dim, int spacedim>
-bool
-MappingQGeneric<dim, spacedim>::is_compatible_with(
-  const ReferenceCell &reference_cell) const
-{
-  Assert(dim == reference_cell.get_dimension(),
-         ExcMessage("The dimension of your mapping (" +
-                    Utilities::to_string(dim) +
-                    ") and the reference cell cell_type (" +
-                    Utilities::to_string(reference_cell.get_dimension()) +
-                    " ) do not agree."));
-
-  return reference_cell.is_hyper_cube();
-}
-
-
-
-//--------------------------- Explicit instantiations -----------------------
-#include "mapping_q_generic.inst"
-
-
-DEAL_II_NAMESPACE_CLOSE
diff --git a/source/fe/mapping_q_generic.inst.in b/source/fe/mapping_q_generic.inst.in
deleted file mode 100644 (file)
index 93b78cc..0000000
+++ /dev/null
@@ -1,22 +0,0 @@
-// ---------------------------------------------------------------------
-//
-// Copyright (C) 2015 - 2018 by the deal.II authors
-//
-// This file is part of the deal.II library.
-//
-// The deal.II library is free software; you can use it, redistribute
-// it, and/or modify it under the terms of the GNU Lesser General
-// Public License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-// The full text of the license can be found in the file LICENSE.md at
-// the top level directory of deal.II.
-//
-// ---------------------------------------------------------------------
-
-
-for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS)
-  {
-#if deal_II_dimension <= deal_II_space_dimension
-    template class MappingQGeneric<deal_II_dimension, deal_II_space_dimension>;
-#endif
-  }
index 06e0a4602624d268ee63b5aab5fdcec6a99593f9..5c9b76652778317dbbe95a3c47029087d0400878 100644 (file)
@@ -33,7 +33,6 @@
 #include <deal.II/fe/fe_values.h>
 #include <deal.II/fe/mapping_q.h>
 #include <deal.II/fe/mapping_q1.h>
-#include <deal.II/fe/mapping_q_generic.h>
 
 #include <deal.II/grid/filtered_iterator.h>
 #include <deal.II/grid/grid_reordering.h>
@@ -139,8 +138,7 @@ namespace GridTools
   {
     // get the degree of the mapping if possible. if not, just assume 1
     unsigned int mapping_degree = 1;
-    if (const auto *p =
-          dynamic_cast<const MappingQGeneric<dim, spacedim> *>(&mapping))
+    if (const auto *p = dynamic_cast<const MappingQ<dim, spacedim> *>(&mapping))
       mapping_degree = p->get_degree();
     else if (const auto *p =
                dynamic_cast<const MappingQ<dim, spacedim> *>(&mapping))
index ab4afa55e2a716a82569de95c35986258ffd5aa8..2842954fd48430ef4e486a1126ca1a01dd48b249 100644 (file)
@@ -24,8 +24,8 @@
 #include <deal.II/dofs/dof_accessor.h>
 #include <deal.II/dofs/dof_handler.h>
 
+#include <deal.II/fe/mapping_q.h>
 #include <deal.II/fe/mapping_q1.h>
-#include <deal.II/fe/mapping_q_generic.h>
 
 #include <deal.II/grid/filtered_iterator.h>
 #include <deal.II/grid/grid_tools.h>
@@ -512,8 +512,7 @@ namespace GridTools
                       }
                   }
                 catch (
-                  typename MappingQGeneric<dim,
-                                           spacedim>::ExcTransformationFailed &)
+                  typename MappingQ<dim, spacedim>::ExcTransformationFailed &)
                   {
                     // ok, the transformation
                     // failed presumably
@@ -1347,8 +1346,7 @@ namespace GridTools
                       }
                   }
                 catch (
-                  typename MappingQGeneric<dim,
-                                           spacedim>::ExcTransformationFailed &)
+                  typename MappingQ<dim, spacedim>::ExcTransformationFailed &)
                   {
                     // ok, the transformation
                     // failed presumably
index 5f0f75b9310a876a0e8e241ebd2577ebdfe8ea70..119752f0141d702eb057a264fe085f3aa6ca85f6 100644 (file)
@@ -23,8 +23,8 @@
 #include <deal.II/fe/fe_simplex_p_bubbles.h>
 #include <deal.II/fe/fe_wedge_p.h>
 #include <deal.II/fe/mapping_fe.h>
+#include <deal.II/fe/mapping_q.h>
 #include <deal.II/fe/mapping_q1.h>
-#include <deal.II/fe/mapping_q_generic.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/reference_cell.h>
@@ -112,7 +112,7 @@ ReferenceCell::get_default_mapping(const unsigned int degree) const
   AssertDimension(dim, get_dimension());
 
   if (is_hyper_cube())
-    return std::make_unique<MappingQGeneric<dim, spacedim>>(degree);
+    return std::make_unique<MappingQ<dim, spacedim>>(degree);
   else if (is_simplex())
     return std::make_unique<MappingFE<dim, spacedim>>(
       FE_SimplexP<dim, spacedim>(degree));
@@ -127,7 +127,7 @@ ReferenceCell::get_default_mapping(const unsigned int degree) const
       Assert(false, ExcNotImplemented());
     }
 
-  return std::make_unique<MappingQGeneric<dim, spacedim>>(degree);
+  return std::make_unique<MappingQ<dim, spacedim>>(degree);
 }
 
 
index dcc0e2ce11503b36eac96b3f43aab37afa5ec171..e3d097524070a537d9860c2a1ccedde4676ede59 100644 (file)
@@ -66,7 +66,7 @@ namespace hp
      * this function is called.
      */
     template <int dim, int spacedim>
-    MappingQGeneric<dim, spacedim> &
+    MappingQ<dim, spacedim> &
     get_static_mapping_q1()
     {
       static MappingQ1<dim, spacedim> mapping;
index d58babb880ea77bc2a82cfc0a2257652119182c0..88f466b52ceb164bcb7cb1b9f5fdfaefe17535e1 100644 (file)
@@ -68,11 +68,11 @@ transfer(std::ostream &out)
   Triangulation<dim> tria(Triangulation<dim>::allow_anisotropic_smoothing);
   GridGenerator::hyper_cube(tria);
   tria.refine_global(3);
-  FE_DGQ<dim>          fe(1);
-  DoFHandler<dim>      dof_handler(tria);
-  Vector<double>       solution;
-  MappingQGeneric<dim> mapping(1);
-  DataOut<dim>         data_out;
+  FE_DGQ<dim>     fe(1);
+  DoFHandler<dim> dof_handler(tria);
+  Vector<double>  solution;
+  MappingQ<dim>   mapping(1);
+  DataOut<dim>    data_out;
 
   dof_handler.distribute_dofs(fe);
   solution.reinit(dof_handler.n_dofs());
index 5bf724f8dee23f40937befdb7847e10e2871e3aa..ba80611e9050765c41beecb11668a9153418580a 100644 (file)
@@ -98,8 +98,8 @@ test()
   ePos(0) = 0.0653630060373507487669897386695;
   ePos(1) = 1125.59175030825804242340382189;
 
-  MappingQ<2>         mapping(1);
-  MappingQGeneric<2> &mapping2 = StaticMappingQ1<2>::mapping;
+  MappingQ<2>  mapping(1);
+  MappingQ<2> &mapping2 = StaticMappingQ1<2>::mapping;
   deallog << "1:" << std::endl;
   GridTools::find_active_cell_around_point(mapping, triangulation, ePos);
   deallog << "2:" << std::endl;
index 6ac52eb2ac41e78065a017a2f78f96dc5dc80d6c..33c9968d146003f7244ecddd2f20e2a32a898f09 100644 (file)
@@ -85,8 +85,8 @@ test()
   ePos(0) = 0.0653630060373507487669897386695;
   ePos(1) = 1125.59175030825804242340382189;
 
-  MappingQ<2>         mapping(1);
-  MappingQGeneric<2> &mapping2 = StaticMappingQ1<2>::mapping;
+  MappingQ<2>  mapping(1);
+  MappingQ<2> &mapping2 = StaticMappingQ1<2>::mapping;
 
   Triangulation<2> triangulation;
   create_coarse_grid(triangulation); // first Tria with just one cell
index a084fe28b4784f08375bf56c2d924ea18237bb85..a53d10564a58ba04e40c00f5f1abf7c027d90db1 100644 (file)
@@ -74,10 +74,9 @@ test()
 
   Point<2> test_point(250, 195);
   std::cout << "Checking Point " << test_point << std::endl;
-  auto current_cell =
-    GridTools::find_active_cell_around_point(MappingQGeneric<2>(1),
-                                             triangulation,
-                                             test_point);
+  auto current_cell = GridTools::find_active_cell_around_point(MappingQ<2>(1),
+                                                               triangulation,
+                                                               test_point);
   if (current_cell.first.state() == IteratorState::valid)
     {
       deallog << "cell: index = " << current_cell.first->index()
index 0d9ef642ba35f5bbe3052f7e68be367997efc2b0..90bd1a557e928662316da5001a5e7151bd8c7290 100644 (file)
@@ -74,8 +74,8 @@ check2()
   deallog << inside(tria, p2) << std::endl;
 
   hp::MappingCollection<3> mappings;
-  mappings.push_back(MappingQGeneric<3>(1));
-  mappings.push_back(MappingQGeneric<3>(1));
+  mappings.push_back(MappingQ<3>(1));
+  mappings.push_back(MappingQ<3>(1));
 
   hp::FECollection<3> fes;
   fes.push_back(FE_Q<3>(1));
index 9ec9baef8145e8b1af819166e2cd48e441d5530b..1f98182b0dc96f18fba216ac94d722873c22cc42 100644 (file)
@@ -32,7 +32,7 @@
 
 void check(Triangulation<3> &tria)
 {
-  MappingQGeneric<3> map(1);
+  MappingQ<3> map(1);
 
   Point<3> p(0.75, 0, 0);
 
index 5e03d6f4df8bfd092bb11ee2ca9305d5a43e7141..204bfff1a30e76ad809484fecf6de108cee890d7 100644 (file)
@@ -32,8 +32,8 @@
 
 void check(Triangulation<3> &tria)
 {
-  MappingQGeneric<3> map(1);
-  Point<3>           p(0.75, 0.75, 0.75);
+  MappingQ<3> map(1);
+  Point<3>    p(0.75, 0.75, 0.75);
 
   std::pair<Triangulation<3>::active_cell_iterator, Point<3>> cell =
     GridTools::find_active_cell_around_point(map, tria, p);
index 777ae40c0efb1132c74ba9ef96145777fff5589b..51a0c54c0cca9d1d51882c3715213af0cccf1590 100644 (file)
@@ -44,7 +44,7 @@
 void check(Triangulation<2> &tria)
 {
   const std::vector<Point<2>> &v = tria.get_vertices();
-  MappingQGeneric<2>           map(1);
+  MappingQ<2>                  map(1);
 
   for (unsigned i = 0; i < tria.n_vertices(); i++)
     {
index cd2258c308086b150ec47068a9c064fd55119c34..cb144d48882ee1f15e1f10e74925cce6b469b742 100644 (file)
@@ -116,8 +116,8 @@ template <int dim>
 void
 check()
 {
-  MappingQGeneric<dim> mapping(1);
-  Triangulation<dim>   tria;
+  MappingQ<dim>      mapping(1);
+  Triangulation<dim> tria;
   make_mesh(tria);
 
   FE_Q<dim>       element(QIterated<1>(QTrapezoid<1>(), 3));
index 2d137b990da1c5e7a8c28886b7cc58531b26e7cb..e14fa1e177cd6c72277160572701b87d3d37c64c 100644 (file)
@@ -145,9 +145,9 @@ check()
   Triangulation<dim> tria;
   make_mesh(tria);
 
-  FE_Q<dim>            element(QIterated<1>(QTrapezoid<1>(), 3));
-  DoFHandler<dim>      dof(tria);
-  MappingQGeneric<dim> mapping(1);
+  FE_Q<dim>       element(QIterated<1>(QTrapezoid<1>(), 3));
+  DoFHandler<dim> dof(tria);
+  MappingQ<dim>   mapping(1);
   dof.distribute_dofs(element);
 
   // test with two different functions: one
index b0ea620c73cf3f11f3f3d5be24be2064dded783f..30311d7c5b05f67e5e5b53da138938421dd1d5c1 100644 (file)
@@ -153,12 +153,12 @@ check()
   fe.push_back(FE_Q<dim>(QIterated<1>(QTrapezoid<1>(), 5)));
 
   hp::MappingCollection<dim> mapping_1;
-  mapping_1.push_back(MappingQGeneric<dim>(1));
-  mapping_1.push_back(MappingQGeneric<dim>(1));
-  mapping_1.push_back(MappingQGeneric<dim>(1));
+  mapping_1.push_back(MappingQ<dim>(1));
+  mapping_1.push_back(MappingQ<dim>(1));
+  mapping_1.push_back(MappingQ<dim>(1));
 
   hp::MappingCollection<dim> mapping_2;
-  mapping_2.push_back(MappingQGeneric<dim>(1));
+  mapping_2.push_back(MappingQ<dim>(1));
 
   DoFHandler<dim> dof_handler(tria);
 
index d1db8b0e8d8e99dbe6bae8f3ab4f0452f9be2c74..b929ff2299829abdb9fe0ada11648c683b65b0ad 100644 (file)
@@ -115,9 +115,9 @@ check()
   Triangulation<dim> tria;
   make_mesh(tria);
 
-  FE_Q<dim>            element(QIterated<1>(QTrapezoid<1>(), 3));
-  DoFHandler<dim>      dof(tria);
-  MappingQGeneric<dim> mapping(1);
+  FE_Q<dim>       element(QIterated<1>(QTrapezoid<1>(), 3));
+  DoFHandler<dim> dof(tria);
+  MappingQ<dim>   mapping(1);
   dof.distribute_dofs(element);
 
   // test with two different functions: one
index 82fd0326f9cc816d9e3b8e8b6ab3117f409b7d18..5f7762c582da512dfa823c3e8718fb58ecba1061 100644 (file)
@@ -123,12 +123,12 @@ check()
   fe.push_back(FE_Q<dim>(5));
 
   hp::MappingCollection<dim> mapping_1;
-  mapping_1.push_back(MappingQGeneric<dim>(1));
-  mapping_1.push_back(MappingQGeneric<dim>(1));
-  mapping_1.push_back(MappingQGeneric<dim>(1));
+  mapping_1.push_back(MappingQ<dim>(1));
+  mapping_1.push_back(MappingQ<dim>(1));
+  mapping_1.push_back(MappingQ<dim>(1));
 
   hp::MappingCollection<dim> mapping_2;
-  mapping_2.push_back(MappingQGeneric<dim>(1));
+  mapping_2.push_back(MappingQ<dim>(1));
 
   DoFHandler<dim> dof_handler(tria);
 
index 678af6ef70fa37816c30082ed44b5b251dd1fb53..1e414f7e7417219416296d4d400e8b6d235eb788 100644 (file)
@@ -77,7 +77,7 @@ transfer(std::ostream &out)
   DoFHandler<dim>           dgq_dof_handler(tria);
   Vector<double>            q_solution;
   Vector<double>            dgq_solution;
-  MappingQGeneric<dim>      mapping(1);
+  MappingQ<dim>             mapping(1);
   DataOut<dim>              q_data_out, dgq_data_out;
   AffineConstraints<double> cm;
   cm.close();
index 8f69239796bc1370c2789316695159f2137c13f5..b1d6b55d6c4df0ec7541fef0b479ed91342ddedb 100644 (file)
@@ -346,8 +346,8 @@ private:
   void
   output_results(const unsigned int cycle) const;
 
-  Triangulation<dim>         triangulation;
-  const MappingQGeneric<dim> mapping;
+  Triangulation<dim>  triangulation;
+  const MappingQ<dim> mapping;
 
   FE_DGQ<dim>     fe;
   DoFHandler<dim> dof_handler;
index 812062744737bb56c84d98688a6562e856dbded4..0c6bfc119395219339068494323dc352ee84c65d 100644 (file)
@@ -187,7 +187,7 @@ Step4<dim>::setup_system()
   solution.reinit(dof_handler.n_dofs());
   system_rhs.reinit(dof_handler.n_dofs());
 
-  MappingQGeneric<dim>                mapping(1);
+  MappingQ<dim>                       mapping(1);
   MeshWorker::IntegrationInfoBox<dim> info_box;
   UpdateFlags update_flags = update_values | update_gradients;
   info_box.add_update_flags_all(update_flags);
index 84ff8b042da23620f13c73e26338e3c85a433f86..f42c82d40a79945e7217d905a4679952019b4f82 100644 (file)
@@ -194,7 +194,7 @@ Step4<dim>::setup_system()
   solution.reinit(dof_handler.n_dofs());
   system_rhs.reinit(dof_handler.n_dofs());
 
-  MappingQGeneric<dim>                mapping(1);
+  MappingQ<dim>                       mapping(1);
   MeshWorker::IntegrationInfoBox<dim> info_box;
   UpdateFlags update_flags = update_values | update_gradients;
   info_box.add_update_flags_all(update_flags);
index a55fdbca04e0529f61ecdbf4369964312296dba6..bd9e71ba2c1a5f489d0d202612d8bf2431c4e06b 100644 (file)
@@ -16,7 +16,7 @@
 
 
 // test mapping surfaces in higher dimensions. when we use the
-// MappingQGeneric(1) class, each 1d cell in 2d space is mapped to a straight
+// MappingQ(1) class, each 1d cell in 2d space is mapped to a straight
 // line and so all cell normals should be parallel. likewise, if the four
 // vertices of a 2d cell in 3d space are in a plane, then the cell normal
 // vectors at all quadrature points of the same cell should be parallel, even
@@ -52,9 +52,9 @@ test()
 
   GridGenerator::extract_boundary_mesh(volume_mesh, boundary_mesh);
 
-  QGauss<dim - 1>               quadrature(2);
-  MappingQGeneric<dim - 1, dim> mapping(1);
-  FE_Q<dim - 1, dim>            fe(1);
+  QGauss<dim - 1>        quadrature(2);
+  MappingQ<dim - 1, dim> mapping(1);
+  FE_Q<dim - 1, dim>     fe(1);
 
   FEValues<dim - 1, dim> fe_values(mapping,
                                    fe,
index 5d1ed0f48e65a840cca6ca9806d657cb10dd8186..78a855b7fd476e8d43009672ce0061a504b9b60d 100644 (file)
@@ -47,8 +47,8 @@ test(std::string filename)
   grid_out.set_flags(GridOutFlags::Ucd(true));
   grid_out.write_ucd(tria, deallog.get_file_stream());
 
-  QTrapezoid<dim>                quad;
-  MappingQGeneric<dim, spacedim> mapping(1);
+  QTrapezoid<dim>         quad;
+  MappingQ<dim, spacedim> mapping(1);
   typename Triangulation<dim, spacedim>::active_cell_iterator
     cell = tria.begin_active(),
     endc = tria.end();
index 4b9776192d47be7ede6d76dfa31aa2cdd1c2cb64..54913adf2aec38b0fe00459fecece4a4bc4d187a 100644 (file)
@@ -117,7 +117,7 @@ test()
   constraints.close();
 
   // Computation on the device
-  MappingQGeneric<dim>                  mapping(fe_degree);
+  MappingQ<dim>                         mapping(fe_degree);
   CUDAWrappers::MatrixFree<dim, double> mf_data;
   typename CUDAWrappers::MatrixFree<dim, double>::AdditionalData
     additional_data;
index 69d6a1000cc6e196e4d637f46f3789a4aa552624..46e41fad76eeda8218b50f9b89cf84c4c0153eea 100644 (file)
@@ -85,7 +85,7 @@ test()
   AffineConstraints<double> constraints(relevant_set);
   constraints.close();
 
-  MappingQGeneric<dim>                  mapping(fe_degree);
+  MappingQ<dim>                         mapping(fe_degree);
   CUDAWrappers::MatrixFree<dim, Number> mf_data;
   const QGauss<1>                       quad(fe_degree + 1);
   typename CUDAWrappers::MatrixFree<dim, Number>::AdditionalData
index cd6cd531e7b08eb1faf71f2d9b4e0ed0d45187e6..dc47e1323e0b31ba2e8cfcd03470daa367be50ab 100644 (file)
@@ -105,7 +105,7 @@ test()
 
   deallog << "Testing " << dof.get_fe().get_name() << std::endl;
 
-  MappingQGeneric<dim>                  mapping(fe_degree);
+  MappingQ<dim>                         mapping(fe_degree);
   CUDAWrappers::MatrixFree<dim, Number> mf_data;
   const QGauss<1>                       quad(fe_degree + 1);
   typename CUDAWrappers::MatrixFree<dim, Number>::AdditionalData
index 55734b1d297c1b4f67029bba571a6497339a098a..250ca0463a4f4752d2e2acd1477d2fa46d07ab51 100644 (file)
@@ -107,7 +107,7 @@ test()
 
   deallog << "Testing " << dof.get_fe().get_name() << std::endl;
 
-  MappingQGeneric<dim>                  mapping(fe_degree);
+  MappingQ<dim>                         mapping(fe_degree);
   CUDAWrappers::MatrixFree<dim, Number> mf_data;
   const QGauss<1>                       quad(fe_degree + 1);
   typename CUDAWrappers::MatrixFree<dim, Number>::AdditionalData
index cf7f617e04f81e85a79749cbaf0c9e8fea9fd429..e39e1b421859fefb0dcb74e41210c5963909d48c 100644 (file)
@@ -101,7 +101,7 @@ test()
 
   deallog << "Testing " << dof.get_fe().get_name() << std::endl;
 
-  MappingQGeneric<dim>                  mapping(fe_degree);
+  MappingQ<dim>                         mapping(fe_degree);
   CUDAWrappers::MatrixFree<dim, Number> mf_data;
   const QGauss<1>                       quad(fe_degree + 1);
   typename CUDAWrappers::MatrixFree<dim, Number>::AdditionalData
index 86bc853f093610ee599b8b534e041120f2fdfb20..38e27a70364029dfb6bf763b0419b3b942a8859f 100644 (file)
@@ -107,7 +107,7 @@ test()
 
   deallog << "Testing " << dof.get_fe().get_name() << std::endl;
 
-  MappingQGeneric<dim>                  mapping(fe_degree);
+  MappingQ<dim>                         mapping(fe_degree);
   CUDAWrappers::MatrixFree<dim, Number> mf_data;
   const QGauss<1>                       quad(fe_degree + 1);
   typename CUDAWrappers::MatrixFree<dim, Number>::AdditionalData
index 5ce71310c0f903b96e882df095859a475807544f..4742c108a6a2e9f60c3c658970bdf94fa5616d22 100644 (file)
@@ -54,7 +54,7 @@ do_test(const DoFHandler<2> &            dof,
                        LinearAlgebra::CUDAWrappers::Vector<double>,
                        n_q_points_1d> &  mf,
         unsigned int                     n_dofs,
-        MappingQGeneric<2> &             mapping,
+        MappingQ<2> &                    mapping,
         const AffineConstraints<double> &constraints)
 {
   Vector<double>                              in_host(n_dofs), out_host(n_dofs);
@@ -162,7 +162,7 @@ main()
   FE_Q<2>                fe_1(fe_degree_1);
   DoFHandler<2>          dof_1(tria);
   dof_1.distribute_dofs(fe_1);
-  MappingQGeneric<2>                                  mapping_1(fe_degree_1);
+  MappingQ<2>                                         mapping_1(fe_degree_1);
   CUDAWrappers::MatrixFree<2, double>                 mf_data_1;
   CUDAWrappers::MatrixFree<2, double>::AdditionalData additional_data_1;
   additional_data_1.mapping_update_flags = update_values | update_gradients |
@@ -186,7 +186,7 @@ main()
   FE_Q<2>                fe_2(fe_degree_2);
   DoFHandler<2>          dof_2(tria);
   dof_2.distribute_dofs(fe_2);
-  MappingQGeneric<2>                                  mapping_2(fe_degree_2);
+  MappingQ<2>                                         mapping_2(fe_degree_2);
   CUDAWrappers::MatrixFree<2, double>                 mf_data_2;
   CUDAWrappers::MatrixFree<2, double>::AdditionalData additional_data_2;
   additional_data_2.mapping_update_flags = update_values | update_gradients |
index 10e2f204d25b948e43d48497eceeae6ccf0b8d5c..0d072baba338796124dcc9f71e752804bc1ff44c 100644 (file)
@@ -68,7 +68,7 @@ test()
                                            constraints);
   constraints.close();
 
-  MappingQGeneric<dim>                  mapping(fe_degree);
+  MappingQ<dim>                         mapping(fe_degree);
   CUDAWrappers::MatrixFree<dim, Number> mf_data;
   const QGauss<1>                       quad(fe_degree + 1);
   typename CUDAWrappers::MatrixFree<dim, Number>::AdditionalData
index 1afedb5607753c8cbe06c32f4bf6c8936363575f..f18302111ad7ce528c4edb9e92f1a2ee24e1f68b 100644 (file)
@@ -84,7 +84,7 @@ do_test(const DoFHandler<dim> &          dof,
 {
   deallog << "Testing " << dof.get_fe().get_name() << std::endl;
 
-  MappingQGeneric<dim>                  mapping(fe_degree);
+  MappingQ<dim>                         mapping(fe_degree);
   CUDAWrappers::MatrixFree<dim, Number> mf_data;
   typename CUDAWrappers::MatrixFree<dim, Number>::AdditionalData
     additional_data;
index 4dc32b4cccce75e85f30d91604c61971114b5db2..e4b0dfb66d1e9ee886ea43953c31fad8c78d51a2 100644 (file)
@@ -106,7 +106,7 @@ test()
 
   deallog << "Testing " << dof.get_fe().get_name() << std::endl;
 
-  MappingQGeneric<dim>                  mapping(fe_degree);
+  MappingQ<dim>                         mapping(fe_degree);
   CUDAWrappers::MatrixFree<dim, Number> mf_data;
   const QGauss<1>                       quad(fe_degree + 1);
   typename CUDAWrappers::MatrixFree<dim, Number>::AdditionalData
index f4e7b4bbaf2a925977077c92df1641200f11481f..ffa49a89656e9ab289777e8dd47617201e25bcdb 100644 (file)
@@ -22,7 +22,7 @@
 
 #include <deal.II/fe/fe_q.h>
 #include <deal.II/fe/fe_system.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/tria.h>
@@ -54,7 +54,7 @@ test()
     component_interpretation(
       dim, DataComponentInterpretation::component_is_part_of_vector);
 
-  MappingQGeneric<dim> mapping(2);
+  MappingQ<dim> mapping(2);
 
   // variant 1
   {
index 8f781b8b79288fcf210fed1742862f6e80d29c20..bcabebfe5655ee4bf6f2864cfc6d571c9e6fbaec 100644 (file)
@@ -20,7 +20,7 @@
 #include <deal.II/dofs/dof_handler.h>
 
 #include <deal.II/fe/fe_q.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/tria.h>
@@ -44,8 +44,8 @@ check(std::ostream &log, unsigned cell_order)
   DoFHandler<dim> dof_handler(triangulation);
   dof_handler.distribute_dofs(fe);
 
-  Vector<double>       vec(dof_handler.n_dofs());
-  MappingQGeneric<dim> mapping(cell_order);
+  Vector<double> vec(dof_handler.n_dofs());
+  MappingQ<dim>  mapping(cell_order);
 
   VectorTools::interpolate(mapping,
                            dof_handler,
index 57fa59fd27588d6ed8a2b0dcd7087ea64e8329ba..1363d54aea21e0223385057b0006a25af97b560a 100644 (file)
@@ -20,7 +20,7 @@
 #include <deal.II/dofs/dof_handler.h>
 
 #include <deal.II/fe/fe_q.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/tria.h>
@@ -43,8 +43,8 @@ check(std::ostream &log, unsigned cell_order)
   DoFHandler<dim> dof_handler(triangulation);
   dof_handler.distribute_dofs(fe);
 
-  Vector<double>       vec(dof_handler.n_dofs());
-  MappingQGeneric<dim> mapping(cell_order);
+  Vector<double> vec(dof_handler.n_dofs());
+  MappingQ<dim>  mapping(cell_order);
 
   VectorTools::interpolate(mapping,
                            dof_handler,
index 722d7f5a7951bfbedd0ee6d347672885d21c1005..027b2e6eab2c11cce68af946db65480a26c8dd23 100644 (file)
@@ -20,7 +20,7 @@
 #include <deal.II/dofs/dof_handler.h>
 
 #include <deal.II/fe/fe_q.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/tria.h>
@@ -51,8 +51,8 @@ check(std::ostream &log, unsigned cell_order)
   DoFHandler<dim> dof_handler(triangulation);
   dof_handler.distribute_dofs(fe);
 
-  Vector<double>       vec(dof_handler.n_dofs());
-  MappingQGeneric<dim> mapping(cell_order);
+  Vector<double> vec(dof_handler.n_dofs());
+  MappingQ<dim>  mapping(cell_order);
 
   VectorTools::interpolate(mapping,
                            dof_handler,
index f33f461d95f895d37f5050c62581929de0f56e0e..a36afe12b9a5eeec79a78b98368c952b34d4b4c1 100644 (file)
@@ -20,7 +20,7 @@
 #include <deal.II/dofs/dof_handler.h>
 
 #include <deal.II/fe/fe_q.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/tria.h>
@@ -43,8 +43,8 @@ check(std::ostream &log, unsigned cell_order)
   DoFHandler<dim> dof_handler(triangulation);
   dof_handler.distribute_dofs(fe);
 
-  Vector<double>       vec(dof_handler.n_dofs());
-  MappingQGeneric<dim> mapping(cell_order);
+  Vector<double> vec(dof_handler.n_dofs());
+  MappingQ<dim>  mapping(cell_order);
 
   VectorTools::interpolate(mapping,
                            dof_handler,
index 4e956bc35bc586a841314f6d20fc3b90fe1608a0..df443cc819179be65840625d3313ef3837005ea4 100644 (file)
@@ -136,9 +136,9 @@ curved_grid(std::ostream &out)
   // now provide everything that is
   // needed for solving a Laplace
   // equation.
-  MappingQGeneric<2> mapping_q1(1);
-  FE_Q<2>            fe(2);
-  DoFHandler<2>      dof_handler(triangulation);
+  MappingQ<2>   mapping_q1(1);
+  FE_Q<2>       fe(2);
+  DoFHandler<2> dof_handler(triangulation);
   dof_handler.distribute_dofs(fe);
   SparsityPattern sparsity_pattern(dof_handler.n_dofs(),
                                    dof_handler.n_dofs(),
index 28f73c2f550dbda93ab87d032dd3367359dd782f..23647bdae53090ed5b81c7a8f778f6d3be3b03cd 100644 (file)
@@ -65,7 +65,7 @@ test()
   MappingFEField<dim, spacedim> mapping_1(dhq, eulerq, mask);
 
   // create first mapping class, that does preserve position of vertices
-  MappingQGeneric<dim, spacedim> mapping_2(1);
+  MappingQ<dim, spacedim> mapping_2(1);
 
   // create mapping collection
   hp::FECollection<dim>      fe_collection(FE_Q<dim>(1), FE_Q<dim>(1));
index a6d456a7b548fa1f7abd168be5138a0a4c7501a6..7b736706897c8eb19a3377a2cbb64a3023e2429c 100644 (file)
@@ -65,7 +65,7 @@ void
 test(std::ostream & /*out*/)
 {
   MyFunction<dim>                           func;
-  MappingQGeneric<dim>                      mapping(1);
+  MappingQ<dim>                             mapping(1);
   parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
 
   GridGenerator::hyper_cube(tr);
index d84c7543554ccc6ee27f608a84ebb81ec6dba1a4..907e591f6a047d192284b2267a1ce563504b5ce5 100644 (file)
@@ -64,7 +64,7 @@ void
 test(std::ostream & /*out*/)
 {
   MyFunction<dim>                           func;
-  MappingQGeneric<dim>                      mapping(1);
+  MappingQ<dim>                             mapping(1);
   parallel::distributed::Triangulation<dim> tr(MPI_COMM_WORLD);
 
   GridGenerator::hyper_cube(tr);
index 92b37659ad02a0462b46dd0b3a3d4941e806192d..dae3c6ecd091b858285f6ca2e57d4dc0497971f4 100644 (file)
@@ -29,7 +29,7 @@
 #include <deal.II/dofs/dof_tools.h>
 
 #include <deal.II/fe/fe_q.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/grid_out.h>
index a0afc98c8240729c4920e49e5805d7e0ecb05b42..ac154f3908044702fb2b1ca340ebcb4557ae0e73 100644 (file)
@@ -92,7 +92,7 @@ test()
       dof_handler.distribute_dofs(fe);
 
       Vector<double> interpolant(dof_handler.n_dofs());
-      VectorTools::interpolate_based_on_material_id(MappingQGeneric<dim>(1),
+      VectorTools::interpolate_based_on_material_id(MappingQ<dim>(1),
                                                     dof_handler,
                                                     functions,
                                                     interpolant);
index 2944c0d909d406b4b91098c2b0e0bfcbd5b4f50b..8234118ec951df7fe5ab19ebe79fd03db56f1c97 100644 (file)
@@ -633,7 +633,7 @@ main(int /*argc*/, char ** /*argv*/)
   hn_constraints.clear();
   DoFTools::make_hanging_node_constraints(*dof_handler, hn_constraints);
   hn_constraints.close();
-  MappingQGeneric<2> map_default(1);
+  MappingQ<2> map_default(1);
   project(map_default,
           *dof_handler,
           hn_constraints,
index be07865ecf44ce8d31dbdd6101187bd70cef2d97..a24a65cec408800a0dadda3e7e12cc53089b525d 100644 (file)
@@ -542,7 +542,7 @@ main()
   hn_constraints.clear();
   DoFTools::make_hanging_node_constraints(dof_handler, hn_constraints);
   hn_constraints.close();
-  MappingQGeneric<3> map_default(1);
+  MappingQ<3> map_default(1);
   project(map_default,
           dof_handler,
           hn_constraints,
index 920a6ed421f761e5bdb0632b3dfed2f0d6aa46c1..8808da3dd3b66fb178e98d3efabfc477e2bd07b9 100644 (file)
@@ -71,7 +71,7 @@ test(const Triangulation<dim> &tr)
   FE_Q<dim> fe(1);
   deallog << "FE=" << fe.get_name() << std::endl;
 
-  MappingQGeneric<dim> mapping(1);
+  MappingQ<dim> mapping(1);
   deallog << "Mapping=Q1" << std::endl;
 
 
index dc093efa416919a2c89d60e1ed22f947d04a3705..6ed4e7581391201e46ad7638a54b5a972e260295 100644 (file)
@@ -71,7 +71,7 @@ test(const Triangulation<dim> &tr)
   FE_Q<dim> fe(2);
   deallog << "FE=" << fe.get_name() << std::endl;
 
-  MappingQGeneric<dim> mapping(1);
+  MappingQ<dim> mapping(1);
   deallog << "Mapping=Q1" << std::endl;
 
 
index c9489b264f9e32dce6df2b728475932f760560ad..c72b0eb165f6413fc4bad25e80cbb974ea1734d2 100644 (file)
@@ -71,7 +71,7 @@ test(const Triangulation<dim> &tr)
   FE_DGPMonomial<dim> fe(1);
   deallog << "FE=" << fe.get_name() << std::endl;
 
-  MappingQGeneric<dim> mapping(1);
+  MappingQ<dim> mapping(1);
   deallog << "Mapping=Q1" << std::endl;
 
 
index c7bc94b8f2ffe83b764968102afac7ffd0c793ca..a53070c0a07b07487fb7c2c538a16e7b4f989dc1 100644 (file)
@@ -71,7 +71,7 @@ test(const Triangulation<dim> &tr)
   FE_DGPMonomial<dim> fe(2);
   deallog << "FE=" << fe.get_name() << std::endl;
 
-  MappingQGeneric<dim> mapping(1);
+  MappingQ<dim> mapping(1);
   deallog << "Mapping=Q1" << std::endl;
 
 
index 0f35a1551d0c9f10796c219a03b84503df723e61..d5607df92deecae598b648825c80e38271348426 100644 (file)
@@ -71,7 +71,7 @@ test(const Triangulation<dim> &tr)
   FE_DGPNonparametric<dim> fe(1);
   deallog << "FE=" << fe.get_name() << std::endl;
 
-  MappingQGeneric<dim> mapping(1);
+  MappingQ<dim> mapping(1);
   deallog << "Mapping=Q1" << std::endl;
 
 
index 0d8da5bc12af2f5c40ef2f2e57fa3643b3d41688..3a567ed39ac49a8dea2cfd15a720578c2b48607b 100644 (file)
@@ -71,7 +71,7 @@ test(const Triangulation<dim> &tr)
   FE_DGPNonparametric<dim> fe(2);
   deallog << "FE=" << fe.get_name() << std::endl;
 
-  MappingQGeneric<dim> mapping(1);
+  MappingQ<dim> mapping(1);
   deallog << "Mapping=Q1" << std::endl;
 
 
index 7ebc726bb8ff70c760bf54bb7ce93d3129247e83..d537359312e8cd66b1f0af22c8cec0c70bbb95a2 100644 (file)
@@ -744,7 +744,7 @@ check(const FiniteElement<2> &           fe,
       DoFTools::make_hanging_node_constraints(*dof_handler, hn_constraints);
       hn_constraints.close();
 
-      MappingQGeneric<2> map_default(1);
+      MappingQ<2> map_default(1);
 
       project(map_default,
               *dof_handler,
index e3bd63f51885350ea3910e0d5261819374e34545..7ac19c8f7e5081c8834c0d35fed6176b67c67db5 100644 (file)
@@ -88,8 +88,8 @@ template <int dim>
 void
 plot_FE_Q_shape_functions()
 {
-  MappingQGeneric<dim> m(1);
-  FE_Q<dim>            q1(1);
+  MappingQ<dim> m(1);
+  FE_Q<dim>     q1(1);
   plot_derivatives(m, q1, "Q1");
   //  plot_face_shape_functions(m, q1, "Q1");
   FE_Q<dim> q2(2);
@@ -120,8 +120,8 @@ template <int dim>
 void
 plot_FE_DGQ_shape_functions()
 {
-  MappingQGeneric<dim> m(1);
-  FE_DGQ<dim>          q1(1);
+  MappingQ<dim> m(1);
+  FE_DGQ<dim>   q1(1);
   plot_derivatives(m, q1, "DGQ1");
   //  plot_face_shape_functions(m, q1, "DGQ1");
   FE_DGQ<dim> q2(2);
@@ -169,8 +169,8 @@ main()
 
 
   // FESystem test.
-  MappingQGeneric<2> m(1);
-  FESystem<2>        q2_q3(FE_Q<2>(2),
+  MappingQ<2> m(1);
+  FESystem<2> q2_q3(FE_Q<2>(2),
                     1,
                     FE_Q<2>(QIterated<1>(QTrapezoid<1>(), 3)),
                     1);
index a6ff93d5fd3a8ac36aeecfda8a4bd3f0688ab762..528c661527b663e8b9179e10761bfb729563be56 100644 (file)
@@ -87,8 +87,8 @@ template <int dim>
 void
 plot_FE_Bernstein_shape_functions()
 {
-  MappingQGeneric<dim> m(1);
-  FE_Bernstein<dim>    b1(1);
+  MappingQ<dim>     m(1);
+  FE_Bernstein<dim> b1(1);
   plot_derivatives(m, b1, "B1");
 
   FE_Bernstein<dim> b2(2);
@@ -124,8 +124,8 @@ main()
 
 
   // FESystem test.
-  MappingQGeneric<2> m(1);
-  FESystem<2>        q2_q3(FE_Bernstein<2>(2), 1, FE_Bernstein<2>(3), 1);
+  MappingQ<2> m(1);
+  FESystem<2> q2_q3(FE_Bernstein<2>(2), 1, FE_Bernstein<2>(3), 1);
   //  plot_derivatives(m, q2_q3, "B2_Q3");
 
   return 0;
index a363f83ce18e64f6e51e72fc72b2f4089dff62cc..b13980b0cb8e5b9aeab40c16ea52c3f58a758915 100644 (file)
@@ -80,7 +80,7 @@ template <int dim>
 void
 plot_FE_Q_shape_functions()
 {
-  MappingQGeneric<dim> m(1);
+  MappingQ<dim> m(1);
   //  FE_Q<dim> q1(1);
   //  plot_derivatives(m, q1, "Q1");
   //  plot_face_shape_functions(m, q1, "Q1");
@@ -97,8 +97,8 @@ template <int dim>
 void
 plot_FE_DGQ_shape_functions()
 {
-  MappingQGeneric<dim> m(1);
-  FE_DGQ<dim>          q1(1);
+  MappingQ<dim> m(1);
+  FE_DGQ<dim>   q1(1);
   plot_derivatives(m, q1, "DGQ1");
   FE_DGQ<dim> q2(2);
   plot_derivatives(m, q2, "DGQ2");
index 642eb78ce0bd111e187737ec8779585e9cdeaf6a..772119c8beeddd2f020de604f5f2441d65acf4bb 100644 (file)
@@ -144,8 +144,8 @@ mapping_test()
   std::vector<Mapping<dim> *> mapping_ptr;
   std::vector<std::string>    mapping_strings;
 
-  MappingQGeneric<dim> mapping(1);
-  std::string          mapping_name = "MappingQ1";
+  MappingQ<dim> mapping(1);
+  std::string   mapping_name = "MappingQ1";
 
   Triangulation<dim> tria;
   GridGenerator::hyper_cube(tria);
index c51fe56e1fdd938c88db6d94c6b95f6ba2227722..85e2ba211f5b3ff3d2d5b2fcd29bb0f98e257954 100644 (file)
@@ -182,7 +182,7 @@ test(const FiniteElement<dim> &fe,
   const QGauss<dim>                quadrature(fe.degree + 1);
   const unsigned int               n_q_points = quadrature.size();
   MappingQ<dim>                    mapping(1);
-  // MappingQGeneric<dim> mapping(1);
+  // MappingQ<dim> mapping(1);
   std::vector<double>                                         div_v(n_q_points);
   std::vector<typename FEValuesViews::Vector<dim>::curl_type> curl_v(
     n_q_points);
index ebaa740c381e8e84f96e760181f2b566b04aef91..84ff5f72caf9478b90c589f9e713280ada43a1b1 100644 (file)
@@ -247,7 +247,7 @@ test(const FiniteElement<dim> &fe,
   const unsigned int               n_q_points      = quadrature.size();
   const unsigned int               n_face_q_points = face_quadrature.size();
   // MappingQ<dim> mapping(2);
-  MappingQGeneric<dim>                                        mapping(1);
+  MappingQ<dim>                                               mapping(1);
   std::vector<double>                                         div_v(n_q_points);
   std::vector<typename FEValuesViews::Vector<dim>::curl_type> curl_v(
     n_q_points);
index 284fddf092704c588a49f46d8fa0452b3cd4f820..97ee685583a9deb3c07dd77bdc7339c897c7126c 100644 (file)
@@ -202,8 +202,8 @@ main()
 {
   initlog();
 
-  Triangulation<2>   tria;
-  MappingQGeneric<2> mapping(1);
+  Triangulation<2> tria;
+  MappingQ<2>      mapping(1);
 
   make_grid(tria);
 
index eb2e0c411f821fea3314bd5e7755c635c41f87c4..06cfcc9b7c76fe11ee30b023931923d121dc662f 100644 (file)
@@ -27,7 +27,7 @@
 
 #include <deal.II/fe/fe_q.h>
 #include <deal.II/fe/fe_values.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/manifold.h>
@@ -238,7 +238,7 @@ protected:
   FE_Q<dim>                      finite_element;
   DoFHandler<dim>                dof_handler;
   QGauss<dim>                    cell_quadrature;
-  MappingQGeneric<dim>           cell_mapping;
+  MappingQ<dim>                  cell_mapping;
 
   AffineConstraints<double> all_constraints;
   SparsityPattern           sparsity_pattern;
index cbfd78d0ec43aa6bf2deb01918819a8e79b8c00c..b9c092047df1c5d136c5c8e30f8aaa19ab887d7c 100644 (file)
@@ -118,7 +118,7 @@ test(const Triangulation<dim> &tr, const FiniteElement<dim> &fe)
 
   VectorFunction<dim> fe_function;
 
-  MappingQGeneric<dim> mapping(1);
+  MappingQ<dim> mapping(1);
 
   const QGauss<dim> quadrature(fe.degree + 2);
   FEValues<dim>     fe_values(mapping,
index b452d071f156533667e6b4966c657c8655983afc..18177247b05ed8d834631f4e36a25f80f3499533 100644 (file)
@@ -31,7 +31,7 @@ template <int dim>
 void
 plot_FE_Bernstein_shape_functions()
 {
-  MappingQGeneric<dim> m(1);
+  MappingQ<dim> m(1);
 
   FE_Bernstein<dim> b1(1);
   plot_shape_functions(m, b1, "B1");
index 39533b921bffdc485a6b7d4fda25e6b9a0436c00..077d86108438825923a028d46d0ed94f0b2c890f 100644 (file)
@@ -30,7 +30,7 @@ template <int dim>
 void
 plot_FE_DGP_shape_functions()
 {
-  MappingQGeneric<dim> m(1);
+  MappingQ<dim> m(1);
 
   FE_DGP<dim> p1(1);
   plot_shape_functions(m, p1, "DGP1");
index 6b9ec93cf2596ab572f97883a8c6d923e1b97543..bb92bd3f4885fb911b1a7a0582ffebd9d99139be 100644 (file)
@@ -30,7 +30,7 @@ template <int dim>
 void
 plot_FE_DGPMonomial_shape_functions()
 {
-  MappingQGeneric<dim> m(1);
+  MappingQ<dim> m(1);
 
   FE_DGPMonomial<dim> p1(1);
   plot_shape_functions(m, p1, "DGPMonomial1");
index 4d745aa1b392c9b2199092438db15ae0aa44a712..611d4aaf2ee4adfa2715ca3346ecc4d864c0dcca 100644 (file)
@@ -30,7 +30,7 @@ template <int dim>
 void
 plot_FE_DGPNonparametric_shape_functions()
 {
-  MappingQGeneric<dim> m(1);
+  MappingQ<dim> m(1);
 
   FE_DGPNonparametric<dim> p0(0);
   plot_shape_functions(m, p0, "DGPNonparametric0");
index 07060307f4d4aee09212c2db6604e181e989ab19..d6ac2665eec04b362183fc356901ed5db3731909 100644 (file)
@@ -30,7 +30,7 @@ template <int dim>
 void
 plot_FE_DGQ_shape_functions()
 {
-  MappingQGeneric<dim> m(1);
+  MappingQ<dim> m(1);
 
   FE_DGQ<dim> q1(1);
   plot_shape_functions(m, q1, "DGQ1");
index 1964ca6461fbf958e2ef263e4680c0841e88266c..4d7937707000f1e6bb00b22db3d0d15f4a3036a1 100644 (file)
@@ -32,7 +32,7 @@ template <int dim>
 void
 plot_FE_FaceQ_shape_functions()
 {
-  MappingQGeneric<dim> m(1);
+  MappingQ<dim> m(1);
 
   FE_FaceQ<dim> q0(0);
   FE_FaceQ<dim> q1(1);
index a40e5469a5d9c25a833ccf2c63d166771be408eb..8a02ba52cfa64c88a22483a517835227d841e818 100644 (file)
@@ -30,8 +30,8 @@ template <int dim>
 void
 plot_FE_Nedelec_shape_functions()
 {
-  MappingQGeneric<dim> m(1);
-  FE_Nedelec<dim>      p0(0);
+  MappingQ<dim>   m(1);
+  FE_Nedelec<dim> p0(0);
   //   plot_shape_functions(m, p1, "Nedelec1");
   //   plot_face_shape_functions(m, p1, "Nedelec1");
   test_compute_functions(m, p0, "Nedelec0");
index 77ddba8a8e1506f1299d3586f23fa73361b5524e..d6789456a314c3fc9278578ca23c1d6f2caeb5ab 100644 (file)
@@ -30,7 +30,7 @@ template <int dim>
 void
 plot_FE_Q_shape_functions()
 {
-  MappingQGeneric<dim> m(1);
+  MappingQ<dim> m(1);
 
   FE_Q<dim> q1(1);
   plot_shape_functions(m, q1, "Q1");
index e54687514cbbdb3bdbfbf106f5e204a363cc05aa..5d5cba9079c5ec6ad948b15c9640679fe2ab9fea 100644 (file)
@@ -30,7 +30,7 @@ template <int dim>
 void
 plot_FE_Q_Bubbles_shape_functions()
 {
-  MappingQGeneric<dim> m(1);
+  MappingQ<dim> m(1);
 
   FE_Q_Bubbles<dim> q1(1);
   plot_shape_functions(m, q1, "Q1_Bubbles");
index d35851331db526d79174f49ed842ddd7b5d7534f..af138e701ed0a3b7f8556977a41b2128c5122c5d 100644 (file)
@@ -30,7 +30,7 @@ template <int dim>
 void
 plot_FE_Q_DG0_shape_functions()
 {
-  MappingQGeneric<dim> m(1);
+  MappingQ<dim> m(1);
 
   FE_Q_DG0<dim> q1(1);
   plot_shape_functions(m, q1, "Q1_DG0");
index c37beb5c3e84bd42df92d3dfb85b17bd91f33996..7d1edf7d6c38a66cdb040e1e7d130bfdba693966 100644 (file)
@@ -30,7 +30,7 @@ template <int dim>
 void
 plot_FE_Q_Hierarchical_shape_functions()
 {
-  MappingQGeneric<dim> m(1);
+  MappingQ<dim> m(1);
 
   FE_Q_Hierarchical<dim> q1(1);
   plot_shape_functions(m, q1, "QHierarchical1");
index deb0aa5e7a9d7a5394f470695f8bbe8eb26cbd8e..b927461fe661a3ff006ffcf806dbd9f742f41fae 100644 (file)
@@ -30,7 +30,7 @@ template <int dim>
 void
 plot_FE_Q_shape_functions()
 {
-  MappingQGeneric<dim> m(1);
+  MappingQ<dim> m(1);
 
   FE_Q_iso_Q1<dim> q1(1);
   plot_shape_functions(m, q1, "Q1");
index 37d38023548c02b743ad1146b8a31cf661c6f0ec..fabb4a4b8a3794ce6c3a25adc244edcb2acc3c0d 100644 (file)
@@ -33,7 +33,7 @@ template <int dim>
 void
 plot_FE_System_shape_functions()
 {
-  MappingQGeneric<dim> m(1);
+  MappingQ<dim> m(1);
 
   //   FESystem<dim> p1(FE_Q<dim>(2), 1,
   //                    FE_Q<dim>(dim<3 ? 3 : 2), 2);
index 869752687925cf5566e77c5df76044d205ee7f65..718c51e678526be678f2ff1659b06ed294b58b9a 100644 (file)
@@ -35,7 +35,7 @@ template <int dim>
 void
 plot_FE_System_shape_functions()
 {
-  MappingQGeneric<dim> m(1);
+  MappingQ<dim> m(1);
 
   FESystem<dim> p3(FE_Q<dim>(1), 1, FESystem<dim>(FE_Q<dim>(1), 2), 2);
   test_compute_functions(m, p3, "System_1");
index 62c8f791c731ac6e7dda802e7e9e55def13fbca3..4bcdcc39fff2717c7c8ba472f36aaf6e50459779 100644 (file)
@@ -31,7 +31,7 @@ template <int dim>
 void
 plot_FE_TraceQ_shape_functions()
 {
-  MappingQGeneric<dim> m(1);
+  MappingQ<dim> m(1);
 
   FE_TraceQ<dim> tq1(1);
   FE_TraceQ<dim> tq2(2);
index bde0d89cc5be4d0ea38ae9a33620bcea159ba81a..b38a7028d85f6b6e9053a101ae843576b2f93279 100644 (file)
@@ -95,7 +95,7 @@ test(int n_refinements, MPI_Comm comm)
     additional_data.mapping_update_flags_faces_by_cells =
       update_gradients | update_JxW_values | update_quadrature_points;
 
-    MappingQGeneric<dim>      mapping(1);
+    MappingQ<dim>             mapping(1);
     QGauss<1>                 quad(degree + 1);
     AffineConstraints<double> constraint;
 
index 1fa088bfa098a00655ab91f2f5a2de4ee60bf888..3457f91a0ac927c63215917228069c2672fbd0f9 100644 (file)
@@ -19,7 +19,7 @@
 #include <deal.II/base/logstream.h>
 #include <deal.II/base/utilities.h>
 
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/grid_tools.h>
@@ -54,7 +54,7 @@ test(unsigned int n_ref)
   Triangulation<dim, spacedim> tria;
   GridGenerator::hyper_cube(tria);
   tria.refine_global(n_ref);
-  MappingQGeneric<dim, spacedim> mapping(3);
+  MappingQ<dim, spacedim> mapping(3);
 
   Point<dim> p;
   {
index 984f0b9246920641e5b1a2441e52c5f727a5141c..85c982a1d62fa27a8b3aaf032da9f26efa87810b 100644 (file)
@@ -19,7 +19,7 @@
 #include <deal.II/base/logstream.h>
 #include <deal.II/base/utilities.h>
 
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/grid_tools.h>
@@ -55,7 +55,7 @@ test(unsigned int n_ref)
   Triangulation<dim, spacedim> tria;
   GridGenerator::hyper_cube(tria);
   tria.refine_global(n_ref);
-  MappingQGeneric<dim, spacedim> mapping(3);
+  MappingQ<dim, spacedim> mapping(3);
 
   Point<dim> p;
   {
index d2318f5e80e338e7478c27ec43822e21c182b738..b4d2fd4484c443442b4fa7a92d3da715df1eb8db 100644 (file)
@@ -19,7 +19,7 @@
 #include <deal.II/base/logstream.h>
 #include <deal.II/base/utilities.h>
 
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/grid_tools.h>
@@ -54,7 +54,7 @@ test(unsigned int n_ref)
   Triangulation<dim, spacedim> tria;
   GridGenerator::hyper_shell(tria, Point<dim>(), 0.8, 1., dim == 2 ? 3 : 6);
   tria.refine_global(n_ref);
-  MappingQGeneric<dim, spacedim> mapping(8);
+  MappingQ<dim, spacedim> mapping(8);
 
   {
     const double phi   = 0.;
index 48a41b563c7661e0b6a598e83e978754f78960bf..b5cc27db6840b2ad95cead308f50d519341c91ad 100644 (file)
@@ -19,7 +19,7 @@
 #include <deal.II/base/logstream.h>
 #include <deal.II/base/utilities.h>
 
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/grid_tools.h>
@@ -71,7 +71,7 @@ test(unsigned int n_ref)
   Triangulation<dim, spacedim> tria;
   GridGenerator::channel_with_cylinder(tria, 0.03, 2, 2);
   tria.refine_global(n_ref);
-  MappingQGeneric<dim, spacedim> mapping(3);
+  MappingQ<dim, spacedim> mapping(3);
 
   Point<dim> p1;
   p1[0] = 0.28;
index 02de9d4a9eefcba5b8aa0b1b7bb1305a477ea0e2..d14d608992df8547b83b91b10c80640f705752d2 100644 (file)
@@ -27,7 +27,7 @@
 #include <deal.II/fe/fe_q_iso_q1.h>
 #include <deal.II/fe/fe_system.h>
 #include <deal.II/fe/mapping_fe_field.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/grid_out.h>
index a50e53e9198ff164fca863f5b476196daf743d13..92e5a273dc14727d17d3027504342a83ac91599b 100644 (file)
@@ -26,7 +26,7 @@
 
 #include <deal.II/distributed/tria.h>
 
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/grid_tools.h>
@@ -48,8 +48,8 @@ test()
   GridGenerator::torus(
     tria_open, R, r, n_cells_toroidal / factor, angle / (double)factor);
 
-  MappingQGeneric<3> const mapping(3);
-  QGauss<3> const          gauss(4);
+  MappingQ<3> const mapping(3);
+  QGauss<3> const   gauss(4);
 
   double const ar_full_torus =
     GridTools::compute_maximum_aspect_ratio(mapping, tria, gauss);
index 7794602a3be0088bad3a4d5c66fe42206cf71b4a..215f234b82846e2f9d36567003c80a514229739c 100644 (file)
@@ -20,7 +20,7 @@
 // and also that we can do output in dim = 2, spacedim = 3.
 
 
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/grid_out.h>
@@ -57,7 +57,7 @@ gnuplot_output(const GridOutFlags::Gnuplot &flags)
   Triangulation<dim, spacedim> triangulation;
   make_grid(triangulation);
 
-  MappingQGeneric<dim, spacedim> mapping(3);
+  MappingQ<dim, spacedim> mapping(3);
 
   auto cell = triangulation.begin_active();
   cell->set_refine_flag(); // 0
index 39e310cb6e43fe14e69a618355f460586f68115b..39fa9721ce8e50efc053b03aa04aa50c40bf3e07 100644 (file)
@@ -26,7 +26,7 @@
 #include <deal.II/dofs/dof_handler.h>
 
 #include <deal.II/fe/fe_dgq.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/grid_tools.h>
@@ -72,8 +72,8 @@ compute_aspect_ratio_hyper_rectangle(
       tria.begin_active()->vertex(0) += shift;
     }
 
-  MappingQGeneric<dim> const mapping(degree);
-  QGauss<dim> const          gauss(n_q_points);
+  MappingQ<dim> const mapping(degree);
+  QGauss<dim> const   gauss(n_q_points);
 
   Vector<double> ratios =
     GridTools::compute_aspect_ratio_of_cells(mapping, tria, gauss);
index 9a80b53f59e70ac3cdbb3eb88e538d9d5408d279..91bb5c9acdba2d0af949b7bc6ecae57d2e839fba 100644 (file)
@@ -16,7 +16,7 @@
 #include <deal.II/base/geometry_info.h>
 #include <deal.II/base/tensor.h>
 
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/grid_tools.h>
@@ -221,7 +221,7 @@ main()
             << "minimizers. The output here has been eyeballed as decent."
             << std::endl;
 
-    MappingQGeneric<2, 3> mapping(6);
+    MappingQ<2, 3> mapping(6);
     for (auto &cell : triangulation.active_cell_iterators())
       {
         const Point<3> projected_point =
index f26e9468762bd597c5c486933aee753a8c8f44a9..d15105a04822318bcfbe576403660bab7e30573b 100644 (file)
@@ -100,7 +100,7 @@ test()
 
   // use an explicit Q1 mapping. this will yield a zero solution
   {
-    VectorTools::project(hp::MappingCollection<dim>(MappingQGeneric<dim>(1)),
+    VectorTools::project(hp::MappingCollection<dim>(MappingQ<dim>(1)),
                          dh,
                          cm,
                          hp::QCollection<dim>(QGauss<dim>(3)),
index 291689ca4ad40550b0dba61a94bc5e7b11aa406d..20a5e2d135f86afeac813f79344bec8917344b24 100644 (file)
@@ -83,11 +83,11 @@ transfer(std::ostream &out)
       fe_q.push_back(FE_Q<dim>(deg));
       fe_dgq.push_back(FE_DGQ<dim>(deg));
     }
-  DoFHandler<dim>      q_dof_handler(tria);
-  DoFHandler<dim>      dgq_dof_handler(tria);
-  Vector<double>       q_solution;
-  Vector<double>       dgq_solution;
-  MappingQGeneric<dim> mapping(1);
+  DoFHandler<dim> q_dof_handler(tria);
+  DoFHandler<dim> dgq_dof_handler(tria);
+  Vector<double>  q_solution;
+  Vector<double>  dgq_solution;
+  MappingQ<dim>   mapping(1);
 
   // refine a few cells
   typename Triangulation<dim>::active_cell_iterator cell = tria.begin_active(),
index 1cee10bf79d2210c01c6a3900dfb1fb27c1caab3..6f754bae53a27a18a6a33d4fde7bfefe99b573be 100644 (file)
@@ -85,9 +85,9 @@ transfer(std::ostream &out)
     {
       fe_q.push_back(FE_Q_Hierarchical<dim>(deg));
     }
-  DoFHandler<dim>      q_dof_handler(tria);
-  Vector<double>       q_solution;
-  MappingQGeneric<dim> mapping(1);
+  DoFHandler<dim> q_dof_handler(tria);
+  Vector<double>  q_solution;
+  MappingQ<dim>   mapping(1);
 
   // refine a few cells
   typename Triangulation<dim>::active_cell_iterator cell = tria.begin_active(),
index 28a9b12eae6118d50622e92d52e4d52a1c99c2a3..9d5188d8e43e27a262b7ba363918a98a55f35010 100644 (file)
@@ -439,7 +439,7 @@ private:
 
 template <int dim>
 DGMethod<dim>::DGMethod()
-  : mapping(MappingQGeneric<dim>(1))
+  : mapping(MappingQ<dim>(1))
   , fe(FE_DGQ<dim>(1))
   , dof_handler(triangulation)
   , quadrature(QGauss<dim>(4))
index db64acbbea9da9c20f03a24f779bd27413e4f374..9a9277087a9c38c07da05ea7844eb1d66372eef0 100644 (file)
@@ -27,7 +27,7 @@
 #include <deal.II/fe/fe_q.h>
 #include <deal.II/fe/fe_raviart_thomas.h>
 #include <deal.II/fe/fe_system.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/tria.h>
@@ -138,7 +138,7 @@ assemble_mg_matrix(DoFHandler<dim> &                   dof_handler,
 
   mg.set_zero();
 
-  MappingQGeneric<dim> mapping(1);
+  MappingQ<dim> mapping(1);
 
   MeshWorker::IntegrationInfoBox<dim> info_box;
   UpdateFlags update_flags = update_values | update_gradients | update_hessians;
index 8f6ae6d5ffaeb36d53316f89269468755971990d..5c408e6d368694f8cd32384f6bf4c8f115d9622b 100644 (file)
@@ -99,7 +99,7 @@ template <int dim>
 void
 test_cochain(const Triangulation<dim> &tr, const FiniteElement<dim> &fe)
 {
-  MappingQGeneric<dim> mapping(1);
+  MappingQ<dim> mapping(1);
   // Initialize DofHandler for a
   // block system with local blocks
   DoFHandler<dim> dof(tr);
index 47804d517e744efa733bb61a6d76399f336c3c37..ef44d9d0de7ec44a15d50a7e243314db82a2e3b1 100644 (file)
@@ -143,7 +143,7 @@ test_simple(DoFHandler<dim> &mgdofs)
   local.cells = true;
   local.faces = false;
 
-  MappingQGeneric<dim> mapping(1);
+  MappingQ<dim> mapping(1);
 
   MeshWorker::IntegrationInfoBox<dim> info_box;
   info_box.initialize_gauss_quadrature(1, 1, 1);
index 313071cda877b44b8cf5e771b4e70758b4d94367..f303d9561e4e94c2abf13933600445d9b09dcd5b 100644 (file)
@@ -155,7 +155,7 @@ void
 assemble(const DoFHandler<dim> &dof_handler, SparseMatrix<double> &matrix)
 {
   const FiniteElement<dim> &fe = dof_handler.get_fe();
-  MappingQGeneric<dim>      mapping(1);
+  MappingQ<dim>             mapping(1);
 
   MeshWorker::IntegrationInfoBox<dim> info_box;
   const unsigned int n_gauss_points = dof_handler.get_fe().tensor_degree() + 1;
@@ -195,7 +195,7 @@ assemble(const DoFHandler<dim> &             dof_handler,
          MGLevelObject<SparseMatrix<double>> dg_down)
 {
   const FiniteElement<dim> &fe = dof_handler.get_fe();
-  MappingQGeneric<dim>      mapping(1);
+  MappingQ<dim>             mapping(1);
 
   MeshWorker::IntegrationInfoBox<dim> info_box;
   const unsigned int n_gauss_points = dof_handler.get_fe().tensor_degree() + 1;
index 4c14dd6b23c1e893ba01cd71cb59b42477ac94cd..fa6a99cdf74353e1826480cd2dfff65cee673931 100644 (file)
@@ -154,7 +154,7 @@ void
 assemble(const DoFHandler<dim> &dof_handler, SparseMatrix<double> &matrix)
 {
   const FiniteElement<dim> &fe = dof_handler.get_fe();
-  MappingQGeneric<dim>      mapping(1);
+  MappingQ<dim>             mapping(1);
 
   MeshWorker::IntegrationInfoBox<dim> info_box;
   const unsigned int n_gauss_points = dof_handler.get_fe().tensor_degree() + 1;
@@ -194,7 +194,7 @@ assemble(const DoFHandler<dim> &             dof_handler,
          MGLevelObject<SparseMatrix<double>> dg_down)
 {
   const FiniteElement<dim> &fe = dof_handler.get_fe();
-  MappingQGeneric<dim>      mapping(1);
+  MappingQ<dim>             mapping(1);
 
   MeshWorker::IntegrationInfoBox<dim> info_box;
   const unsigned int n_gauss_points = dof_handler.get_fe().tensor_degree() + 1;
index 0fa41b758f5ed3c33f214aded2d79cbe2ccc2fe7..28711c552857a8afb8cd1286c39e5e32cc38496a 100644 (file)
@@ -64,7 +64,7 @@ namespace Advection
     run();
 
   private:
-    const MappingQGeneric<dim> mapping;
+    const MappingQ<dim> mapping;
 
     void
     setup_system();
index cc96ac569b75e2d4bdcff428e32df74ab197bbc9..c198c713da1bddb26772a7c599825fe7c611e381 100644 (file)
@@ -151,7 +151,7 @@ test_simple(DoFHandler<dim> &dofs, bool faces)
   local.cells = true;
   local.faces = faces;
 
-  MappingQGeneric<dim> mapping(1);
+  MappingQ<dim> mapping(1);
 
   MeshWorker::IntegrationInfoBox<dim> info_box;
   info_box.initialize_gauss_quadrature(1, 1, 1);
index 4052babc68490630f3a5680b0ffca3ab8d67263e..7035e38f7b8dd323bc60f3c7fbb0629eb5c853fa 100644 (file)
@@ -20,7 +20,7 @@
 
 #include <deal.II/fe/fe_q.h>
 #include <deal.II/fe/fe_system.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/tria.h>
@@ -52,9 +52,9 @@ main()
   GridGenerator::hyper_cube(triangulation);
   triangulation.refine_global(2);
 
-  MappingQGeneric<dim> mapping_q1(1);
-  FESystem<dim>        fe(FE_Q<dim>(2), 1, FE_Q<dim>(1), 1);
-  DoFHandler<dim>      dof_handler(triangulation);
+  MappingQ<dim>   mapping_q1(1);
+  FESystem<dim>   fe(FE_Q<dim>(2), 1, FE_Q<dim>(1), 1);
+  DoFHandler<dim> dof_handler(triangulation);
 
   dof_handler.distribute_dofs(fe);
 
index 4178eee0f373d4bbfe758ab7db50ceab8241ee19..f2f6daea2885143d879e9300fbd017e64b341d43 100644 (file)
@@ -20,7 +20,7 @@
 
 #include <deal.II/fe/fe_q.h>
 #include <deal.II/fe/fe_system.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/tria.h>
@@ -53,9 +53,9 @@ main()
   GridGenerator::hyper_cube(triangulation);
   triangulation.refine_global(2);
 
-  MappingQGeneric<dim> mapping_q1(1);
-  FESystem<dim>        fe(FE_Q<dim>(2), 1, FE_Q<dim>(1), 1, FE_Q<dim>(3), 1);
-  DoFHandler<dim>      dof_handler(triangulation);
+  MappingQ<dim>   mapping_q1(1);
+  FESystem<dim>   fe(FE_Q<dim>(2), 1, FE_Q<dim>(1), 1, FE_Q<dim>(3), 1);
+  DoFHandler<dim> dof_handler(triangulation);
 
   dof_handler.distribute_dofs(fe);
 
index bcfcbf34858e3b1ef5ab3b476e31547ac1a31a56..789e2c89749e64acd35b2bf6939a4bd7a8f1183f 100644 (file)
@@ -20,7 +20,7 @@
 
 #include <deal.II/fe/fe_q.h>
 #include <deal.II/fe/fe_system.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/tria.h>
@@ -52,9 +52,9 @@ main()
   GridGenerator::hyper_cube(triangulation);
   triangulation.refine_global(2);
 
-  MappingQGeneric<dim> mapping_q1(1);
-  FESystem<dim>        fe(FE_Q<dim>(2), 1, FE_Q<dim>(1), 1);
-  DoFHandler<dim>      dof_handler(triangulation);
+  MappingQ<dim>   mapping_q1(1);
+  FESystem<dim>   fe(FE_Q<dim>(2), 1, FE_Q<dim>(1), 1);
+  DoFHandler<dim> dof_handler(triangulation);
 
   dof_handler.distribute_dofs(fe);
 
index ca30e689ba1ac358c2a857541b055a5b6c5d67df..674bc99694f7c2b42226df31755012bf3bea1fbd 100644 (file)
@@ -53,9 +53,9 @@ main()
   GridGenerator::hyper_cube(triangulation);
   triangulation.refine_global(2);
 
-  MappingQGeneric<dim> mapping_q1(1);
-  FE_Q<dim>            q1(1);
-  DoFHandler<dim>      dof_handler(triangulation);
+  MappingQ<dim>   mapping_q1(1);
+  FE_Q<dim>       q1(1);
+  DoFHandler<dim> dof_handler(triangulation);
   dof_handler.distribute_dofs(q1);
 
   DynamicSparsityPattern dsp(dof_handler.n_dofs(), dof_handler.n_dofs());
index 4e082de1d1fa0141f34716292dbbcf966455933a..afddb53aed90ce73bf7ae84fce9ceb39bcb6805b 100644 (file)
@@ -57,9 +57,9 @@ main()
   GridGenerator::hyper_cube(triangulation);
   triangulation.refine_global(2);
 
-  MappingQGeneric<dim> mapping_q1(1);
-  FE_Q<dim>            q1(1);
-  DoFHandler<dim>      dof_handler(triangulation);
+  MappingQ<dim>   mapping_q1(1);
+  FE_Q<dim>       q1(1);
+  DoFHandler<dim> dof_handler(triangulation);
   dof_handler.distribute_dofs(q1);
 
   DynamicSparsityPattern dsp(dof_handler.n_dofs(), dof_handler.n_dofs());
index b5ccb7ec5f4816aeb2f3390c8030169fe9f12c04..46cb8e9024d72dca7dad5dc767fa2004ff7be5ba 100644 (file)
@@ -61,9 +61,9 @@ main()
   GridGenerator::hyper_cube(triangulation);
   triangulation.refine_global(2);
 
-  MappingQGeneric<dim> mapping_q1(1);
-  FESystem<dim>        fe(FE_Q<dim>(1), 1, FE_Q<dim>(1), 1);
-  DoFHandler<dim>      dof_handler(triangulation);
+  MappingQ<dim>   mapping_q1(1);
+  FESystem<dim>   fe(FE_Q<dim>(1), 1, FE_Q<dim>(1), 1);
+  DoFHandler<dim> dof_handler(triangulation);
 
   dof_handler.distribute_dofs(fe);
 
index 9a1b7c1ff0305a69c723c18f64872a12667f9827..077c8c0160c3d7e515f770f8a4f592ec73689cb8 100644 (file)
@@ -73,9 +73,9 @@ main()
   GridGenerator::hyper_cube(triangulation);
   triangulation.refine_global(2);
 
-  MappingQGeneric<dim> mapping_q1(1);
-  FE_Q<dim>            q1(1);
-  DoFHandler<dim>      dof_handler(triangulation);
+  MappingQ<dim>   mapping_q1(1);
+  FE_Q<dim>       q1(1);
+  DoFHandler<dim> dof_handler(triangulation);
   dof_handler.distribute_dofs(q1);
 
   DynamicSparsityPattern dsp(dof_handler.n_dofs(), dof_handler.n_dofs());
index 5e5d2804fa4c8c8e6e935f7780b4e23aa7ddbf10..5478f75ae862eff0cc9eb7699e28ab96fc8a6858 100644 (file)
@@ -18,7 +18,7 @@
 #include <deal.II/base/utilities.h>
 
 #include <deal.II/fe/fe_values.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/manifold_lib.h>
index 970e9bf934edef1234824652570542104f99166d..bc6db06285b15d240971b7ba21f11a7e993754bb 100644 (file)
@@ -21,7 +21,7 @@
 
 #include <deal.II/fe/fe_nothing.h>
 #include <deal.II/fe/fe_values.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/manifold_lib.h>
@@ -44,7 +44,7 @@ main()
   tria.set_all_manifold_ids(0);
   tria.set_manifold(0, spherical);
 
-  MappingQGeneric<dim>   mapping(4);
+  MappingQ<dim>          mapping(4);
   QGaussLobatto<dim - 1> quadrature(4);
 
   FE_Nothing<dim>   dummy;
index cd68af390d5a3c0419193d181c1e70345383ee92..5f016504c83377beb08c22bfcf72cd4aa6f8d721 100644 (file)
@@ -21,7 +21,7 @@
 
 #include <deal.II/fe/fe_nothing.h>
 #include <deal.II/fe/fe_values.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/manifold_lib.h>
@@ -48,7 +48,7 @@ main()
 
   tria.refine_global(1);
 
-  MappingQGeneric<dim>   mapping(4);
+  MappingQ<dim>          mapping(4);
   QGaussLobatto<dim - 1> quadrature(4);
   FE_Nothing<dim>        dummy;
   FEFaceValues<dim>      fe_values(mapping,
index 68a1d240a569b5edcd2ff6e9ef303601594ae471..e4663e00b47877fd940f5fd2bd5e975b889138a1 100644 (file)
 // ---------------------------------------------------------------------
 
 
-// Similar to transfinite_manifold_01 but now applying a MappingQGeneric and
+// Similar to transfinite_manifold_01 but now applying a MappingQ and
 // computing some areas
 
 #include <deal.II/base/quadrature_lib.h>
 
 #include <deal.II/fe/fe_nothing.h>
 #include <deal.II/fe/fe_values.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/grid_out.h>
@@ -38,9 +38,9 @@ do_test(const Triangulation<dim, spacedim> &tria)
 {
   for (unsigned int degree = 1; degree < 5; ++degree)
     {
-      MappingQGeneric<dim, spacedim> mapping(degree);
-      FE_Nothing<dim, spacedim>      fe;
-      QGauss<dim>                    gauss(degree + 1);
+      MappingQ<dim, spacedim>   mapping(degree);
+      FE_Nothing<dim, spacedim> fe;
+      QGauss<dim>               gauss(degree + 1);
       FEValues<dim, spacedim> fe_values(mapping, fe, gauss, update_JxW_values);
       double                  volume = 0;
       for (typename Triangulation<dim, spacedim>::cell_iterator cell =
index 9fabd7ce821a29765efc50fcd959daef42b2671a..5ce2e4301528de83706670b07d30bc8e7e668cef 100644 (file)
@@ -435,7 +435,7 @@ mapping_test()
   std::vector<std::string>    mapping_strings;
 
   MappingCartesian<dim> cart;
-  MappingQGeneric<dim>  q1_old(1);
+  MappingQ<dim>         q1_old(1);
   MappingQ<dim>         q1tmp(1);
   MappingQ<dim>         q2tmp(2);
   MappingQ<dim>         q3tmp(3);
index 497bf71777741cf6c1e433e0a7371c50eae65b4e..4824d5bb65f8fb0f2a612689875dc0464bbcc833 100644 (file)
@@ -69,8 +69,8 @@ test()
   transfer.build(dh);
   transfer.interpolate_to_mg(dh, level_vectors, map_vector);
   MappingFEField<dim, spacedim, LinearAlgebra::distributed::Vector<double>>
-                       mapping(dh, level_vectors);
-  MappingQGeneric<dim> mapping_ref(fe.degree);
+                mapping(dh, level_vectors);
+  MappingQ<dim> mapping_ref(fe.degree);
 
   QGauss<dim>   quad(1);
   FEValues<dim> fe_values_ref(mapping_ref,
index a4df982c76dc3086a356d9369bcc0ce051730267..23a4405395956c90ee264d927e9b0ec0b3e96b88 100644 (file)
@@ -30,7 +30,7 @@
 #include <deal.II/fe/fe_system.h>
 #include <deal.II/fe/fe_values.h>
 #include <deal.II/fe/mapping_fe_field.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 
@@ -67,8 +67,8 @@ test()
   // Create a Mapping
   std::vector<LinearAlgebra::distributed::Vector<double>> level_vectors(
     tria.n_global_levels());
-  MappingQGeneric<dim, spacedim> mapping_ref(fe.degree);
-  FEValues<dim>                  fe_values_setup(mapping_ref,
+  MappingQ<dim, spacedim> mapping_ref(fe.degree);
+  FEValues<dim>           fe_values_setup(mapping_ref,
                                 dh.get_fe(),
                                 Quadrature<dim>(
                                   dh.get_fe().get_unit_support_points()),
index 71bc4aa9171e4323481b8f6a6c84388d70fd33fd..344b3631b36fc095d19ac4f3ee9cc38cdcc09673 100644 (file)
@@ -13,7 +13,7 @@
 //
 // ---------------------------------------------------------------------
 
-// check that MappingFEField is equivalent to MappingQGeneric on a curved
+// check that MappingFEField is equivalent to MappingQ on a curved
 // shell mesh
 
 #include <deal.II/base/geometry_info.h>
@@ -25,7 +25,7 @@
 #include <deal.II/fe/fe_system.h>
 #include <deal.II/fe/fe_values.h>
 #include <deal.II/fe/mapping_fe_field.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 
@@ -55,7 +55,7 @@ test()
   Vector<double> map_vector(dh.n_dofs());
   VectorTools::get_position_vector(dh, map_vector);
   MappingFEField<dim, spacedim, Vector<double>> mapping(dh, map_vector);
-  MappingQGeneric<dim>                          mapping_ref(fe.degree);
+  MappingQ<dim>                                 mapping_ref(fe.degree);
 
   QGauss<dim>   quad(1);
   FEValues<dim> fe_values_ref(mapping_ref, fe, quad, update_quadrature_points);
index ed50caefd097cfe08bc401861c0c579a79c864cc..6d305d17b8e7703248701d2a4e72cce716416ee1 100644 (file)
@@ -23,7 +23,6 @@
 #include <deal.II/fe/fe_system.h>
 #include <deal.II/fe/mapping_fe_field.h>
 #include <deal.II/fe/mapping_q.h>
-#include <deal.II/fe/mapping_q_generic.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/grid_tools.h>
@@ -169,8 +168,8 @@ test(unsigned int n_ref)
   Triangulation<dim, spacedim> tria;
   GridGenerator::hyper_shell(tria, Point<dim>(), 0.8, 1., dim == 2 ? 3 : 6);
   tria.refine_global(n_ref);
-  const unsigned int             fe_degree = dim == 2 ? 8 : 4;
-  MappingQGeneric<dim, spacedim> mapping_q(fe_degree);
+  const unsigned int      fe_degree = dim == 2 ? 8 : 4;
+  MappingQ<dim, spacedim> mapping_q(fe_degree);
 
   FE_Q<dim>               fe_q(fe_degree);
   FESystem<dim, dim>      fe_system(fe_q, dim);
@@ -184,8 +183,8 @@ test(unsigned int n_ref)
   VectorTools::get_position_vector(dofh, nodes, mask);
   MappingFEField<dim, dim, Vector<double>> mapping(dofh, nodes, mask);
 
-  deallog << "Test with MappingQGeneric in " << dim << "D on "
-          << tria.n_active_cells() << " cells:" << std::endl;
+  deallog << "Test with MappingQ in " << dim << "D on " << tria.n_active_cells()
+          << " cells:" << std::endl;
   do_test(mapping_q, tria);
   deallog << std::endl;
   deallog << "Test with MappingFEField in " << dim << "D on "
index 80ba511cb61b10c913fb8e1d04f07a05bf346c0e..28b7c7d0658807c5748f8969b8fd57b08242e5f2 100644 (file)
@@ -1,5 +1,5 @@
 
-DEAL::Test with MappingQGeneric in 2D on 12 cells:
+DEAL::Test with MappingQ in 2D on 12 cells:
 DEAL::Testing 2D with point 0.8000000000 0.000000000 tolerance 1.000000000e-08
 DEAL::Cell: 0_1:2 unit point 2.615834610e-20 1.000000000
 DEAL::Cell: 2_1:3 unit point 1.000000000 1.000000000
@@ -203,7 +203,7 @@ DEAL::Testing 2D with point -0.7071067812 0.7071067812 tolerance 1.000000000e-08
 DEAL::Cell: 1_1:0 unit point 0.2500000000 9.777199125e-11
 DEAL::
 DEAL::
-DEAL::Test with MappingQGeneric in 2D on 48 cells:
+DEAL::Test with MappingQ in 2D on 48 cells:
 DEAL::Testing 2D with point 0.8000000000 0.000000000 tolerance 1.000000000e-08
 DEAL::Cell: 0_2:22 unit point -5.001540069e-12 1.000000000
 DEAL::Cell: 2_2:33 unit point 1.000000000 1.000000000
@@ -455,7 +455,7 @@ DEAL::Testing 2D with point -0.7071067812 0.7071067812 tolerance 1.000000000e-08
 DEAL::Cell: 1_2:00 unit point 0.5000000000 0.000000000
 DEAL::
 DEAL::
-DEAL::Test with MappingQGeneric in 3D on 48 cells:
+DEAL::Test with MappingQ in 3D on 48 cells:
 DEAL::Testing 3D with point 0.8000000000 0.000000000 4.898587197e-17 tolerance 1.000000000e-08
 DEAL::Cell: 1_1:2 unit point 1.000000000 1.000000000 1.000000000
 DEAL::Cell: 1_1:3 unit point 8.316724501e-17 1.000000000 1.000000000
@@ -943,7 +943,7 @@ DEAL::Testing 3D with point 0.05868060999 0.08076693067 0.9950041653 tolerance 1
 DEAL::Cell: 2_1:5 unit point 0.07446169019 3.662117048e-05 0.1025974553
 DEAL::
 DEAL::
-DEAL::Test with MappingQGeneric in 3D on 384 cells:
+DEAL::Test with MappingQ in 3D on 384 cells:
 DEAL::Testing 3D with point 0.8000000000 0.000000000 4.898587197e-17 tolerance 1.000000000e-08
 DEAL::Cell: 1_2:27 unit point 1.000000000 1.000000000 1.000000000
 DEAL::Cell: 1_2:36 unit point -8.454658402e-13 1.000000000 1.000000000
index 99c2589e859def99a6c5118296d3a5dfde246110..bb06a87a444cdbe4b4cd973fbd68eeff34949cd9 100644 (file)
@@ -19,7 +19,6 @@
 #include <deal.II/base/utilities.h>
 
 #include <deal.II/fe/mapping_q.h>
-#include <deal.II/fe/mapping_q_generic.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/grid_tools_cache.h>
@@ -73,8 +72,8 @@ main()
     test_bounding_boxes(mapping, degree);
   }
   {
-    unsigned int       degree = 2;
-    MappingQGeneric<2> mapping(degree);
+    unsigned int degree = 2;
+    MappingQ<2>  mapping(degree);
     test_bounding_boxes(mapping, degree);
   }
 }
index 6ceb716d34c6b16799f7d14a7a49c866a821c28a..331ea104d42870234702964eaa68b819c5398e79 100644 (file)
@@ -38,7 +38,7 @@ CELL_TYPES 5
  9 9 9 9 9
 POINT_DATA 20
 
-DEAL::Testing dealii::MappingQGeneric<2, 2>(2)
+DEAL::Testing dealii::MappingQ<2, 2>(2)
 # vtk DataFile Version 3.0
 #This file was generated by the deal.II library.
 ASCII
index 23efdc79db73d20d76f29b33795c9e6d18c17c1e..638c272a06a31973be1a4de0236c4c6fff3bed8c 100644 (file)
@@ -19,7 +19,7 @@
 #include <deal.II/base/utilities.h>
 
 #include <deal.II/fe/mapping_manifold.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/manifold_lib.h>
@@ -43,7 +43,7 @@ test()
   std::vector<Point<dim>> q_points = quadrature.get_points();
 
   MappingManifold<dim, spacedim> map_manifold;
-  MappingQGeneric<dim, spacedim> map_q1(1);
+  MappingQ<dim, spacedim>        map_q1(1);
 
   typename Triangulation<dim, spacedim>::active_cell_iterator
     cell = triangulation.begin_active(),
index 910d9d2d24b8fd28c600d55c8faf710ec27b2e85..d3c5bae6250c773ec86c392a51903571a465207d 100644 (file)
@@ -25,7 +25,7 @@
 #include <deal.II/fe/fe_q.h>
 #include <deal.II/fe/fe_values.h>
 #include <deal.II/fe/mapping_manifold.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/manifold_lib.h>
index 6017b172aa5c00442a5669a5d66ebd744bb81c8b..1c4a5b2c4bd8c9957ca4c5dc3722fef6d5e5b47b 100644 (file)
@@ -24,7 +24,7 @@
 #include <deal.II/fe/fe_q.h>
 #include <deal.II/fe/fe_values.h>
 #include <deal.II/fe/mapping_manifold.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/manifold_lib.h>
@@ -50,7 +50,7 @@ test()
   dof.distribute_dofs(fe);
 
   MappingManifold<dim, spacedim> mapping_manifold;
-  MappingQGeneric<dim, spacedim> mapping_q(1);
+  MappingQ<dim, spacedim>        mapping_q(1);
 
   FEValues<dim, spacedim> fe_values_mapping(mapping_manifold,
                                             fe,
index 18a64e5aad7c527ac0aee9bf6b736e699688c8bf..65183374806cfe7beb0b6147deb0000adff426ce 100644 (file)
@@ -25,7 +25,7 @@
 #include <deal.II/fe/fe_q.h>
 #include <deal.II/fe/fe_values.h>
 #include <deal.II/fe/mapping_manifold.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/manifold_lib.h>
@@ -56,7 +56,7 @@ test()
   dof.distribute_dofs(fe);
 
   MappingManifold<dim, spacedim> mapping_manifold;
-  MappingQGeneric<dim, spacedim> mapping_q(1);
+  MappingQ<dim, spacedim>        mapping_q(1);
 
   FEValues<dim, spacedim> fe_values_mapping(mapping_manifold,
                                             fe,
index 16ba7ddb2593530eca52238c48451a95b4700937..631e06369a8b8f67af3b7ffcc76d2eced573f02d 100644 (file)
@@ -26,7 +26,7 @@
 #include <deal.II/fe/fe_q.h>
 #include <deal.II/fe/fe_values.h>
 #include <deal.II/fe/mapping_manifold.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/manifold_lib.h>
@@ -58,7 +58,7 @@ test()
   dof.distribute_dofs(fe);
 
   MappingManifold<dim, spacedim> mapping_manifold;
-  MappingQGeneric<dim, spacedim> mapping_q(1);
+  MappingQ<dim, spacedim>        mapping_q(1);
 
   FEFaceValues<dim, spacedim> fe_values_mapping(mapping_manifold,
                                                 fe,
index d5ca36ace7f6f7315c2527ee9014a93b6cd92203..e5b5e633aa2cad63cfdaf13977fb5a6d8387e892 100644 (file)
@@ -22,7 +22,7 @@
 #include <deal.II/fe/fe_q.h>
 #include <deal.II/fe/fe_values.h>
 #include <deal.II/fe/mapping_manifold.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/manifold_lib.h>
index 9abb35bd7b5ada768efedd9afe8082a0544940b9..5fd369b90a1260bbd24dcf5727e22b3b33aaf69f 100644 (file)
@@ -20,7 +20,7 @@
 #include <deal.II/fe/fe_q.h>
 #include <deal.II/fe/fe_values.h>
 #include <deal.II/fe/mapping_manifold.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/manifold_lib.h>
index 19ca12142d73054eb27efc15146a58221c3b58ee..8e7028adc5da1bec9e088feb40464851cc024632 100644 (file)
@@ -17,7 +17,7 @@
 
 // on a test case similar to mapping_real_to_unit_q4_curved, check the
 // implementation of the many-point interface
-// Mapping::transform_points_real_to_unit_cell for both a MappingQGeneric and
+// Mapping::transform_points_real_to_unit_cell for both a MappingQ and
 // MappingFEField
 
 #include <deal.II/base/utilities.h>
@@ -27,7 +27,7 @@
 #include <deal.II/fe/fe_q.h>
 #include <deal.II/fe/fe_system.h>
 #include <deal.II/fe/mapping_fe_field.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/manifold_lib.h>
@@ -114,9 +114,9 @@ test()
 {
   deallog << "dim=" << dim << ", spacedim=" << spacedim << std::endl;
   deallog << "MappingQ(1): ";
-  test_real_to_unit_cell(MappingQGeneric<dim, spacedim>(1));
+  test_real_to_unit_cell(MappingQ<dim, spacedim>(1));
   deallog << "MappingQ(4): ";
-  test_real_to_unit_cell(MappingQGeneric<dim, spacedim>(4));
+  test_real_to_unit_cell(MappingQ<dim, spacedim>(4));
 
   deallog << "MappingFEField(FESystem(FE_Q(4))): ";
   Triangulation<dim, spacedim> triangulation;
index 099de19eff35d86120c0d493de0b3d1304db3c60..3a48c08be6dbd80c149ff9bf6ea8555bef98f24d 100644 (file)
@@ -38,7 +38,7 @@ dim2_grid()
 
   const Point<2> testp(.5, -.5); // test point
 
-  MappingQGeneric<2> mapping(1);
+  MappingQ<2> mapping(1);
 
   deallog << "Check project for 2D cube from (-1,-1), to (1,1)." << std::endl;
 
@@ -68,7 +68,7 @@ dim3_grid()
 
   const Point<3> testp(.5, -.5, 0); // test point
 
-  MappingQGeneric<3> mapping(1);
+  MappingQ<3> mapping(1);
 
   deallog << "Check project for 3D cube from (-1,-1,-1) to (1,1,1)."
           << std::endl;
@@ -102,7 +102,7 @@ dim3_parallelepiped_grid()
 
   const Point<3> testp(1, 1, 1); // test point
 
-  MappingQGeneric<3> mapping(1);
+  MappingQ<3> mapping(1);
 
   deallog
     << "Check project for 3D parallelepiped with vectors (2, 0, 0), (0, 2, 0), and (0, 1, 2)."
index 306def294c150f923ca400efb0cff01f931f682f..a03f82dfacb0f085b5776e349d84ec7cc95f9afb 100644 (file)
@@ -112,8 +112,8 @@ private:
   void
   test_mapping()
   {
-    const double               tol = 1e-8;
-    const MappingQGeneric<dim> mapping(1);
+    const double        tol = 1e-8;
+    const MappingQ<dim> mapping(1);
 
     deallog << "Number of active cells: " << triangulation.n_active_cells()
             << std::endl;
index ca819925190e584f63aa54b13554561f9970fab6..ded54487d0bc0693d8327df26a931cda234c62f4 100644 (file)
 //
 // ---------------------------------------------------------------------
 
-// Test MappingQCache by comparison with MappingQGeneric
+// Test MappingQCache by comparison with MappingQ
 
+#include <deal.II/fe/mapping_q.h>
 #include <deal.II/fe/mapping_q_cache.h>
-#include <deal.II/fe/mapping_q_generic.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/tria.h>
@@ -33,8 +33,8 @@ do_test(const unsigned int degree)
   else
     GridGenerator::hyper_cube(tria, -1, 1);
 
-  MappingQGeneric<dim> mapping(degree);
-  MappingQCache<dim>   mapping_cache(degree);
+  MappingQ<dim>      mapping(degree);
+  MappingQCache<dim> mapping_cache(degree);
   mapping_cache.initialize(tria, mapping);
 
   Point<dim> p1;
index 95117f7b46f19b76cee52a361905fea01b50e8e4..533fe609f481ee774732ea83804fdcc21747bc26 100644 (file)
 //
 // ---------------------------------------------------------------------
 
-// Test MappingQCache by comparison with MappingQGeneric in parallel
+// Test MappingQCache by comparison with MappingQ in parallel
 
 #include <deal.II/base/mpi.h>
 
 #include <deal.II/distributed/tria.h>
 
+#include <deal.II/fe/mapping_q.h>
 #include <deal.II/fe/mapping_q_cache.h>
-#include <deal.II/fe/mapping_q_generic.h>
 
 #include <deal.II/grid/grid_generator.h>
 
@@ -38,8 +38,8 @@ do_test(const unsigned int degree)
 
   tria.refine_global(1);
 
-  MappingQGeneric<dim> mapping(degree);
-  MappingQCache<dim>   mapping_cache(degree);
+  MappingQ<dim>      mapping(degree);
+  MappingQCache<dim> mapping_cache(degree);
   mapping_cache.initialize(tria, mapping);
 
   Point<dim> p1;
index fd37639a66e3e8026a2ea886ffdb41cbfd9a6166..19a274afece9ffc191a54405c6041e506664ee85 100644 (file)
 //
 // ---------------------------------------------------------------------
 
-// Test MappingQCache by comparison with MappingQGeneric for the case when we
+// Test MappingQCache by comparison with MappingQ for the case when we
 // change the mesh
 
+#include <deal.II/fe/mapping_q.h>
 #include <deal.II/fe/mapping_q_cache.h>
-#include <deal.II/fe/mapping_q_generic.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/tria.h>
@@ -34,8 +34,8 @@ do_test(const unsigned int degree)
   else
     GridGenerator::hyper_cube(tria, -1, 1);
 
-  MappingQGeneric<dim> mapping(degree);
-  MappingQCache<dim>   mapping_cache(degree);
+  MappingQ<dim>      mapping(degree);
+  MappingQCache<dim> mapping_cache(degree);
   mapping_cache.initialize(tria, mapping);
 
   Point<dim> p1;
index 753e8d9b60432aa34d0affec53777e1d064e5b9d..2caf2b20fbaf753372f9954258cdf245f404a1ff 100644 (file)
@@ -18,8 +18,8 @@
 #include <deal.II/fe/fe_nothing.h>
 #include <deal.II/fe/fe_q.h>
 #include <deal.II/fe/fe_values.h>
+#include <deal.II/fe/mapping_q.h>
 #include <deal.II/fe/mapping_q_cache.h>
-#include <deal.II/fe/mapping_q_generic.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/tria.h>
@@ -36,9 +36,9 @@ do_test(const unsigned int degree)
   else
     GridGenerator::hyper_cube(tria, -1, 1);
 
-  MappingQGeneric<dim> mapping(degree);
-  MappingQCache<dim>   mapping_cache(degree);
-  Point<dim>           shift;
+  MappingQ<dim>      mapping(degree);
+  MappingQCache<dim> mapping_cache(degree);
+  Point<dim>         shift;
   for (unsigned int d = 0; d < dim; ++d)
     shift[d] = -0.5 + 0.1 * d;
 
index a45edce896243b1f6f55ccd64c277b8e370c7347..0eb07076900956ccbd4cd77f64f98c53f758acaa 100644 (file)
@@ -18,8 +18,8 @@
 #include <deal.II/fe/fe_nothing.h>
 #include <deal.II/fe/fe_q.h>
 #include <deal.II/fe/fe_values.h>
+#include <deal.II/fe/mapping_q.h>
 #include <deal.II/fe/mapping_q_cache.h>
-#include <deal.II/fe/mapping_q_generic.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/tria.h>
@@ -59,8 +59,8 @@ do_test(const unsigned int degree,
   Triangulation<dim> tria;
   GridGenerator::subdivided_hyper_cube(tria, 4);
 
-  MappingQGeneric<dim> mapping(degree);
-  MappingQCache<dim>   mapping_cache(degree);
+  MappingQ<dim>      mapping(degree);
+  MappingQCache<dim> mapping_cache(degree);
   mapping_cache.initialize(mapping, tria, fu, is_displacement_function);
 
   {
index 9487ce0e2b2a03eb29086a7743d30120ce8c55de..35a0f8b5859c24fba89822a3013dab589e58bea1 100644 (file)
@@ -21,8 +21,8 @@
 #include <deal.II/fe/fe_q.h>
 #include <deal.II/fe/fe_system.h>
 #include <deal.II/fe/fe_values.h>
+#include <deal.II/fe/mapping_q.h>
 #include <deal.II/fe/mapping_q_cache.h>
-#include <deal.II/fe/mapping_q_generic.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/tria.h>
@@ -86,8 +86,8 @@ do_test(const unsigned int degree,
   VectorTools::interpolate(dof_handler, fu, vector);
 
   {
-    MappingQGeneric<dim> mapping(mapping_degree);
-    MappingQCache<dim>   mapping_cache(mapping_degree);
+    MappingQ<dim>      mapping(mapping_degree);
+    MappingQCache<dim> mapping_cache(mapping_degree);
     mapping_cache.initialize(mapping,
                              dof_handler,
                              vector,
@@ -120,8 +120,8 @@ do_test(const unsigned int degree,
     transfer.build(dof_handler);
     transfer.interpolate_to_mg(dof_handler, vectors, vector);
 
-    MappingQGeneric<dim> mapping(mapping_degree);
-    MappingQCache<dim>   mapping_cache(mapping_degree);
+    MappingQ<dim>      mapping(mapping_degree);
+    MappingQCache<dim> mapping_cache(mapping_degree);
     mapping_cache.initialize(mapping,
                              dof_handler,
                              vectors,
index 79ea3b3b5b78f2da213605d208bfe6b4f1a4191b..880c68ac368a2278344689ead5a36fe2b31ce17c 100644 (file)
@@ -20,8 +20,8 @@
 #include <deal.II/fe/fe_system.h>
 #include <deal.II/fe/fe_values.h>
 #include <deal.II/fe/mapping_fe_field.h>
+#include <deal.II/fe/mapping_q.h>
 #include <deal.II/fe/mapping_q_cache.h>
-#include <deal.II/fe/mapping_q_generic.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/tria.h>
index 43a564eade7431fbb4cc26be8d471178d97d4338..34ac00625187778134e99cfc534960b32a7a49a7 100644 (file)
@@ -18,8 +18,8 @@
 #include <deal.II/fe/fe_nothing.h>
 #include <deal.II/fe/fe_q.h>
 #include <deal.II/fe/fe_values.h>
+#include <deal.II/fe/mapping_q.h>
 #include <deal.II/fe/mapping_q_cache.h>
-#include <deal.II/fe/mapping_q_generic.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/tria.h>
@@ -36,9 +36,9 @@ do_test(const unsigned int degree)
   else
     GridGenerator::hyper_cube(tria, -1, 1);
 
-  MappingQGeneric<dim> mapping(degree);
-  MappingQCache<dim>   mapping_cache(degree);
-  Point<dim>           shift;
+  MappingQ<dim>      mapping(degree);
+  MappingQCache<dim> mapping_cache(degree);
+  Point<dim>         shift;
   for (unsigned int d = 0; d < dim; ++d)
     shift[d] = -0.5 + 0.1 * d;
 
index b2644ead7ebe1d062fcb3d2556e59a45853a5230..9e428ea537d9743e49ebf5a36d3d4d121c934055 100644 (file)
@@ -173,7 +173,7 @@ MappingTest<dim>::run_test()
       dof_handler.distribute_dofs(fe);
       displacements.reinit(dof_handler.n_dofs());
 
-      VectorTools::interpolate(MappingQGeneric<dim>(1),
+      VectorTools::interpolate(MappingQ<dim>(1),
                                dof_handler,
                                imposed_displacement,
                                displacements);
@@ -244,7 +244,7 @@ MappingTest<dim>::graphical_output()
   dof_handler.distribute_dofs(fe);
   displacements.reinit(dof_handler.n_dofs());
 
-  VectorTools::interpolate(MappingQGeneric<dim>(1),
+  VectorTools::interpolate(MappingQ<dim>(1),
                            dof_handler,
                            imposed_displacement,
                            displacements);
index 411db4c8f7298a68887e34404e00ece89b5e2fd0..381431862bd99e111177ba2d775d4a406b2eaacd 100644 (file)
@@ -15,7 +15,7 @@
 
 
 // Check InverseQuadraticApproximation used for the initial guess in
-// MappingQGeneric::transform_points_real_to_unit_cell
+// MappingQ::transform_points_real_to_unit_cell
 
 #include <deal.II/base/logstream.h>
 #include <deal.II/base/polynomial.h>
@@ -27,7 +27,6 @@
 #include <deal.II/fe/fe_tools.h>
 #include <deal.II/fe/mapping_fe_field.h>
 #include <deal.II/fe/mapping_q.h>
-#include <deal.II/fe/mapping_q_generic.h>
 #include <deal.II/fe/mapping_q_internal.h>
 
 #include <deal.II/grid/grid_generator.h>
@@ -47,8 +46,8 @@ print_result(const unsigned int                  mapping_degree,
 {
   deallog << "Testing " << dim << "D with point " << p << std::endl;
 
-  FE_Q<dim>            dummy(mapping_degree);
-  MappingQGeneric<dim> mapping(mapping_degree);
+  FE_Q<dim>     dummy(mapping_degree);
+  MappingQ<dim> mapping(mapping_degree);
 
   FEValues<dim> fe_values(mapping,
                           dummy,
@@ -60,8 +59,8 @@ print_result(const unsigned int                  mapping_degree,
   std::vector<unsigned int> renumber =
     FETools::lexicographic_to_hierarchic_numbering<dim>(mapping_degree);
   std::vector<Point<dim>> mapping_unit_support_points =
-    internal::MappingQGenericImplementation::unit_support_points<dim>(
-      mapping_points, renumber);
+    internal::MappingQImplementation::unit_support_points<dim>(mapping_points,
+                                                               renumber);
 
   for (const auto &cell : tria.active_cell_iterators())
     {
@@ -76,7 +75,7 @@ print_result(const unsigned int                  mapping_degree,
           deallog << "Affine approximation:            "
                   << cell->real_to_unit_cell_affine_approximation(p)
                   << std::endl;
-          internal::MappingQGenericImplementation::
+          internal::MappingQImplementation::
             InverseQuadraticApproximation<dim, spacedim>
               approx(fe_values.get_quadrature_points(),
                      mapping_unit_support_points);
index 4e1cbef552ea0902f47123ae0f1cbd282c9559bc..139c50040834553267392f81c227bae067a283d3 100644 (file)
@@ -23,7 +23,7 @@
 
 #include <deal.II/fe/fe_nothing.h>
 #include <deal.II/fe/fe_values.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/grid_tools.h>
@@ -84,7 +84,7 @@ test()
   FE_Nothing<dim> fe;
   for (unsigned int degree = 6; degree < 7; ++degree)
     {
-      MappingQGeneric<dim> mapping(degree);
+      MappingQ<dim> mapping(degree);
 
       QGauss<dim>   quad(degree + 1);
       FEValues<dim> fe_values(mapping, fe, quad, update_JxW_values);
index f9770fe5e7abd71194a89f2a7bd86a0b5bb1b007..246e52cc20f1722f42e340fa02fd854248794b43 100644 (file)
@@ -25,7 +25,7 @@
 
 #include <deal.II/fe/fe_nothing.h>
 #include <deal.II/fe/fe_values.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/manifold_lib.h>
@@ -224,10 +224,10 @@ test()
   FE_Nothing<dim> fe;
   for (unsigned int degree = 1; degree < 7; ++degree)
     {
-      MappingQGeneric<dim> mapping(degree);
-      QGauss<dim>          quad(degree + 1);
-      FEValues<dim>        fe_values(mapping, fe, quad, update_JxW_values);
-      double               sum = 0.;
+      MappingQ<dim> mapping(degree);
+      QGauss<dim>   quad(degree + 1);
+      FEValues<dim> fe_values(mapping, fe, quad, update_JxW_values);
+      double        sum = 0.;
       for (typename Triangulation<dim>::active_cell_iterator cell =
              tria.begin_active();
            cell != tria.end();
index cf747e3de9264b38d0801ec54fa9fc70227a90e5..b1c6749e66824ce79d9705b140258d8b6cc86df7 100644 (file)
 // ---------------------------------------------------------------------
 
 
-// check MappingQGeneric::transform_real_to_unit_points on a set of
+// check MappingQ::transform_real_to_unit_points on a set of
 // challenging points, especially with vectorization because we have nearby
 // points that succeed and others in the regime of negative Jacobian
 // determinants, respectively
 
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/tria.h>
@@ -42,7 +42,7 @@ test(const unsigned int degree)
     real_points.push_back(
       (i % 2 ? 0.05 * (static_cast<double>(i) - 10.) : 0.05 * i) * p);
   std::vector<Point<dim>> unit_points(real_points.size());
-  MappingQGeneric<dim>    mapping(degree);
+  MappingQ<dim>           mapping(degree);
   mapping.transform_points_real_to_unit_cell(tria.begin(),
                                              real_points,
                                              unit_points);
index 1f4a9c1dd04bc407daf64363a3d70ffce03b9bf6..f36aeabb599281b371c68ea606587a72e9b28f7e 100644 (file)
 // ---------------------------------------------------------------------
 
 
-// Show positions of quadrature points with various degrees of MappingQGeneric
+// Show positions of quadrature points with various degrees of MappingQ
 // and quadrature formulas, including the collocation case where quadrature
 // points coincide with the mapping support points and going to the tensor
-// product and non-tensor product path of MappingQGeneric
+// product and non-tensor product path of MappingQ
 
 #include <deal.II/base/quadrature_lib.h>
 
@@ -35,10 +35,10 @@ template <int dim>
 void
 test(const unsigned int degree, const unsigned int n_q_points)
 {
-  MappingQGeneric<dim> mapping(degree);
-  FE_Nothing<dim>      dummy;
-  QGaussLobatto<dim>   quadrature(n_q_points);
-  Quadrature<dim>      quadrature_copy(quadrature.get_points());
+  MappingQ<dim>      mapping(degree);
+  FE_Nothing<dim>    dummy;
+  QGaussLobatto<dim> quadrature(n_q_points);
+  Quadrature<dim>    quadrature_copy(quadrature.get_points());
 
   Triangulation<dim> tria;
   GridGenerator::hyper_ball(tria);
@@ -47,7 +47,7 @@ test(const unsigned int degree, const unsigned int n_q_points)
           << " with " << n_q_points << " points per coordinate direction"
           << std::endl;
 
-  // for QGaussLobatto, MappingQGeneric will choose the tensor product code
+  // for QGaussLobatto, MappingQ will choose the tensor product code
   // path, whereas for the copy it will not as we do not know the tensor
   // product property on general points
   FEValues<dim> fe_val(mapping, dummy, quadrature, update_quadrature_points);
index a02462d8adc064163690de7e3878b51151af3e22..5ff8f1fb9a0e2914a4ba2c489085fb16d49dabb9 100644 (file)
@@ -15,7 +15,7 @@
 
 
 // Check internal implementation of
-// MappingQGeneric::transform_real_to_unit_point by printing Newton iteration
+// MappingQ::transform_real_to_unit_point by printing Newton iteration
 // information. This test is sensitive to roundoff errors by the nature of
 // what gets tested, which can cause one more or one less iteration,
 // especially due to FMA
@@ -30,7 +30,6 @@
 #include <deal.II/fe/fe_tools.h>
 #include <deal.II/fe/mapping_fe_field.h>
 #include <deal.II/fe/mapping_q.h>
-#include <deal.II/fe/mapping_q_generic.h>
 #include <deal.II/fe/mapping_q_internal.h>
 
 #include <deal.II/grid/grid_generator.h>
@@ -50,8 +49,8 @@ print_result(const unsigned int                  mapping_degree,
 {
   deallog << "Testing " << dim << "D with point " << p << std::endl;
 
-  FE_Q<dim>            dummy(mapping_degree);
-  MappingQGeneric<dim> mapping(mapping_degree);
+  FE_Q<dim>     dummy(mapping_degree);
+  MappingQ<dim> mapping(mapping_degree);
 
   FEValues<dim> fe_values(mapping,
                           dummy,
@@ -72,7 +71,7 @@ print_result(const unsigned int                  mapping_degree,
       if (GeometryInfo<dim>::distance_to_unit_cell(
             cell->real_to_unit_cell_affine_approximation(p)) <
           (-0.6 + 1.3 * dim))
-        internal::MappingQGenericImplementation::
+        internal::MappingQImplementation::
           do_transform_real_to_unit_cell_internal(
             p,
             cell->real_to_unit_cell_affine_approximation(p),
index 82b8c5ce01fe9789824e9ea1bcc1e6d03483eb13..6820284f02fe6b9ad1e00d29d03449834856908e 100644 (file)
@@ -45,7 +45,7 @@ test2()
   GridGenerator::hyper_ball(triangulation);
   triangulation.set_manifold(0, boundary_description);
   triangulation.refine_global(1);
-  MappingQGeneric<dim> mapping(1);
+  MappingQ<dim> mapping(1);
 
 
   Point<dim> p(-0.27999999999999992, -0.62999999999999989);
index f3d6c6deee51a65a8825437d8e26ce12ae7ce700..d3692cb85a178b803b4928a154c29e77af4bf9b6 100644 (file)
@@ -74,7 +74,7 @@ test_real_to_unit_cell()
     }
 
 
-  MappingQGeneric<dim, spacedim> map(1);
+  MappingQ<dim, spacedim> map(1);
 
   typename Triangulation<dim, spacedim>::active_cell_iterator cell =
     triangulation.begin_active();
index b32643e28c77ce2c04b82bf537851d32c4bf3b5e..a6a1197c37a544b706374e8cff41f561feec77bd 100644 (file)
@@ -37,8 +37,8 @@ test_real_to_unit_cell()
   Triangulation<dim> triangulation;
   GridGenerator::hyper_ball(triangulation);
 
-  Point<dim>           point;
-  MappingQGeneric<dim> mapping(1);
+  Point<dim>    point;
+  MappingQ<dim> mapping(1);
 
   point[1] = -1. / (1 + std::sqrt(2.0)) / std::sqrt(2);
 
index 72de42c74f98939af6dcfae3c10b5afde5624246..5a198157ba8851a5fa5ccec4a608ee69e240c14d 100644 (file)
@@ -49,8 +49,8 @@ test_real_to_unit_cell()
   cells[0].material_id = 0;
   triangulation.create_triangulation(points, cells, SubCellData());
 
-  Point<dim>           point(-0.29999999999999999, -0.29999999999999999);
-  MappingQGeneric<dim> mapping(1);
+  Point<dim>    point(-0.29999999999999999, -0.29999999999999999);
+  MappingQ<dim> mapping(1);
 
   try
     {
index f4917077de4b4a8e23f0d59710450948c9413f2f..bd3dd5df7f8385df9c98afb48923010a27922b28 100644 (file)
@@ -78,8 +78,8 @@ test_real_to_unit_cell()
   // of the following point in the
   // reference coordinate system of
   // the cell
-  const Point<dim>     p(-3.56413e+06, 1.74215e+06, 2.14762e+06);
-  MappingQGeneric<dim> map(1);
+  const Point<dim> p(-3.56413e+06, 1.74215e+06, 2.14762e+06);
+  MappingQ<dim>    map(1);
   Triangulation<dim>::active_cell_iterator cell = triangulation.begin_active();
   try
     {
index d3515cc9ef3a387fda053a779556580b826f3b82..88a1814ffaeca3e61baf3d26bd0939ffaf1cef25 100644 (file)
@@ -78,8 +78,8 @@ test_real_to_unit_cell()
   // of the following point in the
   // reference coordinate system of
   // the cell
-  const Point<dim>     p(-3.56413e+06, 1.74215e+06, 2.14762e+06);
-  MappingQGeneric<dim> map(1);
+  const Point<dim> p(-3.56413e+06, 1.74215e+06, 2.14762e+06);
+  MappingQ<dim>    map(1);
   Triangulation<dim>::active_cell_iterator cell = triangulation.begin_active();
 
   // the following call will fail
index b57e5e93d284daa2f8967004d2b9040bbf6d9bee..d9caf07dfa09de9dc5778788a4704837eb9ed2d0 100644 (file)
@@ -22,7 +22,7 @@
 #include <deal.II/dofs/dof_handler.h>
 
 #include <deal.II/fe/fe_q.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/tria.h>
@@ -45,9 +45,9 @@ test()
       count += 100000;
     }
 
-  MappingQGeneric<dim> mapping(1);
-  FE_Q<dim>            fe(1);
-  DoFHandler<dim>      dof(tria);
+  MappingQ<dim>   mapping(1);
+  FE_Q<dim>       fe(1);
+  DoFHandler<dim> dof(tria);
   dof.distribute_dofs(fe);
   AffineConstraints<double> constraints;
   constraints.close();
index 254171d948cf7d5e35881d9084059bf1a27ac684..76a75982e5a25c29d273f42c8e4effdcbf1c1505 100644 (file)
@@ -29,7 +29,7 @@
 
 #include <deal.II/fe/fe_dgq.h>
 #include <deal.II/fe/fe_values.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/tria.h>
@@ -342,7 +342,7 @@ test()
   dof.distribute_mg_dofs();
   deallog << "Number of DoFs: " << dof.n_dofs() << std::endl;
 
-  MappingQGeneric<dim>                                   mapping(fe_degree + 1);
+  MappingQ<dim>                                          mapping(fe_degree + 1);
   LaplaceOperator<dim, fe_degree, n_q_points_1d, number> fine_matrix;
   fine_matrix.initialize(mapping, dof);
 
index dd120c0be392423a97ddd3fecadda19e730b6b3a..305bee6532c3b77fb1cb551ea9c5d739e9b2fc1d 100644 (file)
@@ -25,7 +25,7 @@
 #include <deal.II/dofs/dof_tools.h>
 
 #include <deal.II/fe/fe_q.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/tria.h>
@@ -256,7 +256,7 @@ test_deformed_cube()
 
   // check again, now using a mapping that displaces points
   {
-    MappingQGeneric<dim> mapping(3);
+    MappingQ<dim> mapping(3);
     mf.reinit(mapping, dof, constraints, quad, data);
 
     std::vector<unsigned int> n_cell_types(4, 0);
index 5675b98050ce0ccaba8eeb7768eb21252291e2e2..ff7040c77a0ad24f884eecec4ea50a968523b302 100644 (file)
@@ -23,7 +23,7 @@
 #include <deal.II/base/quadrature_lib.h>
 
 #include <deal.II/fe/fe_dgq.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/tria.h>
@@ -47,7 +47,7 @@ test(const unsigned int degree)
   AffineConstraints<double> constraints;
   constraints.close();
 
-  MappingQGeneric<dim> mapping(degree);
+  MappingQ<dim> mapping(degree);
 
   MatrixFree<dim, double>                          mf_data;
   const QGauss<1>                                  quad(degree);
index 358990ff739009da2d47abf25071bc1f800303f8..5025fc05124167a7b88b2f7ca031d5f6fb3134d5 100644 (file)
@@ -67,7 +67,7 @@ do_test(const DoFHandler<dim> &          dof,
   // of degrees of freedom: " << dof.n_dofs() << std::endl; std::cout << "Number
   // of constraints: " << constraints.n_constraints() << std::endl;
 
-  MappingQGeneric<dim>    mapping(dof.get_fe().degree);
+  MappingQ<dim>           mapping(dof.get_fe().degree);
   MatrixFree<dim, number> mf_data;
   {
     const QGauss<1>                                  quad(n_q_points_1d);
index 7058d695ea0efb55557dbafefb9e55c84ce691ec..c620a04a48949c9b9cf0811410eb3eddbf876df6 100644 (file)
@@ -79,7 +79,7 @@ test()
       deallog << " on " << dof.n_dofs() << " DoFs";
       deallog << std::endl;
 
-      MappingQGeneric<dim> mapping(dof.get_fe().degree + 1);
+      MappingQ<dim> mapping(dof.get_fe().degree + 1);
 
       LinearAlgebra::distributed::Vector<double> in, out, out_dist;
 
index e1706bbd0a8974afb9bae7d6077c8c9c06809e7b..5187c374fadf76924a963e3a5ab828a1952e4ba4 100644 (file)
@@ -79,7 +79,7 @@ test()
       deallog << " on " << dof.n_dofs() << " DoFs";
       deallog << std::endl;
 
-      MappingQGeneric<dim> mapping(dof.get_fe().degree + 1);
+      MappingQ<dim> mapping(dof.get_fe().degree + 1);
 
       LinearAlgebra::distributed::BlockVector<double> in(1);
       LinearAlgebra::distributed::BlockVector<double> out(1);
index 6f350189718aaf24faca815845954aeb7345d5ad..b0413f3f18c4a5f7b0ecd941a783aa678d8af67c 100644 (file)
@@ -774,7 +774,7 @@ do_test(const DoFHandler<dim> &          dof,
   // of degrees of freedom: " << dof.n_dofs() << std::endl; std::cout << "Number
   // of constraints: " << constraints.n_constraints() << std::endl;
 
-  MappingQGeneric<dim> mapping(dof.get_fe().degree + 1);
+  MappingQ<dim> mapping(dof.get_fe().degree + 1);
 
   Vector<number> in(dof.n_dofs()), out(dof.n_dofs());
   Vector<number> out_dist(out);
index d441f25f09a548407796650e91e394a1846a5c05..431eef17f70b26f71dbf75691a788383a4ae5de4 100644 (file)
@@ -66,9 +66,9 @@ test()
   // of degrees of freedom: " << dof.n_dofs() << std::endl;
 
   // set up MatrixFree
-  MappingQGeneric<dim> mapping(fe_degree);
-  QGauss<1>            quad(fe_degree + 1);
-  MatrixFree<dim>      mf_data;
+  MappingQ<dim>   mapping(fe_degree);
+  QGauss<1>       quad(fe_degree + 1);
+  MatrixFree<dim> mf_data;
   mf_data.reinit(mapping, dof, constraints, quad);
   SparsityPattern      sparsity;
   SparseMatrix<double> system_matrix;
index e704004cb35fc06c3e2bba433cfbdd772f4a52c9..ab6d3850492cf7c518e7330dbbc7de33b8751630 100644 (file)
@@ -14,7 +14,7 @@
 // ---------------------------------------------------------------------
 
 
-// check FEPointEvaluation for scalar FE_Q and MappingQGeneric by comparing to
+// check FEPointEvaluation for scalar FE_Q and MappingQ by comparing to
 // the output of FEValues with the same settings
 
 #include <deal.II/base/function_lib.h>
@@ -23,7 +23,7 @@
 
 #include <deal.II/fe/fe_q.h>
 #include <deal.II/fe/fe_values.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/tria.h>
@@ -52,7 +52,7 @@ test(const unsigned int degree)
   else
     GridGenerator::subdivided_hyper_cube(tria, 2, 0, 1);
 
-  MappingQGeneric<dim> mapping(degree);
+  MappingQ<dim> mapping(degree);
   deallog << "Mapping of degree " << degree << std::endl;
 
   std::vector<Point<dim>> unit_points;
index a89eba36af946553b5574fd0b4d93993b447e88a..9feca85fbe12b7cf29a5e44b233c0ae90f597cc8 100644 (file)
@@ -14,7 +14,7 @@
 // ---------------------------------------------------------------------
 
 
-// check FEPointEvaluation for scalar FE_DGQ and MappingQGeneric by comparing
+// check FEPointEvaluation for scalar FE_DGQ and MappingQ by comparing
 // to the output of FEValues with the same settings
 
 #include <deal.II/base/function_lib.h>
@@ -23,7 +23,7 @@
 
 #include <deal.II/fe/fe_dgq.h>
 #include <deal.II/fe/fe_values.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/tria.h>
@@ -52,7 +52,7 @@ test(const unsigned int degree)
   else
     GridGenerator::subdivided_hyper_cube(tria, 2, 0, 1);
 
-  MappingQGeneric<dim> mapping(std::max<unsigned int>(1, degree));
+  MappingQ<dim> mapping(std::max<unsigned int>(1, degree));
   deallog << "Mapping of degree " << degree << std::endl;
 
   std::vector<Point<dim>> unit_points;
index 0c95269f1519317309a4e428d74e7dfd380e16ea..2b573ea9d8f875d86698d09b59717c748c6a65ca 100644 (file)
@@ -14,7 +14,7 @@
 // ---------------------------------------------------------------------
 
 
-// check FEPointEvaluation for vector-valued FE_Q and MappingQGeneric by
+// check FEPointEvaluation for vector-valued FE_Q and MappingQ by
 // comparing to the output of FEValues with the same settings
 
 #include <deal.II/base/function_lib.h>
@@ -24,7 +24,7 @@
 #include <deal.II/fe/fe_q.h>
 #include <deal.II/fe/fe_system.h>
 #include <deal.II/fe/fe_values.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/tria.h>
@@ -70,7 +70,7 @@ test(const unsigned int degree)
   else
     GridGenerator::subdivided_hyper_cube(tria, 2, 0, 1);
 
-  MappingQGeneric<dim> mapping(degree);
+  MappingQ<dim> mapping(degree);
   deallog << "Mapping of degree " << degree << std::endl;
 
   std::vector<Point<dim>> unit_points;
index c598625cce1715e5e2ab4652bd26bc55831e8129..3399d4af818e8c6595fb7c572b19ef1aaa41ad7e 100644 (file)
@@ -14,7 +14,7 @@
 // ---------------------------------------------------------------------
 
 
-// check FEPointEvaluation for FESystem(FE_Q^dim, FE_Q) and MappingQGeneric by
+// check FEPointEvaluation for FESystem(FE_Q^dim, FE_Q) and MappingQ by
 // comparing to the output of FEValues with the same settings
 
 #include <deal.II/base/function_lib.h>
@@ -24,7 +24,7 @@
 #include <deal.II/fe/fe_q.h>
 #include <deal.II/fe/fe_system.h>
 #include <deal.II/fe/fe_values.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/tria.h>
@@ -73,7 +73,7 @@ test(const unsigned int degree)
   else
     GridGenerator::subdivided_hyper_cube(tria, 2, 0, 1);
 
-  MappingQGeneric<dim> mapping(degree);
+  MappingQ<dim> mapping(degree);
   deallog << "Mapping of degree " << degree << std::endl;
 
   std::vector<Point<dim>> unit_points;
index 3bea6919a4b995cb0ce683c582bff2f0022ff055..5d7bb217bc539d953579463ddb9155337b841877 100644 (file)
@@ -14,7 +14,7 @@
 // ---------------------------------------------------------------------
 
 
-// check FEPointEvaluation for (dim+1)-valued FE_Q and MappingQGeneric by
+// check FEPointEvaluation for (dim+1)-valued FE_Q and MappingQ by
 // comparing to the output of FEValues with the same settings
 
 #include <deal.II/base/function_lib.h>
@@ -24,7 +24,7 @@
 #include <deal.II/fe/fe_q.h>
 #include <deal.II/fe/fe_system.h>
 #include <deal.II/fe/fe_values.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/tria.h>
@@ -70,7 +70,7 @@ test(const unsigned int degree)
   else
     GridGenerator::subdivided_hyper_cube(tria, 2, 0, 1);
 
-  MappingQGeneric<dim> mapping(degree);
+  MappingQ<dim> mapping(degree);
   deallog << "Mapping of degree " << degree << std::endl;
 
   std::vector<Point<dim>> unit_points;
index 714b1ef5e81786d7b549b82fbacdeb2aeff6f034..f25138c16519d99a5356ae2ccb4ddf3594ce43bd 100644 (file)
@@ -14,7 +14,7 @@
 // ---------------------------------------------------------------------
 
 
-// check FEPointEvaluation for scalar FE_DGQArbitraryNodes and MappingQGeneric
+// check FEPointEvaluation for scalar FE_DGQArbitraryNodes and MappingQ
 // by comparing to the output of FEValues with the same settings (apart from
 // the finite element, this test is the same as point_evaluation_02)
 
@@ -25,7 +25,7 @@
 
 #include <deal.II/fe/fe_dgq.h>
 #include <deal.II/fe/fe_values.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/tria.h>
@@ -54,7 +54,7 @@ test(const unsigned int degree)
   else
     GridGenerator::subdivided_hyper_cube(tria, 2, 0, 1);
 
-  MappingQGeneric<dim> mapping(degree);
+  MappingQ<dim> mapping(degree);
   deallog << "Mapping of degree " << degree << std::endl;
 
   std::vector<Point<dim>> unit_points;
index 0cda0c24050a83dca11ba4c78674c8e0127338ba..e176925ce465ade8715e0538f8321b990e270dd6 100644 (file)
@@ -14,7 +14,7 @@
 // ---------------------------------------------------------------------
 
 
-// check FEPointEvaluation for scalar FE_DGQHermite and MappingQGeneric by
+// check FEPointEvaluation for scalar FE_DGQHermite and MappingQ by
 // comparing to the output of FEValues with the same settings (apart from the
 // finite element and the interpolated function, this is the same as
 // point_evaluation_02)
@@ -25,7 +25,7 @@
 
 #include <deal.II/fe/fe_dgq.h>
 #include <deal.II/fe/fe_values.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/tria.h>
@@ -54,7 +54,7 @@ test(const unsigned int degree)
   else
     GridGenerator::subdivided_hyper_cube(tria, 2, 0, 1);
 
-  MappingQGeneric<dim> mapping(degree);
+  MappingQ<dim> mapping(degree);
   deallog << "Mapping of degree " << degree << std::endl;
 
   std::vector<Point<dim>> unit_points;
index 316e4ff722029d14b3ad97ba8d8fab303d785ed0..f41c308e5d16346fe3ce2c391b94a1dc3bc148eb 100644 (file)
@@ -23,7 +23,7 @@
 #include <deal.II/dofs/dof_handler.h>
 
 #include <deal.II/fe/fe_q.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/tria.h>
@@ -52,7 +52,7 @@ test(const unsigned int degree)
   else
     GridGenerator::subdivided_hyper_cube(tria, 2, 0, 1);
 
-  MappingQGeneric<dim> mapping(degree);
+  MappingQ<dim> mapping(degree);
   deallog << "Mapping of degree " << degree << std::endl;
 
   std::vector<Point<dim>> unit_points;
index 02e68949ce64360f9d82a55a471f587312096b02..5f7eb015ed61867363690c690aaa2a2dfa004eb9 100644 (file)
@@ -86,8 +86,8 @@ test()
   TrilinosWrappers::MPI::Vector vec_rel(locally_relevant_set);
   vec_rel = vec;
 
-  MappingQGeneric<dim> mapping(1);
-  Vector<float>        indicators(tr.n_active_cells());
+  MappingQ<dim> mapping(1);
+  Vector<float> indicators(tr.n_active_cells());
   DerivativeApproximation::approximate_gradient(mapping,
                                                 dofh,
                                                 vec_rel,
index 42c2cbae137842a0676879a4dbddb1bfb306dc9d..68de5c166506ce474b9a59d72c6f990e0e6e9c0a 100644 (file)
@@ -78,7 +78,7 @@ namespace Step39
     setup_system();
 
     parallel::distributed::Triangulation<dim> triangulation;
-    const MappingQGeneric<dim>                mapping;
+    const MappingQ<dim>                       mapping;
     const FiniteElement<dim> &                fe;
     DoFHandler<dim>                           dof_handler;
 
index 2d701834372426665ff5a01485f2828eac3ba5fc..ccd17ec17e0c15be0cfd71b3b038d07793ddda7f 100644 (file)
@@ -23,7 +23,7 @@
 #include <deal.II/dofs/dof_tools.h>
 
 #include <deal.II/fe/fe_q.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 
@@ -46,7 +46,7 @@ test()
   dofh.distribute_dofs(fe);
 
   std::map<types::global_dof_index, Point<dim>> points;
-  DoFTools::map_dofs_to_support_points(MappingQGeneric<dim>(1), dofh, points);
+  DoFTools::map_dofs_to_support_points(MappingQ<dim>(1), dofh, points);
   if (Utilities::MPI::this_mpi_process(MPI_COMM_WORLD) == 0)
     {
       for (typename std::map<types::global_dof_index,
index 06507f91e14013cba75a596b7b94c18a83fe853d..04d203b7d00309c5e789235bf71d19ae7ff185f5 100644 (file)
@@ -150,7 +150,7 @@ test_simple(DoFHandler<dim> &dofs, bool faces)
   local.cells = true;
   local.faces = faces;
 
-  MappingQGeneric<dim> mapping(1);
+  MappingQ<dim> mapping(1);
 
   MeshWorker::IntegrationInfoBox<dim> info_box;
   info_box.initialize_gauss_quadrature(1, 1, 1);
index 916a759654a2e75a8dce98888b5559ffc3d9389b..cb0855932ef3fbaf27b13c3b2cb12cbc0d6b0a2d 100644 (file)
@@ -218,7 +218,7 @@ check(const unsigned int orientation, bool reverse)
   unsigned int n_local_constraints = 0;
 
   std::map<types::global_dof_index, Point<dim>> support_points;
-  DoFTools::map_dofs_to_support_points(MappingQGeneric<dim>(1),
+  DoFTools::map_dofs_to_support_points(MappingQ<dim>(1),
                                        dof_handler,
                                        support_points);
   IndexSet constraints_lines = constraints.get_local_lines();
index a1ee7371d5b0e700b791adf6f47ceb604b85fb71..489c1745bf0d94515cb06ff3972fa0a806d8a6ec 100644 (file)
@@ -53,7 +53,7 @@ refine_and_transfer(const Function<dim> &function, Triangulation<dim> &tria)
   tria.prepare_coarsening_and_refinement();
 
   Vector<double> sol_old(dh.n_dofs());
-  VectorTools::interpolate(MappingQGeneric<dim>(1), dh, function, sol_old);
+  VectorTools::interpolate(MappingQ<dim>(1), dh, function, sol_old);
 
   SolutionTransfer<dim> soltrans(dh);
   soltrans.prepare_for_coarsening_and_refinement(sol_old);
index be62e2fb61006e2c71b49079d0c466232e38eb03..7aa13a39276b5a137fb7677d91bc1efb084c22ca 100644 (file)
@@ -53,7 +53,7 @@ refine_and_transfer(const Function<dim> &function, Triangulation<dim> &tria)
   tria.prepare_coarsening_and_refinement();
 
   Vector<double> sol_old(dh.n_dofs());
-  VectorTools::interpolate(MappingQGeneric<dim>(1), dh, function, sol_old);
+  VectorTools::interpolate(MappingQ<dim>(1), dh, function, sol_old);
 
   SolutionTransfer<dim> soltrans(dh);
   soltrans.prepare_for_pure_refinement();
index dc3b1a6efa841c8363c718a5bf8014bddb8f0c00..1aae9c4e968e66fe0301e86406f4e9a98633ad2c 100644 (file)
@@ -421,7 +421,7 @@ namespace Step39
     output_results(const unsigned int cycle) const;
 
     parallel::distributed::Triangulation<dim> triangulation;
-    const MappingQGeneric<dim>                mapping;
+    const MappingQ<dim>                       mapping;
     const FiniteElement<dim> &                fe;
     DoFHandler<dim>                           dof_handler;
 
index 966b3c5545effcef445421f598454bca1c10f1c1..31aa6a820a401948461bed825e09498d1b14e9cd 100644 (file)
@@ -422,7 +422,7 @@ namespace Step39
     output_results(const unsigned int cycle) const;
 
     parallel::distributed::Triangulation<dim> triangulation;
-    const MappingQGeneric<dim>                mapping;
+    const MappingQ<dim>                       mapping;
     const FiniteElement<dim> &                fe;
     DoFHandler<dim>                           dof_handler;
 
index 1235f5a600289b92937281b10bc2ddbb861b4b03..3fe907b2497fd1a7c64bfa339014714aa7a79937 100644 (file)
@@ -195,10 +195,10 @@ private:
   void
   refine_local();
 
-  Triangulation<dim>         triangulation;
-  const MappingQGeneric<dim> mapping;
-  FESystem<dim>              fe;
-  DoFHandler<dim>            mg_dof_handler_renumbered;
+  Triangulation<dim>  triangulation;
+  const MappingQ<dim> mapping;
+  FESystem<dim>       fe;
+  DoFHandler<dim>     mg_dof_handler_renumbered;
 
   const unsigned int                             degree;
   std::vector<std::set<types::global_dof_index>> boundary_indices_renumbered;
index 08ddf93adcdd43b26713190a751ee560687dc222..426a292d90914d64823a142eac49fe442f841f5b 100644 (file)
@@ -242,11 +242,11 @@ private:
   void
   refine_local();
 
-  Triangulation<dim>         triangulation;
-  const MappingQGeneric<dim> mapping;
-  FESystem<dim>              fe;
-  DoFHandler<dim>            mg_dof_handler;
-  DoFHandler<dim>            mg_dof_handler_renumbered;
+  Triangulation<dim>  triangulation;
+  const MappingQ<dim> mapping;
+  FESystem<dim>       fe;
+  DoFHandler<dim>     mg_dof_handler;
+  DoFHandler<dim>     mg_dof_handler_renumbered;
 
   const unsigned int                             degree;
   std::vector<std::set<types::global_dof_index>> boundary_indices,
index d091c9b27263396d799c473c07d32d34fc30b691..7035cba0b429f30cf1c63e5e0a8b3e9c9e63557c 100644 (file)
@@ -257,7 +257,7 @@ LaplaceProblem<dim>::setup_system()
   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);
+  MappingQ<dim> mapping(1);
   VectorTools::interpolate_boundary_values(mapping,
                                            mg_dof_handler,
                                            dirichlet_boundary,
@@ -358,7 +358,7 @@ LaplaceProblem<dim>::assemble_multigrid(const bool &use_mw)
     {
       mg_matrices = 0.;
 
-      MappingQGeneric<dim>                mapping(1);
+      MappingQ<dim>                       mapping(1);
       MeshWorker::IntegrationInfoBox<dim> info_box;
       UpdateFlags                         update_flags =
         update_values | update_gradients | update_hessians;
index add8ad999defa74baf3967beb6ac5e80e2e1e237..8f8ac391b4d35b6e315aa7eb35dad8b5c7d9a08c 100644 (file)
@@ -176,7 +176,7 @@ LaplaceProblem<dim>::setup_system()
   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);
+  MappingQ<dim> mapping(1);
   VectorTools::interpolate_boundary_values(mapping,
                                            mg_dof_handler,
                                            dirichlet_boundary,
index 02cc1de2d2f92fd1ef28ddd1991fde1efe08c580..9a9eec006989b84fe3e7de0f28ab0c427f6cfab5 100644 (file)
@@ -180,7 +180,7 @@ LaplaceProblem<dim>::setup_system()
   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);
+  MappingQ<dim> mapping(1);
   VectorTools::interpolate_boundary_values(mapping,
                                            mg_dof_handler,
                                            dirichlet_boundary,
index 8c21075ff76d829629204a6fa0f074892b5a21d2..eadb8d16797f73e506386bbf04eabf49e6a05373 100644 (file)
@@ -180,7 +180,7 @@ LaplaceProblem<dim>::setup_system()
   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);
+  MappingQ<dim> mapping(1);
   VectorTools::interpolate_boundary_values(mapping,
                                            mg_dof_handler,
                                            dirichlet_boundary,
index f3b8290eff6a567fa647c002a8106a9fe615af34..360a662960f0233ea82b479b7a7948c16e8875b0 100644 (file)
@@ -180,7 +180,7 @@ LaplaceProblem<dim>::setup_system()
   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);
+  MappingQ<dim> mapping(1);
   VectorTools::interpolate_boundary_values(mapping,
                                            mg_dof_handler,
                                            dirichlet_boundary,
index 766aa29ee400b2ab601c70508903b617ec332b37..43b966d7af86ff6c33d21c37d416ea39e72d94ee 100644 (file)
@@ -182,7 +182,7 @@ LaplaceProblem<dim>::setup_system()
   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);
+  MappingQ<dim> mapping(1);
   VectorTools::interpolate_boundary_values(mapping,
                                            mg_dof_handler,
                                            dirichlet_boundary,
index 52f68cfbfb4fb2424d36f35eb313f455fd401542..04da0ce19faf97135ba570d9eaa0ccc4e043228d 100644 (file)
@@ -184,7 +184,7 @@ LaplaceProblem<dim>::setup_system()
   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);
+  MappingQ<dim> mapping(1);
   VectorTools::interpolate_boundary_values(mapping,
                                            mg_dof_handler,
                                            dirichlet_boundary,
index e8aaf929e4eb2a44f75d578e16e827c3a36fc9f4..07f73318c15182ba987b0e7acbbac0982d5f233f 100644 (file)
@@ -180,7 +180,7 @@ LaplaceProblem<dim>::setup_system()
   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);
+  MappingQ<dim> mapping(1);
   VectorTools::interpolate_boundary_values(mapping,
                                            mg_dof_handler,
                                            dirichlet_boundary,
index e6bb79763ab5f76f99a1a68eab4d29d619f5e1b4..d8681b30b127ff7e7c5f197f0fc43c9f7866cba3 100644 (file)
@@ -258,7 +258,7 @@ LaplaceProblem<dim>::setup_system()
   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);
+  MappingQ<dim> mapping(1);
   VectorTools::interpolate_boundary_values(mapping,
                                            mg_dof_handler,
                                            dirichlet_boundary,
@@ -364,7 +364,7 @@ LaplaceProblem<dim>::assemble_multigrid(bool use_mw)
       mg_interface_in  = 0.;
       mg_interface_out = 0.;
 
-      MappingQGeneric<dim>                mapping(1);
+      MappingQ<dim>                       mapping(1);
       MeshWorker::IntegrationInfoBox<dim> info_box;
       UpdateFlags                         update_flags =
         update_values | update_gradients | update_hessians;
index 19475fbb41f6c3c23f16de7bc0ae36e4b826c848..96f506813db06edf2addf56d9f942924883de2ab 100644 (file)
@@ -182,7 +182,7 @@ LaplaceProblem<dim>::setup_system()
   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);
+  MappingQ<dim> mapping(1);
   VectorTools::interpolate_boundary_values(mapping,
                                            mg_dof_handler,
                                            dirichlet_boundary,
index 39e09129e20e26e00ed57bf3144fa6589008eb07..493da723168d3d5dc83ed54706d35e7c56c86d82 100644 (file)
@@ -411,10 +411,10 @@ namespace Step39
     void
     output_results(const unsigned int cycle) const;
 
-    Triangulation<dim>         triangulation;
-    const MappingQGeneric<dim> mapping;
-    const FiniteElement<dim> & fe;
-    DoFHandler<dim>            dof_handler;
+    Triangulation<dim>        triangulation;
+    const MappingQ<dim>       mapping;
+    const FiniteElement<dim> &fe;
+    DoFHandler<dim>           dof_handler;
 
     SparsityPattern      sparsity;
     SparseMatrix<double> matrix;
index b780aa2cba8a6bcdfbab689dcecf8456c5740e04..d420214a95e6045ee3cf8c4c572f1de3ca20569c 100644 (file)
@@ -413,11 +413,11 @@ namespace Step39
     void
     output_results(const unsigned int cycle) const;
 
-    Triangulation<dim>         triangulation;
-    const MappingQGeneric<dim> mapping;
-    const FiniteElement<dim> & fe;
-    DoFHandler<dim>            dof_handler;
-    MGConstrainedDoFs          mg_constraints;
+    Triangulation<dim>        triangulation;
+    const MappingQ<dim>       mapping;
+    const FiniteElement<dim> &fe;
+    DoFHandler<dim>           dof_handler;
+    MGConstrainedDoFs         mg_constraints;
 
     SparsityPattern      sparsity;
     SparseMatrix<double> matrix;
index 22acb0cd73d9a52e82eaf97c788c61c195c50cda..825e93104f4dd9df129df9d235cb8ca9fa41e8da 100644 (file)
@@ -417,10 +417,10 @@ namespace Step39
     void
     output_results(const unsigned int cycle) const;
 
-    Triangulation<dim>         triangulation;
-    const MappingQGeneric<dim> mapping;
-    const FiniteElement<dim> & fe;
-    DoFHandler<dim>            dof_handler;
+    Triangulation<dim>        triangulation;
+    const MappingQ<dim>       mapping;
+    const FiniteElement<dim> &fe;
+    DoFHandler<dim>           dof_handler;
 
     SparsityPattern      sparsity;
     SparseMatrix<double> matrix;
index aebc0d93b1ecc2b814f855fe0854e2a5af26431a..da2ebc8908605e6f59d12dd175a4e62bf7db9202 100644 (file)
@@ -412,10 +412,10 @@ namespace Step39
     void
     output_results(const unsigned int cycle) const;
 
-    Triangulation<dim>         triangulation;
-    const MappingQGeneric<dim> mapping;
-    const FiniteElement<dim> & fe;
-    DoFHandler<dim>            dof_handler;
+    Triangulation<dim>        triangulation;
+    const MappingQ<dim>       mapping;
+    const FiniteElement<dim> &fe;
+    DoFHandler<dim>           dof_handler;
 
     SparsityPattern      sparsity;
     SparseMatrix<double> matrix;
index 2b72a7867cccb3561cc2506bf3c7b7677aeb7ea7..6b64552ac9957915f994360af855586c7ed0078b 100644 (file)
@@ -151,12 +151,12 @@ derivatives()
   Triangulation<dim> tria;
   GridGenerator::hyper_cube(tria);
   tria.refine_global(5 - dim);
-  FE_DGQ<dim>          fe(2);
-  DoFHandler<dim>      dof_handler(tria);
-  Vector<double>       solution;
-  MappingQGeneric<dim> mapping(1);
-  QMidpoint<dim>       q_midpoint;
-  FEValues<dim> fe_values(mapping, fe, q_midpoint, update_quadrature_points);
+  FE_DGQ<dim>     fe(2);
+  DoFHandler<dim> dof_handler(tria);
+  Vector<double>  solution;
+  MappingQ<dim>   mapping(1);
+  QMidpoint<dim>  q_midpoint;
+  FEValues<dim>   fe_values(mapping, fe, q_midpoint, update_quadrature_points);
 
   dof_handler.distribute_dofs(fe);
   solution.reinit(dof_handler.n_dofs());
index 6a6aeeeb7f3726b585af32643ae0fdd43f4a5ed2..0cc960bd2e5b5dc21647f485a39bacb90193acfa 100644 (file)
@@ -190,7 +190,7 @@ loop()
 
   std::vector<Mapping<dim> *> maps;
   //  maps.push_back (new MappingCartesian<dim>);
-  maps.push_back(new MappingQGeneric<dim>(1));
+  maps.push_back(new MappingQ<dim>(1));
   maps.push_back(new MappingQ<dim>(2));
 
   std::vector<FiniteElement<dim> *> elements;
index dcd819820f23ff1a901462652ea739e16b298e45..332f6783c5eeaae0ec7d77c5392bbe5392a1ce4e 100644 (file)
@@ -20,7 +20,7 @@
 #include <deal.II/dofs/dof_handler.h>
 
 #include <deal.II/fe/fe_q.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 
@@ -51,7 +51,7 @@ template <unsigned int spacedim>
 void
 check(const unsigned int refinement_1, const unsigned int refinement_2)
 {
-  MappingQGeneric<spacedim> mapping(1);
+  MappingQ<spacedim> mapping(1);
 
   Triangulation<spacedim> tria_1, tria_2;
   GridGenerator::hyper_cube(tria_1);
index 5f945e5d31f331ba0c34884416c6e95887a37ffb..bcc2859296a55582bba071dc5bac16f9bcc3efef 100644 (file)
@@ -20,7 +20,7 @@
 #include <deal.II/dofs/dof_handler.h>
 
 #include <deal.II/fe/fe_q.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 
@@ -53,7 +53,7 @@ template <unsigned int spacedim>
 void
 check(const unsigned int refinement_1, const unsigned int refinement_2)
 {
-  MappingQGeneric<spacedim> mapping(1);
+  MappingQ<spacedim> mapping(1);
 
   Triangulation<spacedim> tria_1, tria_2;
   GridGenerator::hyper_cube(tria_1);
index 6ce3e2e65b1d9f5f7935e69d183a7494a429078c..d7c88c720535927720e7f31abdb31790ac4c29c0 100644 (file)
@@ -22,7 +22,7 @@
 #include <deal.II/dofs/dof_handler.h>
 
 #include <deal.II/fe/fe_q.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 
@@ -41,7 +41,7 @@ template <unsigned int spacedim>
 void
 check(const unsigned int refinement_1, const unsigned int refinement_2)
 {
-  MappingQGeneric<spacedim> mapping(1);
+  MappingQ<spacedim> mapping(1);
 
   Triangulation<spacedim> tria_1, tria_2;
   GridGenerator::hyper_cube(tria_1);
index 2b9ac17036e8d695c589eed911a653573ebc9149..8df1c116feaeb74621efdac9f9a623ae046159fd 100644 (file)
@@ -22,7 +22,7 @@
 #include <deal.II/dofs/dof_handler.h>
 
 #include <deal.II/fe/fe_q.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 
@@ -43,7 +43,7 @@ template <unsigned int spacedim>
 void
 check(const unsigned int refinement_1, const unsigned int refinement_2)
 {
-  MappingQGeneric<spacedim> mapping(1);
+  MappingQ<spacedim> mapping(1);
 
   Triangulation<spacedim> tria_1, tria_2;
   GridGenerator::hyper_cube(tria_1);
index 437198c182a9b562931e04fffe6c1d96f32937bd..befb0ed1f4c534eaedcf0c52864d85357aecaadc 100644 (file)
@@ -25,7 +25,6 @@
 
 #include <deal.II/fe/fe_q.h>
 #include <deal.II/fe/mapping_q.h>
-#include <deal.II/fe/mapping_q_generic.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/grid_tools.h>
@@ -97,8 +96,7 @@ test()
 
   // use an explicit Q1 mapping. this will yield a zero solution
   {
-    VectorTools::project(
-      MappingQGeneric<dim>(1), dh, cm, QGauss<dim>(3), F<dim>(), v);
+    VectorTools::project(MappingQ<dim>(1), dh, cm, QGauss<dim>(3), F<dim>(), v);
     deallog << v.l2_norm() << std::endl;
     Assert(v.l2_norm() == 0, ExcInternalError());
   }
index 05126e1babd7e16a9e9fcbbc9035569de4f5fd4b..e639e62327a302ba3d7ea2404be8a51f42ecd41e 100644 (file)
@@ -144,8 +144,8 @@ test_projection(const Triangulation<dim> &tr, const FiniteElement<dim> &fe)
   DoFHandler<dim> dof(tr);
   dof.distribute_dofs(fe);
 
-  QGauss<dim - 1>      quadrature(degree + 2);
-  MappingQGeneric<dim> mapping(1);
+  QGauss<dim - 1> quadrature(degree + 2);
+  MappingQ<dim>   mapping(1);
 
   TestFunction<dim>                                   f(degree - 1);
   std::map<types::global_dof_index, double>           boundary_constraints;
index fb7e0093c1387c0d57ee2d39e6d250fe39417538..e72308bb3e2cd75ac53ab38fb0a42586f1e983dd 100644 (file)
@@ -156,7 +156,7 @@ do_project(const parallel::distributed::Triangulation<dim> &triangulation,
 
         VectorType field(dof_handler.locally_owned_dofs(), MPI_COMM_WORLD);
         VectorTools::project<dim, VectorType, dim>(
-          MappingQGeneric<dim>(1),
+          MappingQ<dim>(1),
           dof_handler,
           constraints,
           quadrature_formula,
index 6a5f96c02a023fd8adc1ea8c33c89bc614a26caf..47eed86e2e41c51d25f3f71989a9211832964daf 100644 (file)
@@ -22,7 +22,7 @@
 
 #include <deal.II/fe/fe_q.h>
 #include <deal.II/fe/fe_values.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/grid_out.h>
@@ -79,7 +79,7 @@ main()
     FE_Q<2, 3>       fe(2);
     DoFHandler<2, 3> dh(tria);
     dh.distribute_dofs(fe);
-    MappingQGeneric<2, 3> mapping2(2);
+    MappingQ<2, 3>        mapping2(2);
     std::vector<Point<3>> spoints(dh.n_dofs());
     DoFTools::map_dofs_to_support_points(mapping2, dh, spoints);
 
index 9f303abfd71582cd2353e30997076ad0b9b8d5df..b8100e95e59bb5bdcf2661c36c939326713619e0 100644 (file)
@@ -23,7 +23,7 @@
 
 #include <deal.II/fe/fe_q.h>
 #include <deal.II/fe/fe_values.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/grid_out.h>
index f61a4d2a9170349763768b004bcd1d7ba8b6bc55..2a595865f9a0b8e6e74b75a96d6e3bf7e759f863 100644 (file)
@@ -43,7 +43,7 @@ test()
 
     GridGenerator::hyper_shell(tr, Point<dim>(), 0.5, 1.0);
 
-    MappingQGeneric<dim, spacedim> mapping(4);
+    MappingQ<dim, spacedim> mapping(4);
 
     Particles::ParticleHandler<dim, spacedim> particle_handler(tr, mapping);
 
index a45df3cd2152cf1882df7c51ee101f62851b12ad..8535f5541d5d261c5cb3e18b368a3e0dda5b4f76 100644 (file)
@@ -23,7 +23,7 @@
 
 #include <deal.II/fe/fe_q.h>
 #include <deal.II/fe/fe_system.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/filtered_iterator.h>
 #include <deal.II/grid/grid_generator.h>
@@ -50,7 +50,7 @@ test()
   GridGenerator::hyper_cube(background_triangulation, 0, 1);
   background_triangulation.refine_global(6 - dim);
 
-  const MappingQGeneric<dim> mapping(1);
+  const MappingQ<dim> mapping(1);
 
   Particles::ParticleHandler<dim> particle_handler;
   particle_handler.initialize(background_triangulation, mapping, 1);
index 528f16322dbc9015a83b497962a9fd8f8cdb5fda..b27967cf6dd6444a93e3d575a5471d263c35238b 100644 (file)
@@ -29,7 +29,7 @@
 #include <deal.II/fe/fe_q_iso_q1.h>
 #include <deal.II/fe/fe_system.h>
 #include <deal.II/fe/mapping_fe_field.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/grid_out.h>
@@ -436,8 +436,7 @@ test()
   Vector<double> euler_vector(dof_handler_dim.n_dofs());
   VectorTools::get_position_vector(dof_handler_dim,
                                    euler_vector,
-                                   MappingQGeneric<dim, spacedim>(
-                                     mapping_degree));
+                                   MappingQ<dim, spacedim>(mapping_degree));
   MappingFEField<dim, spacedim> mapping(dof_handler_dim, euler_vector);
 
 
index 50f4049cad8b5868172159bd0d9e934b46a5b928..8bd1be938ac468869fd809afdc31cabe0cb83e87 100644 (file)
@@ -29,7 +29,7 @@
 #include <deal.II/fe/fe_q_iso_q1.h>
 #include <deal.II/fe/fe_system.h>
 #include <deal.II/fe/mapping_fe_field.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/grid_out.h>
@@ -366,8 +366,7 @@ test()
   Vector<double> euler_vector(dof_handler_dim.n_dofs());
   VectorTools::get_position_vector(dof_handler_dim,
                                    euler_vector,
-                                   MappingQGeneric<dim, spacedim>(
-                                     mapping_degree));
+                                   MappingQ<dim, spacedim>(mapping_degree));
   MappingFEField<dim, spacedim> mapping(dof_handler_dim, euler_vector);
 
 
index bfacec3499635906d076898dcd3446ed4933b37e..726449f1ab355c3987441c3641b05c6f6527831c 100644 (file)
@@ -30,7 +30,7 @@
 #include <deal.II/fe/fe_q_iso_q1.h>
 #include <deal.II/fe/fe_system.h>
 #include <deal.II/fe/mapping_fe_field.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/grid_out.h>
@@ -362,8 +362,7 @@ test(const MPI_Comm comm)
   Vector<double> euler_vector(dof_handler_dim.n_dofs());
   VectorTools::get_position_vector(dof_handler_dim,
                                    euler_vector,
-                                   MappingQGeneric<dim, spacedim>(
-                                     mapping_degree));
+                                   MappingQ<dim, spacedim>(mapping_degree));
   MappingFEField<dim, spacedim> mapping(dof_handler_dim, euler_vector);
 
 
index b1ce1f6556c5ccea068e926b4d5fd948ca53665d..71a48ea124dec85031d55b568da9a77cab25049a 100644 (file)
@@ -25,7 +25,7 @@
 #include <deal.II/fe/fe_dgq.h>
 #include <deal.II/fe/fe_q.h>
 #include <deal.II/fe/mapping_fe.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 
index a6a5f7ae4f82e98b03361ae58dc93b5bc6523cea..6a610129ef6a0f45659f548c3788e3ff86d08341 100644 (file)
@@ -26,7 +26,7 @@
 #include <deal.II/fe/fe_dgq.h>
 #include <deal.II/fe/fe_q.h>
 #include <deal.II/fe/mapping_fe.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/grid_in.h>
@@ -294,18 +294,18 @@ test()
   const unsigned int n_refinements_1 = 4;
   const unsigned int n_refinements_2 = 4;
 
-  const MappingQGeneric<dim> mapping_1(1);
-  const FE_Q<dim>            fe_1(2);
-  const QGauss<dim>          quad_1(3);
+  const MappingQ<dim> mapping_1(1);
+  const FE_Q<dim>     fe_1(2);
+  const QGauss<dim>   quad_1(3);
 
 #if false
   const MappingFE<dim>     mapping_2(Simplex::FE_P<dim>(1));
   const Simplex::FE_P<dim> fe_2(2);
   const Simplex::QGauss<dim>        quad_2(3);
 #else
-  const MappingQGeneric<dim> mapping_2(1);
-  const FE_Q<dim>            fe_2(2);
-  const QGauss<dim>          quad_2(3);
+  const MappingQ<dim> mapping_2(1);
+  const FE_Q<dim>     fe_2(2);
+  const QGauss<dim>   quad_2(3);
 #endif
 
   parallel::distributed::Triangulation<dim> tria_1(MPI_COMM_WORLD);
index c1cc3f82aad7bd14faad25c1c85cc0a60497e416..2bf4c47d723c7309036ffcd85f3043e7b544a810 100644 (file)
@@ -26,7 +26,7 @@
 #include <deal.II/fe/fe_dgq.h>
 #include <deal.II/fe/fe_q.h>
 #include <deal.II/fe/mapping_fe.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 
index c30f0ec9bc43c05fa373f9a07a2c5775f18c569c..50cd62461953b366a33f38f23573ae2c418dac09 100644 (file)
@@ -25,7 +25,7 @@
 #include <deal.II/fe/fe_dgq.h>
 #include <deal.II/fe/fe_q.h>
 #include <deal.II/fe/mapping_fe.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 
index 808f485c34c256b1394366aa2fe350489d0b1c9f..62fcaf2a28a52617a7aba3fc47781285fe59572b 100644 (file)
@@ -25,7 +25,7 @@
 #include <deal.II/fe/fe_dgq.h>
 #include <deal.II/fe/fe_q.h>
 #include <deal.II/fe/mapping_fe.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 
index 0094b9c7b6c1aa7be18afc11b91ab3d0d9223577..efc597ad625654135d3494558ffeeb3caf200498 100644 (file)
@@ -72,9 +72,9 @@ test(const FiniteElement<dim, spacedim> &fe_0,
   hp::QCollection<dim> quadrature(QGaussSimplex<dim>(degree + 1),
                                   QGauss<dim>(degree + 1));
 
-  hp::MappingCollection<dim, spacedim> mapping(
-    MappingFE<dim, spacedim>(FE_SimplexP<dim, spacedim>(1)),
-    MappingQGeneric<dim, spacedim>(1));
+  hp::MappingCollection<dim, spacedim> mapping(MappingFE<dim, spacedim>(
+                                                 FE_SimplexP<dim, spacedim>(1)),
+                                               MappingQ<dim, spacedim>(1));
 
   Triangulation<dim, spacedim> tria;
   GridGenerator::subdivided_hyper_cube_with_simplices_mix(tria,
index 115179c52a255b210ba0323bb1fa6859fea9a5d7..1638180e5dee4e59301597f794492a38efe112c4 100644 (file)
@@ -47,7 +47,7 @@ test()
   GridGenerator::subdivided_hyper_cube(tria, 4);
 
   hp::FECollection<dim> fe{FE_Q<2>(degree), FE_Q<2>(degree)};
-  MappingQGeneric<dim>  mapping(1);
+  MappingQ<dim>         mapping(1);
   QGauss<dim>           quadrature(degree + 1);
 
   DoFHandler<dim> dof_handler(tria);
index ccc00ba9762ac5d53e05718173a2fa2593560de0..6110f0df9a5b76bbaf8e883e4edbcaa053e02219 100644 (file)
@@ -1015,10 +1015,9 @@ main()
         {
           ScratchData<2> scratch_data;
 
-          scratch_data.mapping =
-            hp::MappingCollection<2>(MappingQGeneric<2>(1));
-          scratch_data.fe              = hp::FECollection<2>(FE_DGQ<2>(i));
-          scratch_data.quadrature      = hp::QCollection<2>(QGauss<2>(i + 1));
+          scratch_data.mapping    = hp::MappingCollection<2>(MappingQ<2>(1));
+          scratch_data.fe         = hp::FECollection<2>(FE_DGQ<2>(i));
+          scratch_data.quadrature = hp::QCollection<2>(QGauss<2>(i + 1));
           scratch_data.face_quadrature = std::vector<hp::QCollection<1>>{
             hp::QCollection<1>(QGauss<1>(i + 1))};
           scratch_data.mesh_generator =
@@ -1106,10 +1105,9 @@ main()
         {
           ScratchData<3> scratch_data;
 
-          scratch_data.mapping =
-            hp::MappingCollection<3>(MappingQGeneric<3>(1));
-          scratch_data.fe              = hp::FECollection<3>(FE_DGQ<3>(i));
-          scratch_data.quadrature      = hp::QCollection<3>(QGauss<3>(i + 1));
+          scratch_data.mapping    = hp::MappingCollection<3>(MappingQ<3>(1));
+          scratch_data.fe         = hp::FECollection<3>(FE_DGQ<3>(i));
+          scratch_data.quadrature = hp::QCollection<3>(QGauss<3>(i + 1));
           scratch_data.face_quadrature = std::vector<hp::QCollection<2>>{
             hp::QCollection<2>(QGauss<2>(i + 1))};
           scratch_data.mesh_generator =
index 49b5b6150f07c572d585ac37d97954cd0b466ef6..4a8ba815d0fada4d1fbffffacd500a996f5e7f49 100644 (file)
@@ -1015,10 +1015,9 @@ main()
         {
           ScratchData<2> scratch_data;
 
-          scratch_data.mapping =
-            hp::MappingCollection<2>(MappingQGeneric<2>(1));
-          scratch_data.fe              = hp::FECollection<2>(FE_DGQ<2>(i));
-          scratch_data.quadrature      = hp::QCollection<2>(QGauss<2>(i + 1));
+          scratch_data.mapping    = hp::MappingCollection<2>(MappingQ<2>(1));
+          scratch_data.fe         = hp::FECollection<2>(FE_DGQ<2>(i));
+          scratch_data.quadrature = hp::QCollection<2>(QGauss<2>(i + 1));
           scratch_data.face_quadrature = std::vector<hp::QCollection<1>>{
             hp::QCollection<1>(QGauss<1>(i + 1))};
           scratch_data.mesh_generator =
@@ -1106,10 +1105,9 @@ main()
         {
           ScratchData<3> scratch_data;
 
-          scratch_data.mapping =
-            hp::MappingCollection<3>(MappingQGeneric<3>(1));
-          scratch_data.fe              = hp::FECollection<3>(FE_DGQ<3>(i));
-          scratch_data.quadrature      = hp::QCollection<3>(QGauss<3>(i + 1));
+          scratch_data.mapping    = hp::MappingCollection<3>(MappingQ<3>(1));
+          scratch_data.fe         = hp::FECollection<3>(FE_DGQ<3>(i));
+          scratch_data.quadrature = hp::QCollection<3>(QGauss<3>(i + 1));
           scratch_data.face_quadrature = std::vector<hp::QCollection<2>>{
             hp::QCollection<2>(QGauss<2>(i + 1))};
           scratch_data.mesh_generator =
index fe0e208ce260205be3470e41864ef5b8e1b50235..52531733a0d8b329c8ff27b39e3cfb337c763f11 100644 (file)
@@ -110,7 +110,7 @@ namespace Step17
     const unsigned int this_mpi_process;
 
 #ifdef HEX
-    MappingQGeneric<dim, dim> mapping;
+    MappingQ<dim, dim> mapping;
 #else
     MappingFE<dim, dim> mapping;
 #endif
index 518a640192808574a2b1bad67c53a8c65f4f6b77..269024ec61d6d9444a7e904c9c72fa15313f17c0 100644 (file)
@@ -241,7 +241,7 @@ namespace Step18
     const Quadrature<dim> quadrature_formula;
 
 #ifdef HEX
-    MappingQGeneric<dim, dim> mapping;
+    MappingQ<dim, dim> mapping;
 #else
     MappingFE<dim, dim>  mapping;
 #endif
index 0c706f037b629b4b76caf2b94025b21cc1ead05f..7102155424662fbdb511385d67fcf958ac31d1ed 100644 (file)
@@ -88,9 +88,9 @@ namespace Step23
 
     Triangulation<dim> triangulation;
 #ifdef HEX
-    MappingQGeneric<dim, dim> mapping;
-    FE_Q<dim>                 fe;
-    QGauss<dim>               quadrature;
+    MappingQ<dim, dim> mapping;
+    FE_Q<dim>          fe;
+    QGauss<dim>        quadrature;
 #else
     MappingFE<dim, dim> mapping;
     FE_SimplexP<dim>    fe;
index 7a670fbe41703d8db322241d63739202a6578874..b040723a55acaaaecf1de6fadfd61b66739482eb 100644 (file)
@@ -119,7 +119,7 @@ namespace Step40
     MPI_Comm mpi_communicator;
 
 #ifdef HEX
-    MappingQGeneric<dim, dim>                 mapping;
+    MappingQ<dim, dim>                        mapping;
     parallel::distributed::Triangulation<dim> triangulation;
     FE_Q<dim>                                 fe;
 #else
index 912b01b9105a313e57a744079bd8e3d042a9f2b0..87cecd642bbdf61fe280e68b9e42821fcaa9296e 100644 (file)
@@ -1909,7 +1909,7 @@ namespace Euler_DG
 #endif
 
 #ifdef HEX
-    MappingQGeneric<dim> mapping;
+    MappingQ<dim> mapping;
 #else
     MappingFE<dim>                                      mapping;
 #endif
index 1c3de3bf81223e577a7e67d7261113a74af772d7..f4a198eaf0b968f1af592d883162acf557dd7402 100644 (file)
@@ -166,7 +166,7 @@ Step4<dim>::setup_system()
   solution.reinit(dof_handler.n_dofs());
   system_rhs.reinit(dof_handler.n_dofs());
 
-  MappingQGeneric<dim>                mapping(1);
+  MappingQ<dim>                       mapping(1);
   MeshWorker::IntegrationInfoBox<dim> info_box;
   UpdateFlags update_flags = update_values | update_gradients;
   info_box.add_update_flags_all(update_flags);
index 38beda26f97c17a8810f6bd865c9fff25fcf8465..c32bfd4572178d43c2112ae300653faeb8625de8 100644 (file)
@@ -169,7 +169,7 @@ Step4<dim>::setup_system()
   solution.reinit(dof_handler.n_dofs());
   system_rhs.reinit(dof_handler.n_dofs());
 
-  MappingQGeneric<dim>                mapping(1);
+  MappingQ<dim>                       mapping(1);
   MeshWorker::IntegrationInfoBox<dim> info_box;
   UpdateFlags update_flags = update_values | update_gradients;
   info_box.add_update_flags_all(update_flags);
index 6bc6c334aa6a000c38de56c2f50d674ba47e93de..f80ec27a5dcc845d837c597e305fe0cf24273ea3 100644 (file)
@@ -166,7 +166,7 @@ Step4<dim>::setup_system()
   solution.reinit(dof_handler.n_dofs());
   system_rhs.reinit(dof_handler.n_dofs());
 
-  MappingQGeneric<dim>                mapping(1);
+  MappingQ<dim>                       mapping(1);
   MeshWorker::IntegrationInfoBox<dim> info_box;
   UpdateFlags update_flags = update_values | update_gradients;
   info_box.add_update_flags_all(update_flags);
index 3cf4b15551df59b42509b799ba22e2138a50ff34..30f31f3963d74ed3d6da479fb2a965c6be58b6fc 100644 (file)
@@ -20,7 +20,7 @@
 #include <deal.II/fe/fe_system.h>
 #include <deal.II/fe/fe_values.h>
 #include <deal.II/fe/mapping_fe_field.h>
-#include <deal.II/fe/mapping_q_generic.h>
+#include <deal.II/fe/mapping_q.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/tria.h>
@@ -53,7 +53,7 @@ test()
 
   // set up base high-order mapping
   Vector<double> euler_vector_base(dof_handler_dim.n_dofs());
-  VectorTools::get_position_vector(MappingQGeneric<dim, spacedim>(4),
+  VectorTools::get_position_vector(MappingQ<dim, spacedim>(4),
                                    dof_handler_dim,
                                    euler_vector_base);
   MappingFEField<dim, spacedim> mapping_base(dof_handler_dim,
@@ -62,7 +62,7 @@ test()
   // clear manifold
   tria.reset_all_manifolds();
 
-  // output mesh with with MappingQGeneric(degree=4)
+  // output mesh with with MappingQ(degree=4)
   {
     DataOutBase::VtkFlags flags;
 
@@ -71,7 +71,7 @@ test()
     data_out.attach_dof_handler(dof_handler);
 
     data_out.build_patches(
-      MappingQGeneric<dim, spacedim>(4),
+      MappingQ<dim, spacedim>(4),
       fe_degree + 1,
       DataOut<dim, spacedim>::CurvedCellRegion::curved_inner_cells);
 
index dc9ee8cf37c584733c6011e7c7fee8a12a6d57d4..4149e71227c268bc6cdf944602c53494130a76b3 100644 (file)
@@ -144,7 +144,7 @@ namespace PhaseField
     const Functions::ConstantFunction<dim> constant_function_1(1.0);
     function_map[1] = &constant_function_1;
 
-    VectorTools::interpolate_based_on_material_id(MappingQGeneric<dim>(1),
+    VectorTools::interpolate_based_on_material_id(MappingQ<dim>(1),
                                                   dof_handler,
                                                   function_map,
                                                   dst);

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.