]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Use operator^ to create FESystem objects in the tutorials. 11066/head
authorWolfgang Bangerth <bangerth@colostate.edu>
Tue, 20 Oct 2020 19:47:44 +0000 (13:47 -0600)
committerWolfgang Bangerth <bangerth@colostate.edu>
Tue, 4 Jul 2023 04:53:03 +0000 (22:53 -0600)
26 files changed:
examples/step-17/step-17.cc
examples/step-18/step-18.cc
examples/step-20/step-20.cc
examples/step-21/step-21.cc
examples/step-22/step-22.cc
examples/step-29/step-29.cc
examples/step-31/step-31.cc
examples/step-32/step-32.cc
examples/step-33/step-33.cc
examples/step-35/step-35.cc
examples/step-42/step-42.cc
examples/step-43/step-43.cc
examples/step-44/step-44.cc
examples/step-45/step-45.cc
examples/step-46/step-46.cc
examples/step-51/step-51.cc
examples/step-55/step-55.cc
examples/step-56/step-56.cc
examples/step-57/step-57.cc
examples/step-60/step-60.cc
examples/step-61/step-61.cc
examples/step-62/step-62.cc
examples/step-67/step-67.cc
examples/step-68/step-68.cc
examples/step-70/step-70.cc
examples/step-8/step-8.cc

index 6089836ea699a5092c9b67a7ad3ee8a413526135..9db123312641ea595d981cc7b980199358e69963 100644 (file)
@@ -225,7 +225,7 @@ namespace Step17
   // The first step in the actual implementation is the constructor of
   // the main class. Apart from initializing the same member variables
   // that we already had in step-8, we here initialize the MPI
-  // communicator variable we shall use with the global MPI
+  // communicator variable we want to use with the global MPI
   // communicator linking all processes together (in more complex
   // applications, one could here use a communicator object that only
   // links a subset of all processes), and call the Utilities::MPI
@@ -242,7 +242,7 @@ namespace Step17
     , n_mpi_processes(Utilities::MPI::n_mpi_processes(mpi_communicator))
     , this_mpi_process(Utilities::MPI::this_mpi_process(mpi_communicator))
     , pcout(std::cout, (this_mpi_process == 0))
-    , fe(FE_Q<dim>(1), dim)
+    , fe(FE_Q<dim>(1) ^ dim)
     , dof_handler(triangulation)
   {}
 
index 0980521e00dd1d5807f8b4abb3d09fdaaa9f30e7..973b104bb15b82ae8ae2b3e1e81c645ab806553d 100644 (file)
@@ -694,7 +694,7 @@ namespace Step18
   template <int dim>
   TopLevel<dim>::TopLevel()
     : triangulation(MPI_COMM_WORLD)
-    , fe(FE_Q<dim>(1), dim)
+    , fe(FE_Q<dim>(1) ^ dim)
     , dof_handler(triangulation)
     , quadrature_formula(fe.degree + 1)
     , present_time(0.0)
index 2599b02e666484fe34a9e5b59f3a143e49da361b..7676c1eeca9c445b93d0f094fdc2c9675ad0c68f 100644 (file)
@@ -320,7 +320,7 @@ namespace Step20
   template <int dim>
   MixedLaplaceProblem<dim>::MixedLaplaceProblem(const unsigned int degree)
     : degree(degree)
-    , fe(FE_RaviartThomas<dim>(degree), 1, FE_DGQ<dim>(degree), 1)
+    , fe(FE_RaviartThomas<dim>(degree), FE_DGQ<dim>(degree))
     , dof_handler(triangulation)
   {}
 
index bb574b4a298a482d56659c9343dd4018265aec29..59de4bec66bcaae2026c61f099aa9886b761bf4d 100644 (file)
@@ -509,11 +509,8 @@ namespace Step21
   TwoPhaseFlowProblem<dim>::TwoPhaseFlowProblem(const unsigned int degree)
     : degree(degree)
     , fe(FE_RaviartThomas<dim>(degree),
-         1,
          FE_DGQ<dim>(degree),
-         1,
-         FE_DGQ<dim>(degree),
-         1)
+         FE_DGQ<dim>(degree))
     , dof_handler(triangulation)
     , n_refinement_steps(5)
     , time(/*start time*/ 0., /*end time*/ 1.)
