]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Mapping: refactor the contravariant Hessian mappings.
authorDavid Wells <drwells@email.unc.edu>
Tue, 17 Jun 2025 15:40:11 +0000 (11:40 -0400)
committerDavid Wells <drwells@email.unc.edu>
Tue, 17 Jun 2025 15:42:40 +0000 (11:42 -0400)
include/deal.II/fe/mapping_internal.h
include/deal.II/fe/mapping_q_internal.h
source/fe/mapping_fe.cc
source/fe/mapping_manifold.cc

index 2b4bf35cfff5260c9628370b7c80ab441b5d5717..7fd4592795b1302a4fcca408b8ec94706a0bb937 100644 (file)
@@ -27,6 +27,18 @@ DEAL_II_NAMESPACE_OPEN
 
 namespace internal
 {
+  /**
+   * Map the Hessian of a contravariant vector field. For more information see
+   * the overload of Mapping::transform() which maps 3-differential forms from
+   * the reference cell to the physical cell.
+   */
+  template <int dim, int spacedim, typename Number>
+  Tensor<3, spacedim, Number>
+  apply_contravariant_hessian(
+    const DerivativeForm<1, dim, spacedim, Number> &covariant,
+    const DerivativeForm<1, dim, spacedim, Number> &contravariant,
+    const Tensor<3, dim, Number>                   &input);
+
   /**
    * Map the Hessian of a covariant vector field. For more information see the
    * overload of Mapping::transform() which maps 3-differential forms from the
@@ -41,6 +53,47 @@ namespace internal
 
 namespace internal
 {
+  template <int dim, int spacedim, typename Number>
+  inline Tensor<3, spacedim, Number>
+  apply_contravariant_hessian(
+    const DerivativeForm<1, dim, spacedim, Number> &covariant,
+    const DerivativeForm<1, dim, spacedim, Number> &contravariant,
+    const Tensor<3, dim, Number>                   &input)
+  {
+    Tensor<3, spacedim, Number> output;
+    for (unsigned int i = 0; i < spacedim; ++i)
+      {
+        Number tmp1[dim][dim];
+        for (unsigned int J = 0; J < dim; ++J)
+          for (unsigned int K = 0; K < dim; ++K)
+            {
+              tmp1[J][K] = contravariant[i][0] * input[0][J][K];
+              for (unsigned int I = 1; I < dim; ++I)
+                tmp1[J][K] += contravariant[i][I] * input[I][J][K];
+            }
+        for (unsigned int j = 0; j < spacedim; ++j)
+          {
+            Number tmp2[dim];
+            for (unsigned int K = 0; K < dim; ++K)
+              {
+                tmp2[K] = covariant[j][0] * tmp1[0][K];
+                for (unsigned int J = 1; J < dim; ++J)
+                  tmp2[K] += covariant[j][J] * tmp1[J][K];
+              }
+            for (unsigned int k = 0; k < spacedim; ++k)
+              {
+                output[i][j][k] = covariant[k][0] * tmp2[0];
+                for (unsigned int K = 1; K < dim; ++K)
+                  output[i][j][k] += covariant[k][K] * tmp2[K];
+              }
+          }
+      }
+
+    return output;
+  }
+
+
+
   template <int dim, int spacedim, typename Number>
   inline Tensor<3, spacedim, Number>
   apply_covariant_hessian(
index 518aad29e8185606d88f13fab31644534675c281..1d46c444b829c6241489e2890958c9838a6fcab3 100644 (file)
@@ -2364,37 +2364,12 @@ namespace internal
                     data.output_data->inverse_jacobians[q].transpose();
                   const DerivativeForm<1, dim, spacedim> contravariant =
                     data.output_data->jacobians[q];
-
-                  for (unsigned int i = 0; i < spacedim; ++i)
-                    {
-                      double tmp1[dim][dim];
-                      for (unsigned int J = 0; J < dim; ++J)
-                        for (unsigned int K = 0; K < dim; ++K)
-                          {
-                            tmp1[J][K] =
-                              contravariant[i][0] * input[q][0][J][K];
-                            for (unsigned int I = 1; I < dim; ++I)
-                              tmp1[J][K] +=
-                                contravariant[i][I] * input[q][I][J][K];
-                          }
-                      for (unsigned int j = 0; j < spacedim; ++j)
-                        {
-                          double tmp2[dim];
-                          for (unsigned int K = 0; K < dim; ++K)
-                            {
-                              tmp2[K] = covariant[j][0] * tmp1[0][K];
-                              for (unsigned int J = 1; J < dim; ++J)
-                                tmp2[K] += covariant[j][J] * tmp1[J][K];
-                            }
-                          for (unsigned int k = 0; k < spacedim; ++k)
-                            {
-                              output[q][i][j][k] = covariant[k][0] * tmp2[0];
-                              for (unsigned int K = 1; K < dim; ++K)
-                                output[q][i][j][k] += covariant[k][K] * tmp2[K];
-                            }
-                        }
-                    }
+                  output[q] =
+                    internal::apply_contravariant_hessian(covariant,
+                                                          contravariant,
+                                                          input[q]);
                 }
+
               return;
             }
 
index f33503485116ffb0e8027bf035dcd7becbc138d0..2b0fb25f5dbcad3c7b945fa958ba2c3a8303b53a 100644 (file)
@@ -1901,37 +1901,11 @@ namespace internal
                     "update_contravariant_transformation"));
 
                 for (unsigned int q = 0; q < output.size(); ++q)
-                  for (unsigned int i = 0; i < spacedim; ++i)
-                    {
-                      double tmp1[dim][dim];
-                      for (unsigned int J = 0; J < dim; ++J)
-                        for (unsigned int K = 0; K < dim; ++K)
-                          {
-                            tmp1[J][K] =
-                              data.contravariant[q][i][0] * input[q][0][J][K];
-                            for (unsigned int I = 1; I < dim; ++I)
-                              tmp1[J][K] +=
-                                data.contravariant[q][i][I] * input[q][I][J][K];
-                          }
-                      for (unsigned int j = 0; j < spacedim; ++j)
-                        {
-                          double tmp2[dim];
-                          for (unsigned int K = 0; K < dim; ++K)
-                            {
-                              tmp2[K] = data.covariant[q][j][0] * tmp1[0][K];
-                              for (unsigned int J = 1; J < dim; ++J)
-                                tmp2[K] += data.covariant[q][j][J] * tmp1[J][K];
-                            }
-                          for (unsigned int k = 0; k < spacedim; ++k)
-                            {
-                              output[q][i][j][k] =
-                                data.covariant[q][k][0] * tmp2[0];
-                              for (unsigned int K = 1; K < dim; ++K)
-                                output[q][i][j][k] +=
-                                  data.covariant[q][k][K] * tmp2[K];
-                            }
-                        }
-                    }
+                  output[q] =
+                    internal::apply_contravariant_hessian(data.covariant[q],
+                                                          data.contravariant[q],
+                                                          input[q]);
+
                 return;
               }
 
index 92055faecf0f8642ed2257c038d65cf242719012..20df91ffd7ab13aba7e73cd98e8d4b7755e65236 100644 (file)
@@ -1060,37 +1060,11 @@ namespace internal
                     "update_contravariant_transformation"));
 
                 for (unsigned int q = 0; q < output.size(); ++q)
-                  for (unsigned int i = 0; i < spacedim; ++i)
-                    {
-                      double tmp1[dim][dim];
-                      for (unsigned int J = 0; J < dim; ++J)
-                        for (unsigned int K = 0; K < dim; ++K)
-                          {
-                            tmp1[J][K] =
-                              data.contravariant[q][i][0] * input[q][0][J][K];
-                            for (unsigned int I = 1; I < dim; ++I)
-                              tmp1[J][K] +=
-                                data.contravariant[q][i][I] * input[q][I][J][K];
-                          }
-                      for (unsigned int j = 0; j < spacedim; ++j)
-                        {
-                          double tmp2[dim];
-                          for (unsigned int K = 0; K < dim; ++K)
-                            {
-                              tmp2[K] = data.covariant[q][j][0] * tmp1[0][K];
-                              for (unsigned int J = 1; J < dim; ++J)
-                                tmp2[K] += data.covariant[q][j][J] * tmp1[J][K];
-                            }
-                          for (unsigned int k = 0; k < spacedim; ++k)
-                            {
-                              output[q][i][j][k] =
-                                data.covariant[q][k][0] * tmp2[0];
-                              for (unsigned int K = 1; K < dim; ++K)
-                                output[q][i][j][k] +=
-                                  data.covariant[q][k][K] * tmp2[K];
-                            }
-                        }
-                    }
+                  output[q] =
+                    internal::apply_contravariant_hessian(data.covariant[q],
+                                                          data.contravariant[q],
+                                                          input[q]);
+
                 return;
               }
 

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.