From: Wolfgang Bangerth <bangerth@colostate.edu>
Date: Tue, 29 Sep 2020 01:36:05 +0000 (-0600)
Subject: Rename QTrapez to QTrapezoid in examples/.
X-Git-Tag: v9.3.0-rc1~1053^2~5
X-Git-Url: https://gitweb.dealii.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=1a859940abdaafcf5f594de041e08d572829472b;p=dealii.git

Rename QTrapez to QTrapezoid in examples/.
---

diff --git a/examples/step-14/step-14.cc b/examples/step-14/step-14.cc
index 6e812744e9..9e612bd39a 100644
--- a/examples/step-14/step-14.cc
+++ b/examples/step-14/step-14.cc
@@ -206,7 +206,7 @@ namespace Step14
 
       // ...then have some objects of which the meaning will become clear
       // below...
-      QTrapez<dim>                vertex_quadrature;
+      QTrapezoid<dim>             vertex_quadrature;
       FEValues<dim>               fe_values(dof_handler.get_fe(),
                               vertex_quadrature,
                               update_gradients | update_quadrature_points);
diff --git a/examples/step-18/step-18.cc b/examples/step-18/step-18.cc
index d6b937b936..327e1967eb 100644
--- a/examples/step-18/step-18.cc
+++ b/examples/step-18/step-18.cc
@@ -1463,7 +1463,7 @@ namespace Step18
   // In this context, it is instructive to point out what a more general way
   // would be. For general finite elements, the way to go would be to take a
   // quadrature formula with the quadrature points in the vertices of a
-  // cell. The <code>QTrapez</code> formula for the trapezoidal rule does
+  // cell. The <code>QTrapezoid</code> formula for the trapezoidal rule does
   // exactly this. With this quadrature formula, we would then initialize an
   // <code>FEValues</code> object in each cell, and use the
   // <code>FEValues::get_function_values</code> function to obtain the values