index d173f41acf98b986063059ad210efaff38291604..022fbb9bfb3d2829513b881831d756dcb45200ce 100644 (file)
@@ -405,7 +405,7 @@ namespace Step22
   StokesProblem<dim>::StokesProblem(const unsigned int degree)
     : degree(degree)
     , triangulation(Triangulation<dim>::maximum_smoothing)
-    , fe(FE_Q<dim>(degree + 1), dim, FE_Q<dim>(degree), 1)
+    , fe(FE_Q<dim>(degree + 1) ^ dim, FE_Q<dim>(degree))
     , dof_handler(triangulation)
   {}
 
index 765a2868ab5a1d03052829396cba3fdf8b6078e0..ef4d7a46b37794f4fb246f2ff6d31f0ec6b897bb 100644 (file)
@@ -387,13 +387,16 @@ namespace Step29
 
   // The constructor takes the ParameterHandler object and stores it in a
   // reference. It also initializes the DoF-Handler and the finite element
-  // system, which consists of two copies of the scalar Q1 field, one for $v$
-  // and one for $w$:
+  // system, which consists of two copies of the scalar $Q_1$ field, one for
+  // $v$ and one for $w$. In other words, we want the finite element space
+  // $Q_1\times Q_1 = Q_1^2$, which is easily constructed and passed as the
+  // constructor argument to the FESystem class (i.e., the type of the `fe`
+  // member being initialized here):
   template <int dim>
   UltrasoundProblem<dim>::UltrasoundProblem(ParameterHandler &param)
     : prm(param)
     , dof_handler(triangulation)
-    , fe(FE_Q<dim>(1), 2)
+    , fe(FE_Q<dim>(1) ^ 2)
   {}
 
   // @sect4{<code>UltrasoundProblem::make_grid</code>}
@@ -590,7 +593,7 @@ namespace Step29
                 // compute from the given two shape functions.  Fortunately,
                 // the FESystem object can provide us with this information,
                 // namely it has a function
-                // FESystem::system_to_component_index, that for each local
+                // FESystem::system_to_component_index(), that for each local
                 // DoF index returns a pair of integers of which the first
                 // indicates to which component of the system the DoF
                 // belongs. The second integer of the pair indicates which
index 7222de350a337a238bf696436dfdb5e1cfa4b05e..5c97bf0db8bcf29275f24736d54bb23ea59c9f11 100644 (file)
@@ -526,7 +526,7 @@ namespace Step31
   // The constructor of this class is an extension of the constructor in
   // step-22. We need to add the various variables that concern the
   // temperature. As discussed in the introduction, we are going to use
-  // $Q_2\times Q_1$ (Taylor-Hood) elements again for the Stokes part, and
+  // $Q_2^d\times Q_1$ (Taylor-Hood) elements again for the Stokes part, and
   // $Q_2$ elements for the temperature. However, by using variables that
   // store the polynomial degree of the Stokes and temperature finite
   // elements, it is easy to consistently modify the degree of the elements as
@@ -538,7 +538,7 @@ namespace Step31
     : triangulation(Triangulation<dim>::maximum_smoothing)
     , global_Omega_diameter(std::numeric_limits<double>::quiet_NaN())
     , stokes_degree(1)
-    , stokes_fe(FE_Q<dim>(stokes_degree + 1), dim, FE_Q<dim>(stokes_degree), 1)
+    , stokes_fe(FE_Q<dim>(stokes_degree + 1) ^ dim, FE_Q<dim>(stokes_degree))
     , stokes_dof_handler(triangulation)
     ,
 
