]> https://gitweb.dealii.org/ - dealii.git/commitdiff
use FEEval::normal_vector() to be consistent with FEValues and FEPEval 15304/head
authorJohannes Heinz <johannes.heinz@tuwien.ac.at>
Mon, 5 Jun 2023 13:20:40 +0000 (15:20 +0200)
committerJohannes Heinz <johannes.heinz@tuwien.ac.at>
Wed, 7 Jun 2023 06:06:24 +0000 (08:06 +0200)
25 files changed:
doc/doxygen/headers/matrixfree.h
examples/step-59/step-59.cc
examples/step-67/step-67.cc
examples/step-76/step-76.cc
include/deal.II/matrix_free/face_info.h
include/deal.II/matrix_free/fe_evaluation.h
include/deal.II/matrix_free/fe_evaluation_data.h
tests/matrix_free/advect_1d.cc
tests/matrix_free/advect_1d_deprecated.cc [new file with mode: 0644]
tests/matrix_free/advect_1d_deprecated.output [new file with mode: 0644]
tests/matrix_free/advect_1d_system.cc
tests/matrix_free/advect_1d_vectorization_mask.cc
tests/matrix_free/compare_faces_by_cells.cc
tests/matrix_free/ecl.h
tests/matrix_free/element_birth_and_death_01.cc
tests/matrix_free/interpolate_functions_common.h
tests/matrix_free/matrix_vector_faces_35.cc
tests/matrix_free/matrix_vector_faces_common.h
tests/matrix_free/multigrid_dg_periodic.cc
tests/matrix_free/multigrid_dg_sip_01.cc
tests/matrix_free/multigrid_dg_sip_02.cc
tests/performance/timing_navier_stokes.cc
tests/simplex/matrix_free_03.cc
tests/simplex/step-12c.cc
tests/simplex/step-67.cc

index a153519370747189495dd81c751995fee63ae94e..67cdf52fb00ef475c482e127a642aee5df140d27 100644 (file)
@@ -211,7 +211,7 @@ digraph G
  * information, respectively. Besides access to the function values with
  * FEEvaluationAccess::get_value() or gradients with
  * FEEvaluationAccess::get_gradient(), the face evaluator also enables the
- * access to the normal vector by FEEvaluationAccess::get_normal_vector() and
+ * access to the normal vector by FEEvaluationAccess::normal_vector() and
  * a specialized field FEEvaluationAccess::get_normal_derivative(), which
  * returns the derivative of the solution field normal to the face. This
  * quantity is computed as the gradient (in real space) multiplied by the
index 980185edef25a21ad91d3d508273164783ac481c..a079ff559f37a7636de729acf1f07790a2b2c25d 100644 (file)
@@ -579,9 +579,9 @@ namespace Step59
         // take the absolute value of these factors as the normal could point
         // into either positive or negative direction.
         const VectorizedArray<number> inverse_length_normal_to_face =