diff --git a/examples/step-19/step-19.cc b/examples/step-19/step-19.cc
index c882662750..48ad730f16 100644
--- a/examples/step-19/step-19.cc
+++ b/examples/step-19/step-19.cc
@@ -826,8 +826,8 @@ namespace Step19
     // discussion in the introduction.
     else
       {
-        const QTrapez<dim> vertex_quadrature;
-        FEValues<dim>      fe_values(fe, vertex_quadrature, update_gradients);
+        const QTrapezoid<dim> vertex_quadrature;
+        FEValues<dim> fe_values(fe, vertex_quadrature, update_gradients);
 
         std::vector<Tensor<1, dim>> field_gradients(vertex_quadrature.size());
 
diff --git a/examples/step-20/step-20.cc b/examples/step-20/step-20.cc
index c4e64df7a2..e8bbd2faca 100644
--- a/examples/step-20/step-20.cc
+++ b/examples/step-20/step-20.cc
@@ -716,7 +716,7 @@ namespace Step20
     // points for integration. To avoid this problem, we simply use a
     // trapezoidal rule and iterate it <code>degree+2</code> times in each
     // coordinate direction (again as explained in step-7):
-    QTrapez<1>     q_trapez;
+    QTrapezoid<1>  q_trapez;
     QIterated<dim> quadrature(q_trapez, degree + 2);
 
     // With this, we can then let the library compute the errors and output
diff --git a/examples/step-31/step-31.cc b/examples/step-31/step-31.cc
index 27fe2bc106..c029702952 100644
--- a/examples/step-31/step-31.cc
+++ b/examples/step-31/step-31.cc
@@ -582,7 +582,7 @@ namespace Step31
   // on each cell. To this end, recall that if we had a single $Q_1$ field
   // (rather than the vector-valued field of higher order) then the maximum
   // would be attained at a vertex of the mesh. In other words, we should use
-  // the QTrapez class that has quadrature points only at the vertices of
+  // the QTrapezoid class that has quadrature points only at the vertices of
   // cells.
   //
   // For higher order shape functions, the situation is more complicated: the
@@ -600,15 +600,15 @@ namespace Step31
   // FiniteElement::get_unit_support_points() function, reduce the output to a
   // unique set of points to avoid duplicate function evaluations, and create
   // a Quadrature object using these points. Another option, chosen here, is
-  // to use the QTrapez class and combine it with the QIterated class that
-  // repeats the QTrapez formula on a number of sub-cells in each coordinate
+  // to use the QTrapezoid class and combine it with the QIterated class that
+  // repeats the QTrapezoid formula on a number of sub-cells in each coordinate
   // direction. To cover all support points, we need to iterate it
   // <code>stokes_degree+1</code> times since this is the polynomial degree of
   // the Stokes element in use:
   template <int dim>
   double BoussinesqFlowProblem<dim>::get_maximal_velocity() const
   {
-    const QIterated<dim> quadrature_formula(QTrapez<1>(), stokes_degree + 1);
+    const QIterated<dim> quadrature_formula(QTrapezoid<1>(), stokes_degree + 1);
     const unsigned int   n_q_points = quadrature_formula.size();
 
     FEValues<dim> fe_values(stokes_fe, quadrature_formula, update_values);
@@ -661,7 +661,8 @@ namespace Step31
   std::pair<double, double>
   BoussinesqFlowProblem<dim>::get_extrapolated_temperature_range() const
   {
-    const QIterated<dim> quadrature_formula(QTrapez<1>(), temperature_degree);
+    const QIterated<dim> quadrature_formula(QTrapezoid<1>(),
+                                            temperature_degree);
     const unsigned int   n_q_points = quadrature_formula.size();
 
     FEValues<dim> fe_values(temperature_fe, quadrature_formula, update_values);
diff --git a/examples/step-32/step-32.cc b/examples/step-32/step-32.cc
index f74c6f741f..4cfac9d552 100644
--- a/examples/step-32/step-32.cc
+++ b/examples/step-32/step-32.cc
@@ -1264,7 +1264,7 @@ namespace Step32
   template <int dim>
   double BoussinesqFlowProblem<dim>::get_maximal_velocity() const
   {
-    const QIterated<dim> quadrature_formula(QTrapez<1>(),
+    const QIterated<dim> quadrature_formula(QTrapezoid<1>(),
                                             parameters.stokes_velocity_degree);
     const unsigned int   n_q_points = quadrature_formula.size();
 
@@ -1306,7 +1306,7 @@ namespace Step32
   template <int dim>
   double BoussinesqFlowProblem<dim>::get_cfl_number() const
   {
-    const QIterated<dim> quadrature_formula(QTrapez<1>(),
+    const QIterated<dim> quadrature_formula(QTrapezoid<1>(),
                                             parameters.stokes_velocity_degree);
     const unsigned int   n_q_points = quadrature_formula.size();
 
@@ -1461,7 +1461,7 @@ namespace Step32
   std::pair<double, double>
   BoussinesqFlowProblem<dim>::get_extrapolated_temperature_range() const
   {
-    const QIterated<dim> quadrature_formula(QTrapez<1>(),
+    const QIterated<dim> quadrature_formula(QTrapezoid<1>(),
                                             parameters.temperature_degree);
     const unsigned int   n_q_points = quadrature_formula.size();
 
diff --git a/examples/step-41/step-41.cc b/examples/step-41/step-41.cc
index 02a5cfc1f4..b54dc855c9 100644
--- a/examples/step-41/step-41.cc
+++ b/examples/step-41/step-41.cc
@@ -345,8 +345,8 @@ namespace Step41
   {
     Assert(fe.degree == 1, ExcNotImplemented());
 
-    const QTrapez<dim> quadrature_formula;
-    FEValues<dim>      fe_values(fe,
+    const QTrapezoid<dim> quadrature_formula;
+    FEValues<dim>         fe_values(fe,
                             quadrature_formula,
                             update_values | update_JxW_values);
 
diff --git a/examples/step-7/step-7.cc b/examples/step-7/step-7.cc
index 44245daadc..0005d83e80 100644
--- a/examples/step-7/step-7.cc
+++ b/examples/step-7/step-7.cc
@@ -897,7 +897,7 @@ namespace Step7
     // error on each cell. Finally, we compute the global L infinity error
     // from the L infinity errors on each cell with a call to
     // VectorTools::compute_global_error.
-    const QTrapez<1>     q_trapez;
+    const QTrapezoid<1>  q_trapez;
     const QIterated<dim> q_iterated(q_trapez, fe->degree * 2 + 1);
     VectorTools::integrate_difference(dof_handler,
                                       solution,