index e6f3c5af7796e9fb43d0a7d0f0cdd7414eb32a8a..a26812f157d295112868c5a5cc6a2d497a4d864e 100644 (file)
@@ -1190,14 +1190,12 @@ namespace Step32
     mapping(4)
     ,
 
-    stokes_fe(FE_Q<dim>(parameters.stokes_velocity_degree),
-              dim,
+    stokes_fe(FE_Q<dim>(parameters.stokes_velocity_degree) ^ dim,
               (parameters.use_locally_conservative_discretization ?
                  static_cast<const FiniteElement<dim> &>(
                    FE_DGP<dim>(parameters.stokes_velocity_degree - 1)) :
                  static_cast<const FiniteElement<dim> &>(
-                   FE_Q<dim>(parameters.stokes_velocity_degree - 1))),
-              1)
+                   FE_Q<dim>(parameters.stokes_velocity_degree - 1))))
     ,
 
     stokes_dof_handler(triangulation)
index 15ac9725ddabb3168376cca0339dc66443c75a1f..11376d966ed3c0be4b7298a1fc4db848f37c1fd5 100644 (file)
@@ -1377,7 +1377,7 @@ namespace Step33
   template <int dim>
   ConservationLaw<dim>::ConservationLaw(const char *input_filename)
     : mapping()
-    , fe(FE_Q<dim>(1), EulerEquations<dim>::n_components)
+    , fe(FE_Q<dim>(1) ^ EulerEquations<dim>::n_components)
     , dof_handler(triangulation)
     , quadrature(fe.degree + 1)
     , face_quadrature(fe.degree + 1)
