Rename QTrapez to QTrapezoid in examples/.

diff --git a/examples/step-14/step-14.cc b/examples/step-14/step-14.cc
index 6e812744e94374a555a22a743eaf70f76309b8a8..9e612bd39a8170552a3028f2873b87ed8483ae74 100644 (file)
--- 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 d6b937b936a2fd833ff6ca777f6922b471f70984..327e1967ebe629e135e2fd7b75e71291ae2ea266 100644 (file)
--- 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 c88266275001636654ad91dda6880cbaf5c918c6..48ad730f16e1a9be867d35228726a3ace4827f12 100644 (file)
--- 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 c4e64df7a23cd5c7a83a2feb965a33df1c44277d..e8bbd2faca1f4e528fba3c0ec0606f9f6bbcfbb3 100644 (file)
--- 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 27fe2bc106ad6711fdf2513b0e5022e9c319558a..c0297029522af13405a0a14d18ab097007e5b9d5 100644 (file)
--- 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 f74c6f741f8fc140319b833b33386dc2fa457a96..4cfac9d5525a3f8e872c216f1f01e5951cf0a806 100644 (file)
--- 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 02a5cfc1f48674d0540cdfba9735024c0babef79..b54dc855c9db84d3ccc0228ed8cc9537919b3563 100644 (file)
--- 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 44245daadc70fb37f54b74d7aa1ce4c345dc3e42..0005d83e809a7fece2a082aaea27dd951192238f 100644 (file)
--- 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,