-          0.5 * (std::abs((phi_inner.get_normal_vector(0) *
+          0.5 * (std::abs((phi_inner.normal_vector(0) *
                            phi_inner.inverse_jacobian(0))[dim - 1]) +
-                 std::abs((phi_outer.get_normal_vector(0) *
+                 std::abs((phi_outer.normal_vector(0) *
                            phi_outer.inverse_jacobian(0))[dim - 1]));
         const VectorizedArray<number> sigma =
           inverse_length_normal_to_face * get_penalty_factor();
@@ -680,9 +680,8 @@ namespace Step59
                                   EvaluationFlags::values |
                                     EvaluationFlags::gradients);
 
-        const VectorizedArray<number> inverse_length_normal_to_face =
-          std::abs((phi_inner.get_normal_vector(0) *
-                    phi_inner.inverse_jacobian(0))[dim - 1]);
+        const VectorizedArray<number> inverse_length_normal_to_face = std::abs((
+          phi_inner.normal_vector(0) * phi_inner.inverse_jacobian(0))[dim - 1]);
         const VectorizedArray<number> sigma =
           inverse_length_normal_to_face * get_penalty_factor();
 
@@ -1134,9 +1133,8 @@ namespace Step59
       {
         phi_face.reinit(face);
 
-        const VectorizedArray<double> inverse_length_normal_to_face =
-          std::abs((phi_face.get_normal_vector(0) *
-                    phi_face.inverse_jacobian(0))[dim - 1]);
+        const VectorizedArray<double> inverse_length_normal_to_face = std::abs(
+          (phi_face.normal_vector(0) * phi_face.inverse_jacobian(0))[dim - 1]);
         const VectorizedArray<double> sigma =
           inverse_length_normal_to_face * system_matrix.get_penalty_factor();
 
@@ -1169,7 +1167,7 @@ namespace Step59
                   {
                     Tensor<1, dim> normal;
                     for (unsigned int d = 0; d < dim; ++d)
-                      normal[d] = phi_face.get_normal_vector(q)[d][v];
+                      normal[d] = phi_face.normal_vector(q)[d][v];
                     test_normal_derivative[v] =
                       -normal * exact_solution.gradient(single_point);
                   }
index c76c6e09db9a8cebdddf6e0bcd88ba17d81d5935..95a814c5c3bfe473e131adf74dac9e27401b074e 100644 (file)
@@ -1125,7 +1125,7 @@ namespace Euler_DG
             const auto numerical_flux =
               euler_numerical_flux<dim>(phi_m.get_value(q),
                                         phi_p.get_value(q),
-                                        phi_m.get_normal_vector(q));
+                                        phi_m.normal_vector(q));
             phi_m.submit_value(-numerical_flux, q);
             phi_p.submit_value(numerical_flux, q);
           }
@@ -1205,7 +1205,7 @@ namespace Euler_DG
         for (unsigned int q = 0; q < phi.n_q_points; ++q)
           {
             const auto w_m    = phi.get_value(q);
-            const auto normal = phi.get_normal_vector(q);
+            const auto normal = phi.normal_vector(q);
 
             auto rho_u_dot_n = w_m[1] * normal[0];
             for (unsigned int d = 1; d < dim; ++d)
index c66a6ac44b9361e05cbda35ce24b1a7ed93304a4..d720b534095b654c1a7844a9a78336b9abc747f4 100644 (file)
@@ -812,7 +812,7 @@ namespace Euler_DG
                         const auto numerical_flux =
                           euler_numerical_flux<dim>(phi_m.get_value(q),
                                                     phi_p.get_value(q),
-                                                    phi_m.get_normal_vector(q));
+                                                    phi_m.normal_vector(q));
                         phi_m.submit_value(-numerical_flux, q);
                       }
                   }
@@ -825,7 +825,7 @@ namespace Euler_DG
                     for (unsigned int q = 0; q < phi_m.n_q_points; ++q)
                       {
                         const auto w_m    = phi_m.get_value(q);
-                        const auto normal = phi_m.get_normal_vector(q);
+                        const auto normal = phi_m.normal_vector(q);
 
                         auto rho_u_dot_n = w_m[1] * normal[0];
                         for (unsigned int d = 1; d < dim; ++d)
index 1fc018fe952977f29c603e848c4110eeba3a06b7..180bfd009b8fa791c6a5ee8275b5ad1a26060202 100644 (file)
@@ -56,7 +56,7 @@ namespace internal
       /**
        * Indices of the faces in the current face batch as compared to the
        * numbers of the cells on the logical "interior" side of the face which
-       * is aligned to the direction of FEEvaluation::get_normal_vector().
+       * is aligned to the direction of FEEvaluation::normal_vector().
        */
       std::array<unsigned int, vectorization_width> cells_interior;
 
@@ -64,7 +64,7 @@ namespace internal
        * Indices of the faces in the current face batch as compared to the
        * numbers of the cells on the logical "exterior" side of the face which
        * is aligned to the opposite direction of
-       * FEEvaluation::get_normal_vector(). Note that the distinction into
+       * FEEvaluation::normal_vector(). Note that the distinction into
        * interior and exterior faces is purely logical and refers to the
        * direction of the normal only. In the actual discretization of a
        * problem, the discretization typically needs to make sure that interior
index 077067d7a697692e667cdcd7e85f6c0d63413c28..fb482e5a254f27bf49be00302966860525219e8a 100644 (file)
@@ -365,7 +365,7 @@ public:
    * to the face: $\boldsymbol \nabla u(\mathbf x_q) \cdot \mathbf n(\mathbf
    * x_q)$
    *
-   * This call is equivalent to calling get_gradient() * get_normal_vector()
+   * This call is equivalent to calling get_gradient() * normal_vector()
    * but will use a more efficient internal representation of data.
    *
    * @note The derived class FEEvaluationAccess overloads this operation
index 20e2fb2ab2321d0fdbc61a52c35784bd1358f154..b188a05a6b3dfaeec188a9f809ddbb87ce0e9c07 100644 (file)
@@ -227,6 +227,14 @@ public:
    * @note Only implemented in case `is_face == true`.
    */
   Tensor<1, dim, Number>
+  normal_vector(const unsigned int q_point) const;
+
+  /**
+   * Same as `normal_vector(const unsigned int q_point)`.
+   *
+   * @warning  This function will be deprecated!
+   */
+  Tensor<1, dim, Number>
   get_normal_vector(const unsigned int q_point) const;
 
   /** @} */
@@ -1260,7 +1268,7 @@ FEEvaluationData<dim, Number, is_face>::reinit_face(
 
 template <int dim, typename Number, bool is_face>
 inline DEAL_II_ALWAYS_INLINE Tensor<1, dim, Number>
-FEEvaluationData<dim, Number, is_face>::get_normal_vector(
+FEEvaluationData<dim, Number, is_face>::normal_vector(
   const unsigned int q_point) const
 {
   AssertIndexRange(q_point, n_quadrature_points);
@@ -1275,6 +1283,17 @@ FEEvaluationData<dim, Number, is_face>::get_normal_vector(
 
 
 
+// This function is deprecated.
+template <int dim, typename Number, bool is_face>
+inline DEAL_II_ALWAYS_INLINE Tensor<1, dim, Number>
+FEEvaluationData<dim, Number, is_face>::get_normal_vector(
+  const unsigned int q_point) const
+{
+  return normal_vector(q_point);
+}
+
+
+
 template <int dim, typename Number, bool is_face>
 inline DEAL_II_ALWAYS_INLINE Number
 FEEvaluationData<dim, Number, is_face>::JxW(const unsigned int q_point) const
index 063de99da3f49764e3efd02fe878171e4a02812a..af5d943bbaa5bd06dbb8e1fc07e76ee6021e30f8 100644 (file)
@@ -151,7 +151,7 @@ private:
             value_type u_minus = phi_m.get_value(q),
                        u_plus  = phi_p.get_value(q);
             const VectorizedArray<number> normal_times_advection =
-              advection * phi_m.get_normal_vector(q);
+              advection * phi_m.normal_vector(q);
             const value_type flux_times_normal =
               make_vectorized_array<number>(0.5) *
               ((u_minus + u_plus) * normal_times_advection +
@@ -193,7 +193,7 @@ private:
             value_type                    u_minus = fe_eval.get_value(q);
             value_type                    u_plus  = -u_minus;
             const VectorizedArray<number> normal_times_advection =
-              advection * fe_eval.get_normal_vector(q);
+              advection * fe_eval.normal_vector(q);
             const value_type flux_times_normal =
               make_vectorized_array<number>(0.5) *
               ((u_minus + u_plus) * normal_times_advection +
diff --git a/tests/matrix_free/advect_1d_deprecated.cc b/tests/matrix_free/advect_1d_deprecated.cc
new file mode 100644 (file)
index 0000000..9374fb6
--- /dev/null
@@ -0,0 +1,327 @@
+// ---------------------------------------------------------------------
+//
+// Copyright (C) 2018 - 2022 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.
+//
+// ---------------------------------------------------------------------
+
+
+
+// Same as advect_1d.cc using the deprecated FEEval::get_normal_vector()
+// to ensure user code is not broken. This test can be removed once
+// get_normal_vector() is removed.
+
+#include <deal.II/base/function.h>
+#include <deal.II/base/quadrature_lib.h>
+
+#include <deal.II/fe/fe_dgq.h>
+
+#include <deal.II/grid/grid_generator.h>
+#include <deal.II/grid/grid_tools.h>
+#include <deal.II/grid/tria.h>
+
+#include <deal.II/lac/la_parallel_vector.h>
+
+#include <deal.II/matrix_free/fe_evaluation.h>
+#include <deal.II/matrix_free/matrix_free.h>
+#include <deal.II/matrix_free/operators.h>
+
+#include <deal.II/numerics/vector_tools.h>
+
+#include "../tests.h"
+
+
+
+template <int dim,
+          int fe_degree,
+          int n_q_points_1d   = fe_degree + 1,
+          typename number     = double,
+          typename VectorType = Vector<number>,
+          int n_components    = 1>
+class MatrixFreeAdvectionBasic
+{
+public:
+  MatrixFreeAdvectionBasic(const MatrixFree<dim, number> &data,
+                           const bool         zero_within_loop       = true,
+                           const unsigned int start_vector_component = 0)
+    : data(data)
+    , zero_within_loop(zero_within_loop)
+    , start_vector_component(start_vector_component)
+  {
+    for (unsigned int d = 0; d < dim; ++d)
+      advection[d] = 0.4 + 0.12 * d;
+  }
+
+  void
+  vmult(VectorType &dst, const VectorType &src) const
+  {
+    if (!zero_within_loop)
+      dst = 0;
+    data.loop(&MatrixFreeAdvectionBasic::local_apply,
+              &MatrixFreeAdvectionBasic::local_apply_face,
+              &MatrixFreeAdvectionBasic::local_apply_boundary_face,
+              this,
+              dst,
+              src,
+              zero_within_loop,
+              MatrixFree<dim, number>::DataAccessOnFaces::values,
+              MatrixFree<dim, number>::DataAccessOnFaces::values);
+
+    FEEvaluation<dim, fe_degree, fe_degree + 1, n_components, number> phi(data);
+
+    const unsigned int dofs_per_cell = phi.dofs_per_cell;
+
+    AlignedVector<VectorizedArray<number>> coefficients(phi.dofs_per_cell);
+    MatrixFreeOperators::
+      CellwiseInverseMassMatrix<dim, fe_degree, n_components, number>
+        inverse(phi);
+
+    for (unsigned int cell = 0; cell < data.n_cell_batches(); ++cell)
+      {
+        phi.reinit(cell);
+        phi.read_dof_values(dst);
+
+        inverse.fill_inverse_JxW_values(coefficients);
+        inverse.apply(coefficients,
+                      n_components,
+                      phi.begin_dof_values(),
+                      phi.begin_dof_values());
+
+        phi.set_dof_values(dst);
+      }
+  }
+
+private:
+  void
+  local_apply(const MatrixFree<dim, number> &              data,
+              VectorType &                                 dst,
+              const VectorType &                           src,
+              const std::pair<unsigned int, unsigned int> &cell_range) const
+  {
+    FEEvaluation<dim, fe_degree, n_q_points_1d, n_components, number> phi(
+      data, 0, 0, start_vector_component);
+
+    for (unsigned int cell = cell_range.first; cell < cell_range.second; ++cell)
+      {
+        phi.reinit(cell);
+        phi.read_dof_values(src);
+        phi.evaluate(EvaluationFlags::values);
+        for (unsigned int q = 0; q < phi.n_q_points; ++q)
+          phi.submit_gradient(advection * phi.get_value(q), q);
+        phi.integrate(EvaluationFlags::gradients);
+        phi.distribute_local_to_global(dst);
+      }
+  }
+
+  void
+  local_apply_face(
+    const MatrixFree<dim, number> &              data,
+    VectorType &                                 dst,
+    const VectorType &                           src,
+    const std::pair<unsigned int, unsigned int> &face_range) const
+  {
+    FEFaceEvaluation<dim, fe_degree, n_q_points_1d, n_components, number> phi_m(
+      data, true, 0, 0, start_vector_component);
+    FEFaceEvaluation<dim, fe_degree, n_q_points_1d, n_components, number> phi_p(
+      data, false, 0, 0, start_vector_component);
+    using value_type = typename FEFaceEvaluation<dim,
+                                                 fe_degree,
+                                                 n_q_points_1d,
+                                                 n_components,
+                                                 number>::value_type;
+
+    for (unsigned int face = face_range.first; face < face_range.second; ++face)
+      {
+        phi_m.reinit(face);
+        phi_m.read_dof_values(src);
+        phi_m.evaluate(EvaluationFlags::values);
+        phi_p.reinit(face);
+        phi_p.read_dof_values(src);
+        phi_p.evaluate(EvaluationFlags::values);
+
+        for (unsigned int q = 0; q < phi_m.n_q_points; ++q)
+          {
+            value_type u_minus = phi_m.get_value(q),
+                       u_plus  = phi_p.get_value(q);
+            const VectorizedArray<number> normal_times_advection =
+              advection * phi_m.get_normal_vector(q);
+            const value_type flux_times_normal =
+              make_vectorized_array<number>(0.5) *
+              ((u_minus + u_plus) * normal_times_advection +
+               std::abs(normal_times_advection) * (u_minus - u_plus));
+            phi_m.submit_value(-flux_times_normal, q);
+            phi_p.submit_value(flux_times_normal, q);
+          }
+
+        phi_m.integrate(EvaluationFlags::values);
+        phi_m.distribute_local_to_global(dst);
+        phi_p.integrate(EvaluationFlags::values);
+        phi_p.distribute_local_to_global(dst);
+      }
+  }
+
+  void
+  local_apply_boundary_face(
+    const MatrixFree<dim, number> &              data,
+    VectorType &                                 dst,
+    const VectorType &                           src,
+    const std::pair<unsigned int, unsigned int> &face_range) const
+  {
+    FEFaceEvaluation<dim, fe_degree, n_q_points_1d, n_components, number>
+      fe_eval(data, true, 0, 0, start_vector_component);
+    using value_type = typename FEFaceEvaluation<dim,
+                                                 fe_degree,
+                                                 n_q_points_1d,
+                                                 n_components,
+                                                 number>::value_type;
+
+    for (unsigned int face = face_range.first; face < face_range.second; ++face)
+      {
+        fe_eval.reinit(face);
+        fe_eval.read_dof_values(src);
+        fe_eval.evaluate(EvaluationFlags::values);
+
+        for (unsigned int q = 0; q < fe_eval.n_q_points; ++q)
+          {
+            value_type                    u_minus = fe_eval.get_value(q);
+            value_type                    u_plus  = -u_minus;
+            const VectorizedArray<number> normal_times_advection =
+              advection * fe_eval.get_normal_vector(q);
+            const value_type flux_times_normal =
+              make_vectorized_array<number>(0.5) *
+              ((u_minus + u_plus) * normal_times_advection +
+               std::abs(normal_times_advection) * (u_minus - u_plus));
+            fe_eval.submit_value(-flux_times_normal, q);
+          }
+
+        fe_eval.integrate(EvaluationFlags::values);
+        fe_eval.distribute_local_to_global(dst);
+      }
+  }
+
+  const MatrixFree<dim, number> &         data;
+  const bool                              zero_within_loop;
+  const unsigned int                      start_vector_component;
+  Tensor<1, dim, VectorizedArray<number>> advection;
+};
+
+
+
+template <int dim>
+class AnalyticFunction : public Function<dim>
+{
+public:
+  static_assert(dim == 1, "Only 1D implemented");
+  AnalyticFunction()
+    : Function<dim>(1)
+  {}
+
+  virtual double
+  value(const Point<dim> &p, const unsigned int) const override
+  {
+    return std::sin(3 * numbers::PI * p[0] / 0.8);
+  }
+};
+
+
+
+template <int dim>
+class AnalyticDerivative : public Function<dim>
+{
+public:
+  static_assert(dim == 1, "Only 1D implemented");
+  AnalyticDerivative()
+    : Function<dim>(1)
+  {}
+
+  virtual double
+  value(const Point<dim> &p, const unsigned int) const override
+  {
+    Tensor<1, dim> advection;
+    for (unsigned int d = 0; d < dim; ++d)
+      advection[d] = 0.4 + 0.12 * d;
+
+    return -std::cos(3 * numbers::PI * p[0] / 0.8) * advection[0] * 3 *
+           numbers::PI / 0.8;
+  }
+};
+
+
+
+template <int dim, int fe_degree>
+void
+test(const unsigned int n_refine)
+{
+  Triangulation<dim> tria;
+  GridGenerator::hyper_cube(tria, 0, 0.8);
+  tria.refine_global(n_refine);
+
+  FE_DGQ<dim>     fe(fe_degree);
+  DoFHandler<dim> dof(tria);
+  dof.distribute_dofs(fe);
+  AffineConstraints<double> constraints;
+  constraints.close();
+
+  if (n_refine == 3)
+    {
+      deallog << "Testing " << dof.get_fe().get_name();
+      deallog << std::endl;
+    }
+
+  LinearAlgebra::distributed::Vector<double> in, out;
+
+  const QGauss<1>                                  quad(fe_degree + 1);
+  typename MatrixFree<dim, double>::AdditionalData data;
+  data.tasks_parallel_scheme = MatrixFree<dim, double>::AdditionalData::none;
+  data.mapping_update_flags_inner_faces =
+    (update_gradients | update_JxW_values);
+  data.mapping_update_flags_boundary_faces =
+    (update_gradients | update_JxW_values);
+
+  MatrixFree<dim, double> mf_data;
+  mf_data.reinit(MappingQ1<dim>{}, dof, constraints, quad, data);
+
+  mf_data.initialize_dof_vector(in);
+  mf_data.initialize_dof_vector(out);
+
+  VectorTools::interpolate(dof, AnalyticFunction<dim>(), in);
+
+  MatrixFreeAdvectionBasic<dim,
+                           fe_degree,
+                           fe_degree + 1,
+                           double,
+                           LinearAlgebra::distributed::Vector<double>>
+    mf2(mf_data);
+  mf2.vmult(out, in);
+
+  VectorTools::interpolate(dof, AnalyticDerivative<dim>(), in);
+  out -= in;
+
+  double diff_norm = out.linfty_norm();
+  deallog << "Norm of difference:          " << diff_norm << ' ' << std::endl;
+}
+
+
+
+int
+main()
+{
+  initlog();
+
+  for (unsigned int r = 3; r < 9; ++r)
+    test<1, 2>(r);
+
+  for (unsigned int r = 3; r < 9; ++r)
+    test<1, 4>(r);
+
+  for (unsigned int r = 3; r < 9; ++r)
+    test<1, 5>(r);
+}
diff --git a/tests/matrix_free/advect_1d_deprecated.output b/tests/matrix_free/advect_1d_deprecated.output
new file mode 100644 (file)
index 0000000..b213520
--- /dev/null
@@ -0,0 +1,22 @@
+
+DEAL::Testing FE_DGQ<1>(2)
+DEAL::Norm of difference:          0.531539 
+DEAL::Norm of difference:          0.135407 
+DEAL::Norm of difference:          0.0340112 
+DEAL::Norm of difference:          0.00851279 
+DEAL::Norm of difference:          0.00212882 
+DEAL::Norm of difference:          0.000532245 
+DEAL::Testing FE_DGQ<1>(4)
+DEAL::Norm of difference:          0.00529591 
+DEAL::Norm of difference:          0.000336014 
+DEAL::Norm of difference:          2.10801e-05 
+DEAL::Norm of difference:          1.31874e-06 
+DEAL::Norm of difference:          8.24413e-08 
+DEAL::Norm of difference:          5.15331e-09 
+DEAL::Testing FE_DGQ<1>(5)
+DEAL::Norm of difference:          0.000346887 
+DEAL::Norm of difference:          1.09982e-05 
+DEAL::Norm of difference:          3.44938e-07 
+DEAL::Norm of difference:          1.07881e-08 
+DEAL::Norm of difference:          3.35085e-10 
+DEAL::Norm of difference:          9.72689e-12 
index e1d0ddd8ec2cb318781b22f779a2a4529e85833c..313b5d4db3ceca05e20461ba440c84fb642d3879 100644 (file)
@@ -158,7 +158,7 @@ private:
             value_type u_minus = phi_m.get_value(q),
                        u_plus  = phi_p.get_value(q);
             const VectorizedArray<number> normal_times_advection =
-              advection * phi_m.get_normal_vector(q);
+              advection * phi_m.normal_vector(q);
             const value_type flux_times_normal =
               make_vectorized_array<number>(0.5) *
               ((u_minus + u_plus) * normal_times_advection +
@@ -200,7 +200,7 @@ private:
             value_type                    u_minus = fe_eval.get_value(q);
             value_type                    u_plus  = -u_minus;
             const VectorizedArray<number> normal_times_advection =
-              advection * fe_eval.get_normal_vector(q);
+              advection * fe_eval.normal_vector(q);
             const value_type flux_times_normal =
               make_vectorized_array<number>(0.5) *
               ((u_minus + u_plus) * normal_times_advection +
index db7ea98e0b7c9b5b114af4eb5acbdbe9f2eb25b4..d83d6827be52f5c31df53be983463d8b8ec6dc5b 100644 (file)
@@ -159,7 +159,7 @@ private:
             value_type u_minus = phi_m.get_value(q),
                        u_plus  = phi_p.get_value(q);
             const VectorizedArray<number> normal_times_advection =
-              advection * phi_m.get_normal_vector(q);
+              advection * phi_m.normal_vector(q);
             const value_type flux_times_normal =
               make_vectorized_array<number>(0.5) *
               ((u_minus + u_plus) * normal_times_advection +
@@ -213,7 +213,7 @@ private:
             value_type                    u_minus = fe_eval.get_value(q);
             value_type                    u_plus  = -u_minus;
             const VectorizedArray<number> normal_times_advection =
-              advection * fe_eval.get_normal_vector(q);
+              advection * fe_eval.normal_vector(q);
             const value_type flux_times_normal =
               make_vectorized_array<number>(0.5) *
               ((u_minus + u_plus) * normal_times_advection +
index 8e23091004e103fa11aa74deadd0a9640eb17ae4..6d1c18b1aee994f7783dbd26ded03acb53ca9c38 100644 (file)
@@ -142,8 +142,7 @@ private:
         // penalty parameter because the cell-based method cannot read the
         // sigma parameter on the neighbor
         VectorizedArray<number> sigmaF =
-          std::abs(
-            (phi.get_normal_vector(0) * phi.inverse_jacobian(0))[dim - 1]) *
+          std::abs((phi.normal_vector(0) * phi.inverse_jacobian(0))[dim - 1]) *
           (number)(std::max(fe_degree, 1) * (fe_degree + 1.0)) * 2.0;
 
         // Compute phi part
@@ -178,7 +177,7 @@ private:
         phi.distribute_local_to_global(dst);
 
         // Compute phi_outer part
-        sigmaF = std::abs((phi.get_normal_vector(0) *
+        sigmaF = std::abs((phi.normal_vector(0) *
                            phi_outer.inverse_jacobian(0))[dim - 1]) *
                  (number)(std::max(fe_degree, 1) * (fe_degree + 1.0)) * 2.0;
         for (unsigned int j = 0; j < phi.dofs_per_cell; ++j)
@@ -229,8 +228,7 @@ private:
 
         VectorizedArray<number> local_diagonal_vector[phi.static_dofs_per_cell];
         VectorizedArray<number> sigmaF =
-          std::abs(
-            (phi.get_normal_vector(0) * phi.inverse_jacobian(0))[dim - 1]) *
+          std::abs((phi.normal_vector(0) * phi.inverse_jacobian(0))[dim - 1]) *
           (number)(std::max(1, fe_degree) * (fe_degree + 1.0)) * 2.;
 
         for (unsigned int i = 0; i < phi.dofs_per_cell; ++i)
@@ -277,8 +275,8 @@ private:
           {
             phif.reinit(cell, face);
             VectorizedArray<number> sigmaF =
-              std::abs((phif.get_normal_vector(0) *
-                        phif.inverse_jacobian(0))[dim - 1]) *
+              std::abs(
+                (phif.normal_vector(0) * phif.inverse_jacobian(0))[dim - 1]) *
               (number)(std::max(1, fe_degree) * (fe_degree + 1.0)) * 2.;
 
             std::array<types::boundary_id, VectorizedArray<number>::size()>
index c2d0dc97598b8d926a1d5c8361f1c7ff7115d461..b5e253fad272a21b7f9ff1d34e2b757160dcaee1 100644 (file)
@@ -167,10 +167,10 @@ test(const unsigned int geometry      = 0,
           phi_p.read_dof_values(src);
           phi_p.evaluate(true, true);
           VectorizedArrayType sigmaF =
-            (std::abs((phi_m.get_normal_vector(0) *
-                       phi_m.inverse_jacobian(0))[dim - 1]) +
-             std::abs((phi_m.get_normal_vector(0) *
-                       phi_p.inverse_jacobian(0))[dim - 1])) *
+            (std::abs(
+               (phi_m.normal_vector(0) * phi_m.inverse_jacobian(0))[dim - 1]) +
+             std::abs(
+               (phi_m.normal_vector(0) * phi_p.inverse_jacobian(0))[dim - 1])) *
             (Number)(std::max(fe_degree, 1) * (fe_degree + 1.0));
 
           for (unsigned int q = 0; q < phi_m.n_q_points; ++q)
@@ -200,8 +200,8 @@ test(const unsigned int geometry      = 0,
           phi_m.read_dof_values(src);
           phi_m.evaluate(EvaluationFlags::values | EvaluationFlags::gradients);
           VectorizedArrayType sigmaF =
-            std::abs((phi_m.get_normal_vector(0) *
-                      phi_m.inverse_jacobian(0))[dim - 1]) *
+            std::abs(
+              (phi_m.normal_vector(0) * phi_m.inverse_jacobian(0))[dim - 1]) *
             Number(std::max(fe_degree, 1) * (fe_degree + 1.0)) * 2.0;
 
           for (unsigned int q = 0; q < phi_m.n_q_points; ++q)
@@ -258,7 +258,7 @@ test(const unsigned int geometry      = 0,
                   phi_m.evaluate(EvaluationFlags::values |
                                  EvaluationFlags::gradients);
                   VectorizedArrayType sigmaF =
-                    std::abs((phi_m.get_normal_vector(0) *
+                    std::abs((phi_m.normal_vector(0) *
                               phi_m.inverse_jacobian(0))[dim - 1]) *
                     Number(std::max(fe_degree, 1) * (fe_degree + 1.0)) * 2.0;
 
@@ -291,9 +291,9 @@ test(const unsigned int geometry      = 0,
                                  EvaluationFlags::gradients);
 
                   VectorizedArrayType sigmaF =
-                    (std::abs((phi_m.get_normal_vector(0) *
+                    (std::abs((phi_m.normal_vector(0) *
                                phi_m.inverse_jacobian(0))[dim - 1]) +
-                     std::abs((phi_m.get_normal_vector(0) *
+                     std::abs((phi_m.normal_vector(0) *
                                phi_p.inverse_jacobian(0))[dim - 1])) *
                     (Number)(std::max(fe_degree, 1) * (fe_degree + 1.0));
 
index 53171d0366c481ec8e28d05e5002d376d9d0f0f5..ffa5533ff4e03670d6128fd91a2061959c071345 100644 (file)
@@ -150,7 +150,7 @@ test(const unsigned int n_refinements)
             for (const auto q : phi.quadrature_point_indices())
               {
                 auto gradient = phi.get_gradient(q);
-                auto normal   = phi.get_normal_vector(q);
+                auto normal   = phi.normal_vector(q);
 
                 if (is_interior_face == false) // fix sign!
                   normal *= -1.0;
index 05253c65b3a6054af99f516d976149b6e52c1339..6118067ef36713721f6ac289d3d4d526e109ee5a 100644 (file)
@@ -162,7 +162,7 @@ public:
                 double normal_derivative = 0;
                 for (unsigned int d = 0; d < dim; ++d)
                   normal_derivative += function.gradient(p, 0)[d] *
-                                       fe_evalm.get_normal_vector(q)[d][j];
+                                       fe_evalm.normal_vector(q)[d][j];
                 facem_errors[3] += std::abs(
                   fe_evalm.get_normal_derivative(q)[j] - normal_derivative);
 
@@ -228,7 +228,7 @@ public:
                 double normal_derivative = 0;
                 for (unsigned int d = 0; d < dim; ++d)
                   normal_derivative += function.gradient(p, 0)[d] *
-                                       fe_evalm.get_normal_vector(q)[d][j];
+                                       fe_evalm.normal_vector(q)[d][j];
                 boundary_errors[3] += std::abs(
                   fe_evalm.get_normal_derivative(q)[j] - normal_derivative);
               }
index a87ab23c5ce3f5b1c42dd46329e887ed8306cee4..a0b2587573d142d8d95590eb195602eda1d098aa 100644 (file)
@@ -196,7 +196,7 @@ private:
             value_type u_minus = phi_m.get_value(q),
                        u_plus  = phi_p.get_value(q);
             const VectorizedArrayType normal_times_advection =
-              advection * phi_m.get_normal_vector(q);
+              advection * phi_m.normal_vector(q);
             const value_type flux_times_normal =
               make_vectorized_array<number, VectorizedArrayType::size()>(0.5) *
               ((u_minus + u_plus) * normal_times_advection +
@@ -247,7 +247,7 @@ private:
           {
             value_type                u_minus = fe_eval.get_value(q);
             const VectorizedArrayType normal_times_advection =
-              advection * fe_eval.get_normal_vector(q);
+              advection * fe_eval.normal_vector(q);
             const value_type flux_times_normal =
               make_vectorized_array<number, VectorizedArrayType::size()>(0.5) *
               ((u_minus + u_plus) * normal_times_advection +
index e9c73d46b111d9578260b4fd8f687a7367f03102..54637779334ece904d0cf7d8fd0d1be149662803 100644 (file)
@@ -156,9 +156,9 @@ private:
         fe_eval_neighbor.evaluate(EvaluationFlags::values |
                                   EvaluationFlags::gradients);
         VectorizedArrayType sigmaF =
-          (std::abs((fe_eval.get_normal_vector(0) *
+          (std::abs((fe_eval.normal_vector(0) *
                      fe_eval.inverse_jacobian(0))[dim - 1]) +
-           std::abs((fe_eval.get_normal_vector(0) *
+           std::abs((fe_eval.normal_vector(0) *
                      fe_eval_neighbor.inverse_jacobian(0))[dim - 1])) *
           (number)(std::max(actual_degree, 1) * (actual_degree + 1.0));
 
@@ -217,8 +217,8 @@ private:
         fe_eval.evaluate(EvaluationFlags::values | EvaluationFlags::gradients);
         VectorizedArrayType sigmaF =
           2.0 *
-          std::abs((fe_eval.get_normal_vector(0) *
-                    fe_eval.inverse_jacobian(0))[dim - 1]) *
+          std::abs(
+            (fe_eval.normal_vector(0) * fe_eval.inverse_jacobian(0))[dim - 1]) *
           number(std::max(actual_degree, 1) * (actual_degree + 1.0));
 
         for (unsigned int q = 0; q < fe_eval.n_q_points; ++q)
@@ -362,9 +362,9 @@ private:
                                            EvaluationFlags::gradients);
 
         VectorizedArrayType sigmaF =
-          (std::abs((fe_eval.get_normal_vector(0) *
+          (std::abs((fe_eval.normal_vector(0) *
                      fe_eval.inverse_jacobian(0))[dim - 1]) +
-           std::abs((fe_eval.get_normal_vector(0) *
+           std::abs((fe_eval.normal_vector(0) *
                      fe_eval_neighbor.inverse_jacobian(0))[dim - 1])) *
           (number)(std::max(actual_degree, 1) * (actual_degree + 1.0));
 
@@ -423,8 +423,8 @@ private:
                                 EvaluationFlags::values |
                                   EvaluationFlags::gradients);
         VectorizedArrayType sigmaF =
-          std::abs((fe_eval.get_normal_vector(0) *
-                    fe_eval.inverse_jacobian(0))[dim - 1]) *
+          std::abs(
+            (fe_eval.normal_vector(0) * fe_eval.inverse_jacobian(0))[dim - 1]) *
           number(std::max(actual_degree, 1) * (actual_degree + 1.0)) * 2.0;
 
         for (unsigned int q = 0; q < fe_eval.n_q_points; ++q)
@@ -598,7 +598,7 @@ private:
             value_type u_minus = phi_m.get_value(q),
                        u_plus  = phi_p.get_value(q);
             const VectorizedArrayType normal_times_advection =
-              advection * phi_m.get_normal_vector(q);
+              advection * phi_m.normal_vector(q);
             const value_type flux_times_normal =
               make_vectorized_array<number, VectorizedArrayType::size()>(0.5) *
               ((u_minus + u_plus) * normal_times_advection +
@@ -646,7 +646,7 @@ private:
           {
             value_type                u_minus = fe_eval.get_value(q);
             const VectorizedArrayType normal_times_advection =
-              advection * fe_eval.get_normal_vector(q);
+              advection * fe_eval.normal_vector(q);
             const value_type flux_times_normal =
               make_vectorized_array<number, VectorizedArrayType::size()>(0.5) *
               ((u_minus + u_plus) * normal_times_advection +
index 09606de2149571ad14dbad142c5f51e27d58d21d..bf77ee538f09dd36c8d1ced8dcded1030961ccff 100644 (file)
@@ -208,9 +208,9 @@ private:
         fe_eval_neighbor.evaluate(EvaluationFlags::values |
                                   EvaluationFlags::gradients);
         VectorizedArray<number> sigmaF =
-          (std::abs((fe_eval.get_normal_vector(0) *
+          (std::abs((fe_eval.normal_vector(0) *
                      fe_eval.inverse_jacobian(0))[dim - 1]) +
-           std::abs((fe_eval.get_normal_vector(0) *
+           std::abs((fe_eval.normal_vector(0) *
                      fe_eval_neighbor.inverse_jacobian(0))[dim - 1])) *
           (number)(std::max(fe_degree, 1) * (fe_degree + 1.0));
 
@@ -250,8 +250,8 @@ private:
         fe_eval.read_dof_values(src);
         fe_eval.evaluate(EvaluationFlags::values | EvaluationFlags::gradients);
         VectorizedArray<number> sigmaF =
-          std::abs((fe_eval.get_normal_vector(0) *
-                    fe_eval.inverse_jacobian(0))[dim - 1]) *
+          std::abs(
+            (fe_eval.normal_vector(0) * fe_eval.inverse_jacobian(0))[dim - 1]) *
           (number)(std::max(1, fe_degree) * (fe_degree + 1.0)) * 2.;
 
         for (unsigned int q = 0; q < fe_eval.n_q_points; ++q)
@@ -339,10 +339,9 @@ private:
         phi_outer.reinit(face);
 
         VectorizedArray<number> sigmaF =
-          (std::abs(
-             (phi.get_normal_vector(0) * phi.inverse_jacobian(0))[dim - 1]) +
-           std::abs((phi.get_normal_vector(0) *
-                     phi_outer.inverse_jacobian(0))[dim - 1])) *
+          (std::abs((phi.normal_vector(0) * phi.inverse_jacobian(0))[dim - 1]) +
+           std::abs(
+             (phi.normal_vector(0) * phi_outer.inverse_jacobian(0))[dim - 1])) *
           (number)(std::max(fe_degree, 1) * (fe_degree + 1.0));
 
         // Compute phi part
@@ -426,8 +425,7 @@ private:
         phi.reinit(face);
 
         VectorizedArray<number> sigmaF =
-          std::abs(
-            (phi.get_normal_vector(0) * phi.inverse_jacobian(0))[dim - 1]) *
+          std::abs((phi.normal_vector(0) * phi.inverse_jacobian(0))[dim - 1]) *
           (number)(std::max(1, fe_degree) * (fe_degree + 1.0)) * 2.;
 
         for (unsigned int i = 0; i < phi.dofs_per_cell; ++i)
index 4b813c95b7f8f4606615ce5464cb1be1e6222e3c..c3d7fdf8d1688906235d67232cf868899dd37194 100644 (file)
@@ -217,9 +217,9 @@ private:
         fe_eval_neighbor.evaluate(EvaluationFlags::values |
                                   EvaluationFlags::gradients);
         VectorizedArray<number> sigmaF =
-          (std::abs((fe_eval.get_normal_vector(0) *
+          (std::abs((fe_eval.normal_vector(0) *
                      fe_eval.inverse_jacobian(0))[dim - 1]) +
-           std::abs((fe_eval.get_normal_vector(0) *
+           std::abs((fe_eval.normal_vector(0) *
                      fe_eval_neighbor.inverse_jacobian(0))[dim - 1])) *
           (number)(std::max(fe_degree, 1) * (fe_degree + 1.0));
 
@@ -259,8 +259,8 @@ private:
         fe_eval.read_dof_values(src);
         fe_eval.evaluate(EvaluationFlags::values | EvaluationFlags::gradients);
         VectorizedArray<number> sigmaF =
-          std::abs((fe_eval.get_normal_vector(0) *
-                    fe_eval.inverse_jacobian(0))[dim - 1]) *
+          std::abs(
+            (fe_eval.normal_vector(0) * fe_eval.inverse_jacobian(0))[dim - 1]) *
           number(std::max(fe_degree, 1) * (fe_degree + 1.0)) * 2.0;
 
         for (unsigned int q = 0; q < fe_eval.n_q_points; ++q)
@@ -346,10 +346,9 @@ private:
         phi_outer.reinit(face);
 
         VectorizedArray<number> sigmaF =
-          (std::abs(
-             (phi.get_normal_vector(0) * phi.inverse_jacobian(0))[dim - 1]) +
-           std::abs((phi.get_normal_vector(0) *
-                     phi_outer.inverse_jacobian(0))[dim - 1])) *
+          (std::abs((phi.normal_vector(0) * phi.inverse_jacobian(0))[dim - 1]) +
+           std::abs(
+             (phi.normal_vector(0) * phi_outer.inverse_jacobian(0))[dim - 1])) *
           (number)(std::max(fe_degree, 1) * (fe_degree + 1.0));
 
         // Compute phi part
@@ -433,8 +432,7 @@ private:
         phi.reinit(face);
 
         VectorizedArray<number> sigmaF =
-          std::abs(
-            (phi.get_normal_vector(0) * phi.inverse_jacobian(0))[dim - 1]) *
+          std::abs((phi.normal_vector(0) * phi.inverse_jacobian(0))[dim - 1]) *
           number(std::max(fe_degree, 1) * (fe_degree + 1.0)) * 2.0;
 
         for (unsigned int i = 0; i < phi.dofs_per_cell; ++i)
index 609cc7257632b554a13a4ad3a3f03971db82c877..e407917846976544f69cbee5627f9b0f85ccba5c 100644 (file)
@@ -220,9 +220,9 @@ private:
         fe_eval_neighbor.evaluate(EvaluationFlags::values |
                                   EvaluationFlags::gradients);
         VectorizedArray<number> sigmaF =
-          (std::abs((fe_eval.get_normal_vector(0) *
+          (std::abs((fe_eval.normal_vector(0) *
                      fe_eval.inverse_jacobian(0))[dim - 1]) +
-           std::abs((fe_eval.get_normal_vector(0) *
+           std::abs((fe_eval.normal_vector(0) *
                      fe_eval_neighbor.inverse_jacobian(0))[dim - 1])) *
           (number)(std::max(fe_degree, 1) * (fe_degree + 1.0));
 
@@ -262,8 +262,8 @@ private:
         fe_eval.read_dof_values(src);
         fe_eval.evaluate(EvaluationFlags::values | EvaluationFlags::gradients);
         VectorizedArray<number> sigmaF =
-          std::abs((fe_eval.get_normal_vector(0) *
-                    fe_eval.inverse_jacobian(0))[dim - 1]) *
+          std::abs(
+            (fe_eval.normal_vector(0) * fe_eval.inverse_jacobian(0))[dim - 1]) *
           (number)(std::max(1, fe_degree) * (fe_degree + 1.0)) * 2.;
 
         for (unsigned int q = 0; q < fe_eval.n_q_points; ++q)
@@ -328,8 +328,8 @@ private:
           {
             phif.reinit(cell, face);
             VectorizedArray<number> sigmaF =
-              std::abs((phif.get_normal_vector(0) *
-                        phif.inverse_jacobian(0))[dim - 1]) *
+              std::abs(
+                (phif.normal_vector(0) * phif.inverse_jacobian(0))[dim - 1]) *
               (number)(std::max(1, fe_degree) * (fe_degree + 1.0)) * 2.;
             std::array<types::boundary_id, VectorizedArray<number>::size()>
               boundary_ids = data.get_faces_by_cells_boundary_id(cell, face);
index 4480b17b2c49cabf2d0ebe7da7fc998f1e495d14..85ab590043a151dc793cb60ba2f4d4b1516dbbc4 100644 (file)
@@ -845,9 +845,9 @@ namespace NavierStokes_DG
                                         EvaluationFlags::gradients);
 
                 const auto tau_ip =
-                  (std::abs((phi_m.get_normal_vector(0) *
+                  (std::abs((phi_m.normal_vector(0) *
                              phi_m.inverse_jacobian(0))[dim - 1]) +
-                   std::abs((phi_p.get_normal_vector(0) *
+                   std::abs((phi_p.normal_vector(0) *
                              phi_p.inverse_jacobian(0))[dim - 1])) *
                   Number(viscosity * (degree + 1) * (degree + 1));
 
@@ -855,7 +855,7 @@ namespace NavierStokes_DG
                   {
                     const auto w_m    = phi_m.get_value(q);
                     const auto w_p    = phi_p.get_value(q);
-                    const auto normal = phi_m.get_normal_vector(q);
+                    const auto normal = phi_m.normal_vector(q);
                     auto       numerical_flux =
                       -euler_numerical_flux<dim>(w_m, w_p, normal);
                     const auto grad_w_m = phi_m.get_gradient(q);
@@ -882,14 +882,14 @@ namespace NavierStokes_DG
             else
               {
                 const auto tau_ip =
-                  std::abs((phi_m.get_normal_vector(0) *
+                  std::abs((phi_m.normal_vector(0) *
                             phi_m.inverse_jacobian(0))[dim - 1]) *
                   Number(2. * viscosity * (degree + 1) * (degree + 1));
 
                 for (unsigned int q = 0; q < phi_m.n_q_points; ++q)
                   {
                     const auto w_m      = phi_m.get_value(q);
-                    const auto normal   = phi_m.get_normal_vector(q);
+                    const auto normal   = phi_m.normal_vector(q);
                     const auto grad_w_m = phi_m.get_gradient(q);
                     const auto grad_w_p = grad_w_m;
 
@@ -1225,9 +1225,9 @@ namespace NavierStokes_DG
                               EvaluationFlags::values |
                                 EvaluationFlags::gradients);
 
-        const auto tau_ip = (std::abs((phi_m.get_normal_vector(0) *
+        const auto tau_ip = (std::abs((phi_m.normal_vector(0) *
                                        phi_m.inverse_jacobian(0))[dim - 1]) +
-                             std::abs((phi_p.get_normal_vector(0) *
+                             std::abs((phi_p.normal_vector(0) *
                                        phi_p.inverse_jacobian(0))[dim - 1])) *
                             Number(viscosity * (degree + 1) * (degree + 1));
 
@@ -1235,7 +1235,7 @@ namespace NavierStokes_DG
           {
             const auto w_m      = phi_m.get_value(q);
             const auto w_p      = phi_p.get_value(q);
-            const auto normal   = phi_m.get_normal_vector(q);
+            const auto normal   = phi_m.normal_vector(q);
             auto numerical_flux = -euler_numerical_flux<dim>(w_m, w_p, normal);
             const auto grad_w_m = phi_m.get_gradient(q);
             const auto grad_w_p = phi_p.get_gradient(q);
@@ -1294,7 +1294,7 @@ namespace NavierStokes_DG
 
         const auto tau_ip =
           std::abs(
-            (phi_m.get_normal_vector(0) * phi_m.inverse_jacobian(0))[dim - 1]) *
+            (phi_m.normal_vector(0) * phi_m.inverse_jacobian(0))[dim - 1]) *
           Number(2. * viscosity * (degree + 1) * (degree + 1));
 
         const auto boundary_id = data.get_boundary_id(face);
@@ -1302,7 +1302,7 @@ namespace NavierStokes_DG
         for (unsigned int q = 0; q < phi_m.n_q_points; ++q)
           {
             const auto w_m      = phi_m.get_value(q);
-            const auto normal   = phi_m.get_normal_vector(q);
+            const auto normal   = phi_m.normal_vector(q);
             const auto grad_w_m = phi_m.get_gradient(q);
             const auto grad_w_p = grad_w_m;
 
index 3caf0444138826cc33598291ac3088148b2c9130..eae96818091bac4ba70a7107d1d88eed534c1177 100644 (file)
@@ -187,9 +187,9 @@ public:
                                              EvaluationFlags::values |
                                                EvaluationFlags::gradients);
             VectorizedArray<number> sigmaF = PENALTY;
-            //  (std::abs((fe_eval.get_normal_vector(0) *
+            //  (std::abs((fe_eval.normal_vector(0) *
             //             fe_eval.inverse_jacobian(0))[dim - 1]) +
-            //   std::abs((fe_eval.get_normal_vector(0) *
+            //   std::abs((fe_eval.normal_vector(0) *
             //             fe_eval_neighbor.inverse_jacobian(0))[dim - 1])) *
             //  (number)(std::max(fe_degree, 1) * (fe_degree + 1.0));
 
@@ -225,7 +225,7 @@ public:
             fe_eval.evaluate(EvaluationFlags::values |
                              EvaluationFlags::gradients);
             VectorizedArray<number> sigmaF = PENALTY;
-            //  std::abs((fe_eval.get_normal_vector(0) *
+            //  std::abs((fe_eval.normal_vector(0) *
             //            fe_eval.inverse_jacobian(0))[dim - 1]) *
             //  number(std::max(fe_degree, 1) * (fe_degree + 1.0)) * 2.0;
 
index 4a8ba815d0fada4d1fbffffacd500a996f5e7f49..0418da687f118da9c9a3a9d348ffb7b0112aa023 100644 (file)
@@ -763,8 +763,8 @@ public:
             phi.reinit(face);
             for (unsigned int q = 0; q < phi.n_q_points; ++q)
               {
-                const auto beta_n = this->beta(phi.quadrature_point(q)) *
-                                    phi.get_normal_vector(q);
+                const auto beta_n =
+                  this->beta(phi.quadrature_point(q)) * phi.normal_vector(q);
                 const auto beta_n_m = (-std::abs(beta_n) + beta_n) * 0.5;
                 phi.submit_value(-beta_n_m * this->boundary_values(
                                                phi.quadrature_point(q)),
@@ -810,7 +810,7 @@ public:
             for (unsigned int q = 0; q < phi_m.n_q_points; ++q)
               {
                 const auto beta_n = this->beta(phi_m.quadrature_point(q)) *
-                                    phi_m.get_normal_vector(q);
+                                    phi_m.normal_vector(q);
 
                 const auto u_m = phi_m.get_value(q);
                 const auto u_p = phi_p.get_value(q);
@@ -834,8 +834,8 @@ public:
             phi.gather_evaluate(src, true, false);
             for (unsigned int q = 0; q < phi.n_q_points; ++q)
               {
-                const auto beta_n = this->beta(phi.quadrature_point(q)) *
-                                    phi.get_normal_vector(q);
+                const auto beta_n =
+                  this->beta(phi.quadrature_point(q)) * phi.normal_vector(q);
                 const auto beta_n_p = (std::abs(beta_n) + beta_n) * 0.5;
                 phi.submit_value(beta_n_p * phi.get_value(q), q);
               }
index 4c13a9d894a60db38db245c540dbc2ae9128797a..52bb6b577bfe638d035165eb0b3bd07747b0dc6d 100644 (file)
@@ -1199,7 +1199,7 @@ namespace Euler_DG
             const auto numerical_flux =
               euler_numerical_flux<dim>(phi_m.get_value(q),
                                         phi_p.get_value(q),
-                                        phi_m.get_normal_vector(q));
+                                        phi_m.normal_vector(q));
             //     std::cout<<" phim: "<<phi_m.get_value(q)
             //      <<" phip: "<<phi_p.get_value(q)<<std::endl;
             phi_m.submit_value(-numerical_flux, q);
@@ -1286,7 +1286,7 @@ namespace Euler_DG
         for (unsigned int q = 0; q < phi.n_q_points; ++q)
           {
             const auto w_m    = phi.get_value(q);
-            const auto normal = phi.get_normal_vector(q);
+            const auto normal = phi.normal_vector(q);
 
             auto rho_u_dot_n = w_m[1] * normal[0];
             for (unsigned int d = 1; d < dim; ++d)

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.