index 5b5db632b18413e1155fba08f974a705780700ec..f215b414ab969eeab008a5716afbf9dac1f4d238 100644 (file)
@@ -1291,9 +1291,8 @@ namespace Step35
   void NavierStokesProjection<dim>::output_results(const unsigned int step)
   {
     assemble_vorticity((step == 1));
-    const FESystem<dim> joint_fe(
-      fe_velocity, dim, fe_pressure, 1, fe_velocity, 1);
-    DoFHandler<dim> joint_dof_handler(triangulation);
+    const FESystem<dim> joint_fe(fe_velocity ^ dim, fe_pressure, fe_velocity);
+    DoFHandler<dim>     joint_dof_handler(triangulation);
     joint_dof_handler.distribute_dofs(joint_fe);
     Assert(joint_dof_handler.n_dofs() ==
              ((dim + 1) * dof_handler_velocity.n_dofs() +
index a8d84d047f384a4428a6189201c505b6b85a1602..e6b437ce3673859b102fd684d985fc44e2dae586 100644 (file)
@@ -814,7 +814,7 @@ namespace Step42
         prm.get_integer("number of initial refinements"))
     , triangulation(mpi_communicator)
     , fe_degree(prm.get_integer("polynomial degree"))
-    , fe(FE_Q<dim>(QGaussLobatto<1>(fe_degree + 1)), dim)
+    , fe(FE_Q<dim>(QGaussLobatto<1>(fe_degree + 1)) ^ dim)
     , dof_handler(triangulation)
 
     , e_modulus(200000)
index bbcc2d1a7b8a3892b6c8d5aa2a6fdb03e051de71..f805288e7355911202edbd485a6ae207fb95e889 100644 (file)
@@ -590,7 +590,7 @@ namespace Step43
     , global_Omega_diameter(std::numeric_limits<double>::quiet_NaN())
     , degree(degree)
     , darcy_degree(degree)
-    , darcy_fe(FE_Q<dim>(darcy_degree + 1), dim, FE_Q<dim>(darcy_degree), 1)
+    , darcy_fe(FE_Q<dim>(darcy_degree + 1) ^ dim, FE_Q<dim>(darcy_degree))
     , darcy_dof_handler(triangulation)
     ,
 
index 0e9fcba5c2d3b9297b2313038fee7917124840c7..383441fe4010af2fbcf49e3d31840087022f62df 100644 (file)
@@ -1042,12 +1042,9 @@ namespace Step44
     // condition, while $Q_1 \times DGP_0 \times DGP_0$ elements do
     // not. However, it has been shown that the latter demonstrate good
     // convergence characteristics nonetheless.
-    fe(FE_Q<dim>(parameters.poly_degree),
-       dim, // displacement
-       FE_DGP<dim>(parameters.poly_degree - 1),
-       1, // pressure
-       FE_DGP<dim>(parameters.poly_degree - 1),
-       1) // dilatation
+    fe(FE_Q<dim>(parameters.poly_degree) ^ dim, // displacement
+       FE_DGP<dim>(parameters.poly_degree - 1), // pressure
+       FE_DGP<dim>(parameters.poly_degree - 1)) // dilatation
     , dof_handler(triangulation)
     , dofs_per_cell(fe.n_dofs_per_cell())
     , u_fe(first_u_component)
index f7a44ecd1ffe986627242f26f4c49d08657476d2..d19696d8a93583aedbfdbd5a3fc99ea3c7c3bff0 100644 (file)
@@ -291,7 +291,7 @@ namespace Step45
     : degree(degree)
     , mpi_communicator(MPI_COMM_WORLD)
     , triangulation(mpi_communicator)
-    , fe(FE_Q<dim>(degree + 1), dim, FE_Q<dim>(degree), 1)
+    , fe(FE_Q<dim>(degree + 1) ^ dim, FE_Q<dim>(degree))
     , dof_handler(triangulation)
     , pcout(std::cout, Utilities::MPI::this_mpi_process(mpi_communicator) == 0)
     , mapping(degree + 1)
index 167938cfe5eb137d325ae5d4bc672e3d7fa7a24a..ca0641007cb1ae162c8bfe6ff7fba36a43cacb0b 100644 (file)
@@ -220,18 +220,12 @@ namespace Step46
     : stokes_degree(stokes_degree)
     , elasticity_degree(elasticity_degree)
     , triangulation(Triangulation<dim>::maximum_smoothing)
-    , stokes_fe(FE_Q<dim>(stokes_degree + 1),
-                dim,
-                FE_Q<dim>(stokes_degree),
-                1,
-                FE_Nothing<dim>(),
-                dim)
-    , elasticity_fe(FE_Nothing<dim>(),
-                    dim,
-                    FE_Nothing<dim>(),
-                    1,
-                    FE_Q<dim>(elasticity_degree),
-                    dim)
+    , stokes_fe(FE_Q<dim>(stokes_degree + 1) ^ dim, // for the fluid velocity
+                FE_Q<dim>(stokes_degree),           // for the fluid pressure
+                FE_Nothing<dim>() ^ dim)          // for the solid displacement
+    , elasticity_fe(FE_Nothing<dim>() ^ dim,      // for the fluid velocity
+                    FE_Nothing<dim>(),            // for the fluid pressure
+                    FE_Q<dim>(elasticity_degree)) // for the solid displacement
     , dof_handler(triangulation)
     , viscosity(2)
     , lambda(1)
index 6914a25ea1c8c223906fb5a12a18dc9fc51bb02c..ad1b7be6bb85d1cc225d845f6a8449bc9db6907d 100644 (file)
@@ -383,7 +383,7 @@ namespace Step51
   // gradient/flux part and the scalar part.
   template <int dim>
   HDG<dim>::HDG(const unsigned int degree, const RefinementMode refinement_mode)
-    : fe_local(FE_DGQ<dim>(degree), dim, FE_DGQ<dim>(degree), 1)
+    : fe_local(FE_DGQ<dim>(degree) ^ dim, FE_DGQ<dim>(degree))
     , dof_handler_local(triangulation)
     , fe(degree)
     , dof_handler(triangulation)
index 6b6b671cd827f234eb1e5f3e2b3f8c7e804e1bd1..eee56e9ac898b54269d0a5eeeab8c6559e521781 100644 (file)
@@ -328,7 +328,7 @@ namespace Step55
     : velocity_degree(velocity_degree)
     , viscosity(0.1)
     , mpi_communicator(MPI_COMM_WORLD)
-    , fe(FE_Q<dim>(velocity_degree), dim, FE_Q<dim>(velocity_degree - 1), 1)
+    , fe(FE_Q<dim>(velocity_degree) ^ dim, FE_Q<dim>(velocity_degree - 1))
     , triangulation(mpi_communicator,
                     typename Triangulation<dim>::MeshSmoothing(
                       Triangulation<dim>::smoothing_on_refinement |
index 2322fdcb8f3a4dc81721b0a1356b0b9104a3ce7e..c4cb510a85ddd86b7dbfc71e9d9cf023c32b484e 100644 (file)
@@ -454,11 +454,12 @@ namespace Step56
     , solver_type(solver_type)
     , triangulation(Triangulation<dim>::maximum_smoothing)
     ,
-    // Finite element for the velocity only:
-    velocity_fe(FE_Q<dim>(pressure_degree + 1), dim)
+    // Finite element for the velocity only -- we choose the
+    // $Q_{\text{pressure_degree}}^d$ element:
+    velocity_fe(FE_Q<dim>(pressure_degree + 1) ^ dim)
     ,
     // Finite element for the whole system:
-    fe(velocity_fe, 1, FE_Q<dim>(pressure_degree), 1)
+    fe(velocity_fe, FE_Q<dim>(pressure_degree))
     , dof_handler(triangulation)
     , velocity_dof_handler(triangulation)
     , computing_timer(std::cout, TimerOutput::never, TimerOutput::wall_times)
index 4acd4f5069d6bafc4504728d10f059796b053fc1..395c6d05d2336133c66e10694f5068dd209a439f 100644 (file)
@@ -265,7 +265,7 @@ namespace Step57
     , gamma(1.0)
     , degree(degree)
     , triangulation(Triangulation<dim>::maximum_smoothing)
-    , fe(FE_Q<dim>(degree + 1), dim, FE_Q<dim>(degree), 1)
+    , fe(FE_Q<dim>(degree + 1) ^ dim, FE_Q<dim>(degree))
     , dof_handler(triangulation)
   {}
 
index 9e1bcd7dcc2a145317363c0bd31ee5def77d4d8f..b0fb18fc200f804fb8cdbd74e805ffbb057369ad 100644 (file)
@@ -647,7 +647,7 @@ namespace Step60
 
     embedded_configuration_fe = std::make_unique<FESystem<dim, spacedim>>(
       FE_Q<dim, spacedim>(
-        parameters.embedded_configuration_finite_element_degree),
+        parameters.embedded_configuration_finite_element_degree) ^
       spacedim);
 
     embedded_configuration_dh =
index f6bf740857400e5181dc05b74bc2faf99ce4de10..e7c73a730df9698ada32522e8285cd5f2f0a509f 100644 (file)
@@ -260,7 +260,7 @@ namespace Step61
   // interface pressures, $p^\circ$ and $p^\partial$.
   template <int dim>
   WGDarcyEquation<dim>::WGDarcyEquation(const unsigned int degree)
-    : fe(FE_DGQ<dim>(degree), 1, FE_FaceQ<dim>(degree), 1)
+    : fe(FE_DGQ<dim>(degree), FE_FaceQ<dim>(degree))
     , dof_handler(triangulation)
     , fe_dgrt(degree)
     , dof_handler_dgrt(triangulation)
index 551ac1b4e39b310c766a450f40226f5501ae2601..fbaba8d938064863aa7b80a57fc7eb8ea3fcdc62 100644 (file)
@@ -710,7 +710,7 @@ namespace step62
                       Triangulation<dim>::smoothing_on_refinement |
                       Triangulation<dim>::smoothing_on_coarsening))
     , quadrature_formula(2)
-    , fe(FE_Q<dim>(1), dim)
+    , fe(FE_Q<dim>(1) ^ dim)
     , dof_handler(triangulation)
     , frequency(parameters.nb_frequency_points)
     , probe_positions(parameters.nb_probe_points, dim)
index 0e13d851f973d77abb419cb38c7307e2b6ae17e1..fb127ff0bda1894aea446852a639e5ed4a8dc970 100644 (file)
@@ -1934,7 +1934,7 @@ namespace Euler_DG
 #ifdef DEAL_II_WITH_P4EST
     , triangulation(MPI_COMM_WORLD)
 #endif
-    , fe(FE_DGQ<dim>(fe_degree), dim + 2)
+    , fe(FE_DGQ<dim>(fe_degree) ^ (dim + 2))
     , mapping(fe_degree)
     , dof_handler(triangulation)
     , timer(pcout, TimerOutput::never, TimerOutput::wall_times)
index 47680ef3956a6fcc395a2e538e81c2244271012e..b451131f2ff79b0ebce2928406b29d0ae67e43fe 100644 (file)
@@ -305,7 +305,7 @@ namespace Step68
     , mpi_communicator(MPI_COMM_WORLD)
     , background_triangulation(mpi_communicator)
     , fluid_dh(background_triangulation)
-    , fluid_fe(FE_Q<dim>(par.velocity_degree), dim)
+    , fluid_fe(FE_Q<dim>(par.velocity_degree) ^ dim)
     , pcout(std::cout, Utilities::MPI::this_mpi_process(mpi_communicator) == 0)
     , interpolated_velocity(interpolated_velocity)
 
index 011964a3e1f14989bad6b9a13638ad21f9657d14..c71a9cfdf6a10ee4d57ad6b504466766c8a9da35 100644 (file)
@@ -1191,12 +1191,9 @@ namespace Step70
   {
     TimerOutput::Scope t(computing_timer, "Initial setup");
 
-    fluid_fe =
-      std::make_unique<FESystem<spacedim>>(FE_Q<spacedim>(par.velocity_degree),
-                                           spacedim,
-                                           FE_Q<spacedim>(par.velocity_degree -
-                                                          1),
-                                           1);
+    fluid_fe = std::make_unique<FESystem<spacedim>>(
+      FE_Q<spacedim>(par.velocity_degree) ^ spacedim,
+      FE_Q<spacedim>(par.velocity_degree - 1));
 
 
     solid_fe = std::make_unique<FE_Nothing<dim, spacedim>>();
index 9d4be1af3da3c91e6ee89d20edc7973cfee55850..4063c92e5b9cd0a6c54fbf0c465311b26a1adcfb 100644 (file)
@@ -189,12 +189,26 @@ namespace Step8
   // the solution function has, which is <code>dim</code> since we consider
   // displacement in each space direction. The FESystem class can handle this:
   // we pass it the finite element of which we would like to compose the
-  // system of, and how often it shall be repeated:
-
+  // system of, and how often to repeat it. There are different ways to
+  // tell the FESystem constructor how to do this, but the one that is
+  // closest to mathematical notation is to write out what we want to do
+  // mathematically: We want to construct the finite element space
+  // $Q_1^d$ where the index 1 corresponds to the polynomial degree and
+  // the exponent $d$ to the space dimension -- because the *displacement*
+  // we try to simulate here is a vector with exactly $d$ components. The
+  // FESystem class then lets us create this space by initialization with
+  // `FE_Q<dim>(1)^dim`, emulating the mathematical notation.
+  //
+  // (We could also have written `fe(FE_Q<dim>(1), dim)`, which would simply
+  // have called a different constructor of the FESystem class that first
+  // takes the "base element" and then a "multiplicity", i.e., a number that
+  // indicates how many times the base element is to be repeated. The two
+  // ways of writing things are entirely equivalent; we choose the one that
+  // is closer to mathematical notation.)
   template <int dim>
   ElasticProblem<dim>::ElasticProblem()
     : dof_handler(triangulation)
-    , fe(FE_Q<dim>(1), dim)
+    , fe(FE_Q<dim>(1) ^ dim)
   {}
   // In fact, the FESystem class has several more constructors which can
   // perform more complex operations than just stacking together several

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.