]> https://gitweb.dealii.org/ - dealii-svn.git/commitdiff
Make naming uniform: call second derivatives "hessians" as everywhere else, rather...
authorbangerth <bangerth@0785d39b-7218-0410-832d-ea1e28bc413d>
Fri, 18 May 2012 12:49:31 +0000 (12:49 +0000)
committerbangerth <bangerth@0785d39b-7218-0410-832d-ea1e28bc413d>
Fri, 18 May 2012 12:49:31 +0000 (12:49 +0000)
git-svn-id: https://svn.dealii.org/branches/branch_higher_derivatives@25516 0785d39b-7218-0410-832d-ea1e28bc413d

29 files changed:
deal.II/doc/news/changes.h
deal.II/include/deal.II/base/polynomial_space.h
deal.II/include/deal.II/base/polynomials_abf.h
deal.II/include/deal.II/base/polynomials_adini.h
deal.II/include/deal.II/base/polynomials_bdm.h
deal.II/include/deal.II/base/polynomials_nedelec.h
deal.II/include/deal.II/base/polynomials_raviart_thomas.h
deal.II/include/deal.II/base/tensor_product_polynomials.h
deal.II/include/deal.II/fe/fe.h
deal.II/include/deal.II/fe/fe_dgp_nonparametric.h
deal.II/include/deal.II/fe/fe_poly.h
deal.II/include/deal.II/fe/fe_poly.templates.h
deal.II/include/deal.II/fe/fe_poly_face.h
deal.II/include/deal.II/fe/fe_poly_face.templates.h
deal.II/include/deal.II/fe/fe_poly_tensor.h
deal.II/include/deal.II/fe/fe_system.h
deal.II/include/deal.II/fe/fe_values.h
deal.II/include/deal.II/matrix_free/shape_info.templates.h
deal.II/source/base/polynomial_space.cc
deal.II/source/base/polynomials_abf.cc
deal.II/source/base/polynomials_adini.cc
deal.II/source/base/polynomials_bdm.cc
deal.II/source/base/polynomials_nedelec.cc
deal.II/source/base/polynomials_raviart_thomas.cc
deal.II/source/base/tensor_product_polynomials.cc
deal.II/source/fe/fe.cc
deal.II/source/fe/fe_dgp_nonparametric.cc
deal.II/source/fe/fe_poly_tensor.cc
deal.II/source/fe/fe_system.cc

index 02e374c4fbf0bade3d4ab773a31a326058e3499e..5d0da0b9a92c73f3b03c9b8e1da38cc5ff4dba2d 100644 (file)
@@ -42,6 +42,20 @@ used for boundary indicators.
 
 <!-- ----------- GENERAL IMPROVEMENTS ----------------- -->
 
+
+<!-- ********** BRANCH CHANGES -->
+
+<ol>
+<li> Changed: In many places throughout the library, second derivatives
+were previously referred to uniformly as "Hessians" of some function.
+However, in the internal interfaces of the finite element classes, we still
+used an older name, "grad_grad". This has now changed. None of these
+renamed functions should be used in user programs, however.
+<br>
+(B&auml;rbel Janssen, Wolfgang Bangerth, 2012/05/18)
+</ol>
+
+
 <a name="general"></a>
 <h3>General</h3>
 
index eca0b003555c532aac060eb518a42276d418983a..1caa9e997a6892437832f73dfdf9aa35b31f23a5 100644 (file)
@@ -146,14 +146,14 @@ class PolynomialSpace
                                       * than using any of the
                                       * compute_value(),
                                       * compute_grad() or
-                                      * compute_grad_grad()
+                                      * compute_hessian()
                                       * functions, see below, in a
                                       * loop over all polynomials.
                                       */
     void compute (const Point<dim>            &unit_point,
                   std::vector<double>         &values,
                   std::vector<Tensor<1,dim> > &grads,
-                  std::vector<Tensor<2,dim> > &grad_grads) const;
+                  std::vector<Tensor<2,dim> > &hessians) const;
 
                                      /**
                                       * Computes the value of the
@@ -177,13 +177,13 @@ class PolynomialSpace
 
                                      /**
                                       * Computes the second derivative
-                                      * (grad_grad) of the <tt>i</tt>th
+                                      * (hessian) of the <tt>i</tt>th
                                       * polynomial at
                                       * <tt>unit_point</tt>.
                                       *
                                       * Consider using compute() instead.
                                       */
-    Tensor<2,dim> compute_grad_grad (const unsigned int i,
+    Tensor<2,dim> compute_hessian (const unsigned int i,
                                      const Point<dim> &p) const;
 
                                      /**
index fb21de59b30c68b83c7145ee25919dc12d6ad1ab..0979ac599041d7657acd34050f935c0e6a99d540 100644 (file)
@@ -88,7 +88,7 @@ class PolynomialsABF
                                       * using any of the
                                       * <tt>compute_value</tt>,
                                       * <tt>compute_grad</tt> or
-                                      * <tt>compute_grad_grad</tt>
+                                      * <tt>compute_hessian</tt>
                                       * functions, see below, in a
                                       * loop over all tensor product
                                       * polynomials.
@@ -96,7 +96,7 @@ class PolynomialsABF
     void compute (const Point<dim>            &unit_point,
                   std::vector<Tensor<1,dim> > &values,
                   std::vector<Tensor<2,dim> > &grads,
-                  std::vector<Tensor<3,dim> > &grad_grads) const;
+                  std::vector<Tensor<3,dim> > &hessians) const;
 
                                      /**
                                       * Returns the number of ABF polynomials.
@@ -168,7 +168,7 @@ class PolynomialsABF
                                      /**
                                       * Auxiliary memory.
                                       */
-    mutable std::vector<Tensor<2,dim> > p_grad_grads;
+    mutable std::vector<Tensor<2,dim> > p_hessians;
 };
 
 
index 17798dcae7ca09102b2993b28cea76f45857912b..89c324d36857b047c278becea37082a917b83260 100644 (file)
@@ -64,7 +64,7 @@ class PolynomialsAdini
                                       * than using any of the
                                       * compute_value(),
                                       * compute_grad() or
-                                      * compute_grad_grad()
+                                      * compute_hessian()
                                       * functions, see below, in a
                                       * loop over all polynomials.
                                       */
@@ -72,7 +72,7 @@ class PolynomialsAdini
     void compute (const Point<2> &unit_point,
                   std::vector<double> &values,
                   std::vector<Tensor<1,2> > &grads,
-                  std::vector< Tensor<2,2> > &grad_grads) const;
+                  std::vector< Tensor<2,2> > &hessians) const;
 
                                       /**
                                        * Computes the value of the
@@ -97,15 +97,15 @@ class PolynomialsAdini
                               const Point<2> &p) const;
                                       /**
                                        * Computes the second derivative
-                                       * (grad_grad) of the <tt>i</tt>th
+                                       * (hessian) of the <tt>i</tt>th
                                        * polynomial at
                                        * <tt>unit_point</tt>.
                                        *
                                        * Consider using compute() instead.
                                        */
 
-    Tensor<2,2> compute_grad_grad (const unsigned int i, const Point<2> &p) const;
-    Tensor<2,2> compute_grad_grad_2 (const unsigned int i, const Point<2> &p) const;
+    Tensor<2,2> compute_hessian (const unsigned int i, const Point<2> &p) const;
+    Tensor<2,2> compute_hessian_2 (const unsigned int i, const Point<2> &p) const;
 
   private:
                                         /**
index b5bd31e2f70732a002b6849088d2b74f03d3c10a..67268e7c832acfb1d2ba7fda94c3f16c8f51ed9e 100644 (file)
@@ -91,7 +91,7 @@ class PolynomialsBDM
                                       * using any of the
                                       * <tt>compute_value</tt>,
                                       * <tt>compute_grad</tt> or
-                                      * <tt>compute_grad_grad</tt>
+                                      * <tt>compute_hessian</tt>
                                       * functions, see below, in a
                                       * loop over all tensor product
                                       * polynomials.
@@ -99,7 +99,7 @@ class PolynomialsBDM
     void compute (const Point<dim>            &unit_point,
                   std::vector<Tensor<1,dim> > &values,
                   std::vector<Tensor<2,dim> > &grads,
-                  std::vector<Tensor<3,dim> > &grad_grads) const;
+                  std::vector<Tensor<3,dim> > &hessians) const;
 
                                      /**
                                       * Returns the number of BDM polynomials.
@@ -173,7 +173,7 @@ class PolynomialsBDM
                                      /**
                                       * Auxiliary memory.
                                       */
-    mutable std::vector<Tensor<2,dim> > p_grad_grads;
+    mutable std::vector<Tensor<2,dim> > p_hessians;
 };
 
 
index 5e77df2bd3f8eaca36444dbee5487ca57a0852a3..7eab9a70fb4755c5d81f6cf4e00b3a6f9d3f3cdd 100644 (file)
@@ -80,12 +80,12 @@ class PolynomialsNedelec
                                       * using any of the
                                       * <tt>compute_value</tt>,
                                       * <tt>compute_grad</tt> or
-                                      * <tt>compute_grad_grad</tt>
+                                      * <tt>compute_hessian</tt>
                                       * functions, see below, in a
                                       * loop over all tensor product
                                       * polynomials.
                                       */
-    void compute (const Point<dim> &unit_point, std::vector<Tensor<1, dim> > &values, std::vector<Tensor<2, dim> > &grads, std::vector<Tensor<3, dim> > &grad_grads) const;
+    void compute (const Point<dim> &unit_point, std::vector<Tensor<1, dim> > &values, std::vector<Tensor<2, dim> > &grads, std::vector<Tensor<3, dim> > &hessians) const;
 
                                      /**
                                       * Returns the number of Nédélec
index 0c112f983c08e6ae20f1454ddf9082a4c3a8957e..41fcea1856045c3c21ad2ef98135e9facc66fa33 100644 (file)
@@ -79,7 +79,7 @@ class PolynomialsRaviartThomas
                                       * using any of the
                                       * <tt>compute_value</tt>,
                                       * <tt>compute_grad</tt> or
-                                      * <tt>compute_grad_grad</tt>
+                                      * <tt>compute_hessian</tt>
                                       * functions, see below, in a
                                       * loop over all tensor product
                                       * polynomials.
@@ -87,7 +87,7 @@ class PolynomialsRaviartThomas
     void compute (const Point<dim>            &unit_point,
                   std::vector<Tensor<1,dim> > &values,
                   std::vector<Tensor<2,dim> > &grads,
-                  std::vector<Tensor<3,dim> > &grad_grads) const;
+                  std::vector<Tensor<3,dim> > &hessians) const;
 
                                      /**
                                       * Returns the number of Raviart-Thomas polynomials.
index 7837939db6ae355649caf25d5c8b4a414850134c..8108852dc9627dcd4526ed4f43a76f6aadc2d095 100644 (file)
@@ -127,7 +127,7 @@ class TensorProductPolynomials
                                       * using any of the
                                       * compute_value(),
                                       * compute_grad() or
-                                      * compute_grad_grad()
+                                      * compute_hessian()
                                       * functions, see below, in a
                                       * loop over all tensor product
                                       * polynomials.
@@ -135,7 +135,7 @@ class TensorProductPolynomials
     void compute (const Point<dim>            &unit_point,
                   std::vector<double>         &values,
                   std::vector<Tensor<1,dim> > &grads,
-                  std::vector<Tensor<2,dim> > &grad_grads) const;
+                  std::vector<Tensor<2,dim> > &hessians) const;
 
                                      /**
                                       * Computes the value of the
@@ -192,7 +192,7 @@ class TensorProductPolynomials
 
                                      /**
                                       * Computes the second
-                                      * derivative (grad_grad) of the
+                                      * derivative (hessian) of the
                                       * <tt>i</tt>th tensor product
                                       * polynomial at
                                       * <tt>unit_point</tt>. Here <tt>i</tt> is
@@ -209,13 +209,13 @@ class TensorProductPolynomials
                                       * computed several times.
                                       * Instead use the compute()
                                       * function, see above, with
-                                      * <tt>grad_grads.size()==</tt>n()
+                                      * <tt>hessians.size()==</tt>n()
                                       * to get the point value of all
                                       * tensor polynomials all at once
                                       * and in a much more efficient
                                       * way.
                                       */
-    Tensor<2,dim> compute_grad_grad (const unsigned int i,
+    Tensor<2,dim> compute_hessian (const unsigned int i,
                                      const Point<dim> &p) const;
 
                                      /**
@@ -358,7 +358,7 @@ class AnisotropicPolynomials
                                       * using any of the
                                       * <tt>compute_value</tt>,
                                       * <tt>compute_grad</tt> or
-                                      * <tt>compute_grad_grad</tt>
+                                      * <tt>compute_hessian</tt>
                                       * functions, see below, in a
                                       * loop over all tensor product
                                       * polynomials.
@@ -366,7 +366,7 @@ class AnisotropicPolynomials
     void compute (const Point<dim>            &unit_point,
                   std::vector<double>         &values,
                   std::vector<Tensor<1,dim> > &grads,
-                  std::vector<Tensor<2,dim> > &grad_grads) const;
+                  std::vector<Tensor<2,dim> > &hessians) const;
 
                                      /**
                                       * Computes the value of the
@@ -424,7 +424,7 @@ class AnisotropicPolynomials
 
                                      /**
                                       * Computes the second
-                                      * derivative (grad_grad) of the
+                                      * derivative (hessian) of the
                                       * <tt>i</tt>th tensor product
                                       * polynomial at
                                       * <tt>unit_point</tt>. Here <tt>i</tt> is
@@ -441,13 +441,13 @@ class AnisotropicPolynomials
                                       * computed several times.
                                       * Instead use the <tt>compute</tt>
                                       * function, see above, with
-                                      * <tt>grad_grads.size()==n_tensor_pols</tt>
+                                      * <tt>hessians.size()==n_tensor_pols</tt>
                                       * to get the point value of all
                                       * tensor polynomials all at once
                                       * and in a much more efficient
                                       * way.
                                       */
-    Tensor<2,dim> compute_grad_grad (const unsigned int i,
+    Tensor<2,dim> compute_hessian (const unsigned int i,
                                      const Point<dim> &p) const;
 
                                      /**
index 66c0759613b47edbee0d273ed271fd6ff1bed78d..c49c12cd81e9dfe7015e9b1c394b7405a5cbc89f 100644 (file)
@@ -595,7 +595,7 @@ class FiniteElement : public Subscriptor,
                                       * exception of type
                                       * ExcShapeFunctionNotPrimitive. In
                                       * that case, use the
-                                      * shape_grad_grad_component()
+                                      * shape_hessian_component()
                                       * function.
                                       *
                                       * An
@@ -606,11 +606,11 @@ class FiniteElement : public Subscriptor,
                                       * shape of the cell in real
                                       * space.
                                       */
-    virtual Tensor<2,dim> shape_grad_grad (const unsigned int  i,
+    virtual Tensor<2,dim> shape_hessian (const unsigned int  i,
                                            const Point<dim>   &p) const;
 
                                      /**
-                                      * Just like for shape_grad_grad(),
+                                      * Just like for shape_hessian(),
                                       * but this function will be
                                       * called when the shape function
                                       * has more than one non-zero
@@ -621,9 +621,10 @@ class FiniteElement : public Subscriptor,
                                       * component of the @p ith shape
                                       * function at point @p p.
                                       */
-    virtual Tensor<2,dim> shape_grad_grad_component (const unsigned int i,
+    virtual Tensor<2,dim> shape_hessian_component (const unsigned int i,
                                                      const Point<dim>   &p,
                                                      const unsigned int component) const;
+
                                      /**
                                       * Check for non-zero values on a
                                       * face in order to optimize out
index 22522b1490c9cdf763b6ed42e0033dffae089a10..a0284c188f0a139a2c824c8fdd4cac34daf53cb7 100644 (file)
@@ -148,7 +148,7 @@ class FE_DGPNonparametric : public FiniteElement<dim,spacedim>
                                       * about the semantics of this
                                       * function.
                                       */
-    virtual Tensor<2,dim> shape_grad_grad (const unsigned int  i,
+    virtual Tensor<2,dim> shape_hessian (const unsigned int  i,
                                            const Point<dim> &p) const;
 
                                      /**
@@ -169,7 +169,7 @@ class FE_DGPNonparametric : public FiniteElement<dim,spacedim>
                                       * called, provided that the
                                       * specified component is zero.
                                       */
-    virtual Tensor<2,dim> shape_grad_grad_component (const unsigned int i,
+    virtual Tensor<2,dim> shape_hessian_component (const unsigned int i,
                                                      const Point<dim> &p,
                                                      const unsigned int component) const;
 
@@ -565,7 +565,7 @@ class FE_DGPNonparametric : public FiniteElement<dim,spacedim>
                                        // have some scratch arrays
       std::vector<double> values;
       std::vector<Tensor<1,dim> > grads;
-      std::vector<Tensor<2,dim> > grad_grads;
+      std::vector<Tensor<2,dim> > hessians;
     };
 
                                      /**
index 437dee900c46513ce4ae7529aadb8a48246ca1b9..ca0da2666ecb2247b9a86039b41d35f20ce6af4a 100644 (file)
@@ -37,7 +37,7 @@ DEAL_II_NAMESPACE_OPEN
  * Tensor<1,dim> compute_grad (const unsigned int i,
  *                             const Point<dim> &p) const;
  *
- * Tensor<2,dim> compute_grad_grad (const unsigned int i,
+ * Tensor<2,dim> compute_hessian (const unsigned int i,
  *                                  const Point<dim> &p) const;
  * @endcode
  * Example classes are TensorProductPolynomials, PolynomialSpace or
@@ -171,7 +171,7 @@ class FE_Poly : public FiniteElement<dim,spacedim>
                                       * for more information about the
                                       * semantics of this function.
                                       */
-    virtual Tensor<2,dim> shape_grad_grad (const unsigned int  i,
+    virtual Tensor<2,dim> shape_hessian (const unsigned int  i,
                                            const Point<dim> &p) const;
 
                                      /**
@@ -191,7 +191,7 @@ class FE_Poly : public FiniteElement<dim,spacedim>
                                       * were called, provided that the
                                       * specified component is zero.
                                       */
-    virtual Tensor<2,dim> shape_grad_grad_component (const unsigned int i,
+    virtual Tensor<2,dim> shape_hessian_component (const unsigned int i,
                                                      const Point<dim> &p,
                                                      const unsigned int component) const;
   protected:
index cc79e573ab8467729f73e5e587fd7bb796189e9e..4fe053bdf99fffb4c19a3e1b5a48989934ddeb4c 100644 (file)
@@ -90,24 +90,24 @@ FE_Poly<POLY,dim,spacedim>::shape_grad_component (const unsigned int i,
 
 template <class POLY, int dim, int spacedim>
 Tensor<2,dim>
-FE_Poly<POLY,dim,spacedim>::shape_grad_grad (const unsigned int i,
+FE_Poly<POLY,dim,spacedim>::shape_hessian (const unsigned int i,
                                      const Point<dim> &p) const
 {
   Assert (i<this->dofs_per_cell, ExcIndexRange(i,0,this->dofs_per_cell));
-  return poly_space.compute_grad_grad(i, p);
+  return poly_space.compute_hessian(i, p);
 }
 
 
 
 template <class POLY, int dim, int spacedim>
 Tensor<2,dim>
-FE_Poly<POLY,dim,spacedim>::shape_grad_grad_component (const unsigned int i,
+FE_Poly<POLY,dim,spacedim>::shape_hessian_component (const unsigned int i,
                                                const Point<dim> &p,
                                                const unsigned int component) const
 {
   Assert (i<this->dofs_per_cell, ExcIndexRange(i,0,this->dofs_per_cell));
   Assert (component == 0, ExcIndexRange (component, 0, 1));
-  return poly_space.compute_grad_grad(i, p);
+  return poly_space.compute_hessian(i, p);
 }
 
 
@@ -179,7 +179,7 @@ FE_Poly<POLY,dim,spacedim>::get_data (const UpdateFlags      update_flags,
                                    // some scratch arrays
   std::vector<double> values(0);
   std::vector<Tensor<1,dim> > grads(0);
-  std::vector<Tensor<2,dim> > grad_grads(0);
+  std::vector<Tensor<2,dim> > hessians(0);
 
                                    // initialize fields only if really
                                    // necessary. otherwise, don't
@@ -216,7 +216,7 @@ FE_Poly<POLY,dim,spacedim>::get_data (const UpdateFlags      update_flags,
     for (unsigned int i=0; i<n_q_points; ++i)
       {
         poly_space.compute(quadrature.point(i),
-                           values, grads, grad_grads);
+                           values, grads, hessians);
 
         if (flags & update_values)
           for (unsigned int k=0; k<this->dofs_per_cell; ++k)
index 310cce6e3e8e4e8ec01025529a1ec38ce4d468a1..876ad69ecdc2483b0a7f1f0a7c46f2a0d1da5f14 100644 (file)
@@ -146,7 +146,7 @@ class FE_PolyFace : public FiniteElement<dim,spacedim>
                                       * for more information about the
                                       * semantics of this function.
                                       */
-//    virtual Tensor<2,dim> shape_grad_grad (const unsigned int  i,
+//    virtual Tensor<2,dim> shape_hessian (const unsigned int  i,
 //                                         const Point<dim> &p) const;
 
                                      /**
@@ -166,7 +166,7 @@ class FE_PolyFace : public FiniteElement<dim,spacedim>
                                       * were called, provided that the
                                       * specified component is zero.
                                       */
-//    virtual Tensor<2,dim> shape_grad_grad_component (const unsigned int i,
+//    virtual Tensor<2,dim> shape_hessian_component (const unsigned int i,
 //                                                   const Point<dim> &p,
 //                                                   const unsigned int component) const;
 
index 65f65a5095a0b14ef91a296f4a7f6125bdf39da4..049116df70932b6c64001fde31975ffdc5e0fe9a 100644 (file)
@@ -119,7 +119,7 @@ FE_PolyFace<POLY,dim,spacedim>::get_face_data (
                                    // some scratch arrays
   std::vector<double> values(0);
   std::vector<Tensor<1,dim-1> > grads(0);
-  std::vector<Tensor<2,dim-1> > grad_grads(0);
+  std::vector<Tensor<2,dim-1> > hessians(0);
 
                                    // initialize fields only if really
                                    // necessary. otherwise, don't
@@ -132,7 +132,7 @@ FE_PolyFace<POLY,dim,spacedim>::get_face_data (
       for (unsigned int i=0; i<n_q_points; ++i)
         {
           poly_space.compute(quadrature.point(i),
-                             values, grads, grad_grads);
+                             values, grads, hessians);
 
           for (unsigned int k=0; k<poly_space.n(); ++k)
             data->shape_values[k][i] = values[k];
index 14562bf88f70b7aa6eee79862843e9fe2616697c..065b4f1cef812976d9c85953d7eb0259d7ecadde 100644 (file)
@@ -31,7 +31,7 @@ DEAL_II_NAMESPACE_OPEN
  * void compute (const Point<dim>            &unit_point,
  *               std::vector<Tensor<1,dim> > &values,
  *               std::vector<Tensor<2,dim> > &grads,
- *               std::vector<Tensor<3,dim> > &grad_grads) const;
+ *               std::vector<Tensor<3,dim> > &hessians) const;
  * @endcode
  *
  * In many cases, the node functionals depend on the shape of the mesh
@@ -157,10 +157,10 @@ class FE_PolyTensor : public FiniteElement<dim,spacedim>
                                       * vector valued, an exception is
                                       * thrown.
                                       */
-    virtual Tensor<2,dim> shape_grad_grad (const unsigned int  i,
+    virtual Tensor<2,dim> shape_hessian (const unsigned int  i,
                                            const Point<dim> &p) const;
 
-    virtual Tensor<2,dim> shape_grad_grad_component (const unsigned int i,
+    virtual Tensor<2,dim> shape_hessian_component (const unsigned int i,
                                                      const Point<dim> &p,
                                                      const unsigned int component) const;
 
@@ -329,9 +329,9 @@ class FE_PolyTensor : public FiniteElement<dim,spacedim>
                                      /**
                                       * Cached second derivatives of
                                       * shape functions after call to
-                                      * shape_grad_grad_component().
+                                      * shape_hessian_component().
                                       */
-    mutable std::vector<Tensor<3,dim> > cached_grad_grads;
+    mutable std::vector<Tensor<3,dim> > cached_hessians;
 };
 
 DEAL_II_NAMESPACE_CLOSE
index 2e7fceabc9bd5fcd6daf3fb878bd72a870a2c2c7..e76533bb1968462f54fbd055ff090250c3493230 100644 (file)
@@ -389,7 +389,7 @@ class FESystem : public FiniteElement<dim,spacedim>
                                       * shape of the cell in real
                                       * space.
                                       */
-    virtual Tensor<2,dim> shape_grad_grad (const unsigned int  i,
+    virtual Tensor<2,dim> shape_hessian (const unsigned int  i,
                                            const Point<dim> &p) const;
 
                                      /**
@@ -410,7 +410,7 @@ class FESystem : public FiniteElement<dim,spacedim>
                                       */
     virtual
     Tensor<2,dim>
-    shape_grad_grad_component (const unsigned int i,
+    shape_hessian_component (const unsigned int i,
                                const Point<dim> &p,
                                const unsigned int component) const;
 
index c90121418c90389a6a43202ff9fc0143ae2edc5e..c0e4504226e061f0476eb5f796f949663bf82a10 100644 (file)
@@ -1957,7 +1957,7 @@ class FEValuesBase : protected FEValuesData<dim,spacedim>,
                                       * exception of type
                                       * ExcShapeFunctionNotPrimitive. In
                                       * that case, use the
-                                      * shape_grad_grad_component()
+                                      * shape_hessian_component()
                                       * function.
                                       *
                                       * The same holds for the arguments
index 2dbc45bc0f2d72b7608641f42b1bce2abbf52392..a078f2c39d74f6660a3efec77f8b1cdffd6fdaa2 100644 (file)
@@ -133,7 +133,7 @@ namespace MatrixFreeFunctions
             shape_gradients[my_i*n_q_points_1d+q] =
               shape_gradient_number[my_i*n_q_points_1d+q];
             shape_hessians[my_i*n_q_points_1d+q] =
-              fe.shape_grad_grad(i,q_point)[0][0];
+              fe.shape_hessian(i,q_point)[0][0];
             face_value[0][my_i*n_q_points_1d+q] = fe.shape_value(i,q_point*0.5);
             face_value[1][my_i*n_q_points_1d+q] = fe.shape_value(i,Point<1>(0.5)+q_point*0.5);
           }
index ce3fdb3bd89f459641aa6e17f25a0912aaee2bdb..1199671b9a6372b3ef7800c8afe4130169147486 100644 (file)
@@ -168,7 +168,7 @@ PolynomialSpace<dim>::compute_grad (const unsigned int i,
 
 template <int dim>
 Tensor<2,dim>
-PolynomialSpace<dim>::compute_grad_grad (const unsigned int i,
+PolynomialSpace<dim>::compute_hessian (const unsigned int i,
                                          const Point<dim>  &p) const
 {
   unsigned int ix[dim];
@@ -209,7 +209,7 @@ void
 PolynomialSpace<dim>::compute (const Point<dim>            &p,
                                std::vector<double>         &values,
                                std::vector<Tensor<1,dim> > &grads,
-                               std::vector<Tensor<2,dim> > &grad_grads) const
+                               std::vector<Tensor<2,dim> > &hessians) const
 {
   const unsigned int n_1d=polynomials.size();
 
@@ -217,11 +217,11 @@ PolynomialSpace<dim>::compute (const Point<dim>            &p,
          ExcDimensionMismatch2(values.size(), n_pols, 0));
   Assert(grads.size()==n_pols|| grads.size()==0,
          ExcDimensionMismatch2(grads.size(), n_pols, 0));
-  Assert(grad_grads.size()==n_pols|| grad_grads.size()==0,
-         ExcDimensionMismatch2(grad_grads.size(), n_pols, 0));
+  Assert(hessians.size()==n_pols|| hessians.size()==0,
+         ExcDimensionMismatch2(hessians.size(), n_pols, 0));
 
   unsigned int v_size=0;
-  bool update_values=false, update_grads=false, update_grad_grads=false;
+  bool update_values=false, update_grads=false, update_hessians=false;
   if (values.size()==n_pols)
     {
       update_values=true;
@@ -232,9 +232,9 @@ PolynomialSpace<dim>::compute (const Point<dim>            &p,
       update_grads=true;
       v_size=2;
     }
-  if (grad_grads.size()==n_pols)
+  if (hessians.size()==n_pols)
     {
-      update_grad_grads=true;
+      update_hessians=true;
       v_size=3;
     }
 
@@ -281,7 +281,7 @@ PolynomialSpace<dim>::compute (const Point<dim>            &p,
             }
     }
 
-  if (update_grad_grads)
+  if (update_hessians)
     {
       unsigned int k = 0;
 
@@ -303,7 +303,7 @@ PolynomialSpace<dim>::compute (const Point<dim>            &p,
                     const unsigned int
                       j2 = ((d1==2) ? 1 : 0) + ((d2==2) ? 1 : 0);
 
-                    grad_grads[k2][d1][d2] =
+                    hessians[k2][d1][d2] =
                       v[0][ix][j0]
                       * ((dim>1) ? v[1][iy][j1] : 1.)
                       * ((dim>2) ? v[2][iz][j2] : 1.);
index 51b120266f3b4e62c98914fb531532797e1162bb..cfd8ae27425f1e7b79318b3845208d3628fdc3a9 100644 (file)
@@ -50,14 +50,14 @@ void
 PolynomialsABF<dim>::compute (const Point<dim>            &unit_point,
                               std::vector<Tensor<1,dim> > &values,
                               std::vector<Tensor<2,dim> > &grads,
-                              std::vector<Tensor<3,dim> > &grad_grads) const
+                              std::vector<Tensor<3,dim> > &hessians) const
 {
   Assert(values.size()==n_pols || values.size()==0,
          ExcDimensionMismatch(values.size(), n_pols));
   Assert(grads.size()==n_pols|| grads.size()==0,
          ExcDimensionMismatch(grads.size(), n_pols));
-  Assert(grad_grads.size()==n_pols|| grad_grads.size()==0,
-         ExcDimensionMismatch(grad_grads.size(), n_pols));
+  Assert(hessians.size()==n_pols|| hessians.size()==0,
+         ExcDimensionMismatch(hessians.size(), n_pols));
 
   const unsigned int n_sub = polynomial_space->n();
                                    // guard access to the scratch
@@ -69,7 +69,7 @@ PolynomialsABF<dim>::compute (const Point<dim>            &unit_point,
 
   p_values.resize((values.size() == 0) ? 0 : n_sub);
   p_grads.resize((grads.size() == 0) ? 0 : n_sub);
-  p_grad_grads.resize((grad_grads.size() == 0) ? 0 : n_sub);
+  p_hessians.resize((hessians.size() == 0) ? 0 : n_sub);
 
   for (unsigned int d=0;d<dim;++d)
     {
@@ -88,7 +88,7 @@ PolynomialsABF<dim>::compute (const Point<dim>            &unit_point,
       for (unsigned int c=0;c<dim;++c)
         p(c) = unit_point((c+d)%dim);
 
-      polynomial_space->compute (p, p_values, p_grads, p_grad_grads);
+      polynomial_space->compute (p, p_values, p_grads, p_hessians);
 
       for (unsigned int i=0;i<p_values.size();++i)
         values[i+d*n_sub][d] = p_values[i];
@@ -97,11 +97,11 @@ PolynomialsABF<dim>::compute (const Point<dim>            &unit_point,
         for (unsigned int d1=0;d1<dim;++d1)
           grads[i+d*n_sub][d][(d1+d)%dim] = p_grads[i][d1];
 
-      for (unsigned int i=0;i<p_grad_grads.size();++i)
+      for (unsigned int i=0;i<p_hessians.size();++i)
         for (unsigned int d1=0;d1<dim;++d1)
           for (unsigned int d2=0;d2<dim;++d2)
-            grad_grads[i+d*n_sub][d][(d1+d)%dim][(d2+d)%dim]
-              = p_grad_grads[i][d1][d2];
+            hessians[i+d*n_sub][d][(d1+d)%dim][(d2+d)%dim]
+              = p_hessians[i][d1][d2];
     }
 }
 
index 45777473217105d11cbde6104c7a1986fc800a37..e51681266fa50c42c58db7a9f95919a32b4e1453 100644 (file)
@@ -115,7 +115,7 @@ void
 PolynomialsAdini::compute (const Point<2> &unit_point,
                    std::vector<double> &values,
                    std::vector<Tensor<1,2> > &grads,
-                   std::vector< Tensor<2,2> > &grad_grads) const
+                   std::vector< Tensor<2,2> > &hessians) const
 {
   if(values.empty() == false)//nur dann was tun
   {
@@ -133,11 +133,11 @@ PolynomialsAdini::compute (const Point<2> &unit_point,
     }
   }
 
-  if(grad_grads.empty() == false)//nur dann was tun
+  if(hessians.empty() == false)//nur dann was tun
   {
-    for(unsigned int i=0; i<grad_grads.size(); ++i)
+    for(unsigned int i=0; i<hessians.size(); ++i)
     {
-      grad_grads[i] = compute_grad_grad(i, unit_point);
+      hessians[i] = compute_hessian(i, unit_point);
     }
   }
   return;
@@ -194,7 +194,7 @@ Tensor<1,2> PolynomialsAdini::compute_grad (const unsigned int i, const Point<2>
   return tensor;
 }
 
-Tensor<2,2> PolynomialsAdini::compute_grad_grad (const unsigned int i, const Point<2> &p) const
+Tensor<2,2> PolynomialsAdini::compute_hessian (const unsigned int i, const Point<2> &p) const
 {
   const double x = p(0);
   const double y = p(1);
index 70f96f0a80a0904b8ca9b5e7382d614fb215dde0..df74decdad7a903ffebfebe67d27e6d733922ae7 100644 (file)
@@ -27,7 +27,7 @@ PolynomialsBDM<dim>::PolynomialsBDM (const unsigned int k)
                 n_pols(compute_n_pols(k)),
                 p_values(polynomial_space.n()),
                 p_grads(polynomial_space.n()),
-                p_grad_grads(polynomial_space.n())
+                p_hessians(polynomial_space.n())
 {
   switch(dim)
     {
@@ -50,14 +50,14 @@ void
 PolynomialsBDM<dim>::compute (const Point<dim>            &unit_point,
                               std::vector<Tensor<1,dim> > &values,
                               std::vector<Tensor<2,dim> > &grads,
-                              std::vector<Tensor<3,dim> > &grad_grads) const
+                              std::vector<Tensor<3,dim> > &hessians) const
 {
   Assert(values.size()==n_pols || values.size()==0,
          ExcDimensionMismatch(values.size(), n_pols));
   Assert(grads.size()==n_pols|| grads.size()==0,
          ExcDimensionMismatch(grads.size(), n_pols));
-  Assert(grad_grads.size()==n_pols|| grad_grads.size()==0,
-         ExcDimensionMismatch(grad_grads.size(), n_pols));
+  Assert(hessians.size()==n_pols|| hessians.size()==0,
+         ExcDimensionMismatch(hessians.size(), n_pols));
 
   const unsigned int n_sub = polynomial_space.n();
 
@@ -71,14 +71,14 @@ PolynomialsBDM<dim>::compute (const Point<dim>            &unit_point,
 
     p_values.resize((values.size() == 0) ? 0 : n_sub);
     p_grads.resize((grads.size() == 0) ? 0 : n_sub);
-    p_grad_grads.resize((grad_grads.size() == 0) ? 0 : n_sub);
+    p_hessians.resize((hessians.size() == 0) ? 0 : n_sub);
 
                                      // Compute values of complete space
                                      // and insert into tensors.  Result
                                      // will have first all polynomials
                                      // in the x-component, then y and
                                      // z.
-    polynomial_space.compute (unit_point, p_values, p_grads, p_grad_grads);
+    polynomial_space.compute (unit_point, p_values, p_grads, p_hessians);
 
     std::fill(values.begin(), values.end(), Tensor<1,dim>());
     for (unsigned int i=0;i<p_values.size();++i)
@@ -90,10 +90,10 @@ PolynomialsBDM<dim>::compute (const Point<dim>            &unit_point,
       for (unsigned int j=0;j<dim;++j)
         grads[i+j*n_sub][j] = p_grads[i];
 
-    std::fill(grad_grads.begin(), grad_grads.end(), Tensor<3,dim>());
-    for (unsigned int i=0;i<p_grad_grads.size();++i)
+    std::fill(hessians.begin(), hessians.end(), Tensor<3,dim>());
+    for (unsigned int i=0;i<p_hessians.size();++i)
       for (unsigned int j=0;j<dim;++j)
-        grad_grads[i+j*n_sub][j] = p_grad_grads[i];
+        hessians[i+j*n_sub][j] = p_hessians[i];
   }
 
                                    // This is the first polynomial not
@@ -128,24 +128,24 @@ PolynomialsBDM<dim>::compute (const Point<dim>            &unit_point,
           grads[start+1][1][0] = 0.;
           grads[start+1][1][1] = monovali[1][1];
         }
-      if (grad_grads.size() != 0)
+      if (hessians.size() != 0)
         {
-          grad_grads[start][0][0][0] = monovali[0][2];
-          grad_grads[start][0][0][1] = 0.;
-          grad_grads[start][0][1][0] = 0.;
-          grad_grads[start][0][1][1] = 0.;
-          grad_grads[start][1][0][0] = -unit_point(1) * monovali[0][3];
-          grad_grads[start][1][0][1] = -monovali[0][2];
-          grad_grads[start][1][1][0] = -monovali[0][2];
-          grad_grads[start][1][1][1] = 0.;
-          grad_grads[start+1][0][0][0] = 0;
-          grad_grads[start+1][0][0][1] = -monovali[1][2];
-          grad_grads[start+1][0][1][0] = -monovali[1][2];
-          grad_grads[start+1][0][1][1] = -unit_point(0) * monovali[1][3];
-          grad_grads[start+1][1][0][0] = 0.;
-          grad_grads[start+1][1][0][1] = 0.;
-          grad_grads[start+1][1][1][0] = 0.;
-          grad_grads[start+1][1][1][1] = monovali[1][2];
+          hessians[start][0][0][0] = monovali[0][2];
+          hessians[start][0][0][1] = 0.;
+          hessians[start][0][1][0] = 0.;
+          hessians[start][0][1][1] = 0.;
+          hessians[start][1][0][0] = -unit_point(1) * monovali[0][3];
+          hessians[start][1][0][1] = -monovali[0][2];
+          hessians[start][1][1][0] = -monovali[0][2];
+          hessians[start][1][1][1] = 0.;
+          hessians[start+1][0][0][0] = 0;
+          hessians[start+1][0][0][1] = -monovali[1][2];
+          hessians[start+1][0][1][0] = -monovali[1][2];
+          hessians[start+1][0][1][1] = -unit_point(0) * monovali[1][3];
+          hessians[start+1][1][0][0] = 0.;
+          hessians[start+1][1][0][1] = 0.;
+          hessians[start+1][1][1][0] = 0.;
+          hessians[start+1][1][1][1] = monovali[1][2];
         }
     }
   else // dim == 3
@@ -222,7 +222,7 @@ PolynomialsBDM<dim>::compute (const Point<dim>            &unit_point,
               grads[start+2][1][0] = 0.;
               grads[start+2][1][1] = 0.;
             }
-          if (grad_grads.size() != 0)
+          if (hessians.size() != 0)
             {
               Assert(false,ExcNotImplemented());
             }
@@ -245,7 +245,7 @@ PolynomialsBDM<dim>::compute_node_matrix (Table<2,double>& A) const
 
   std::vector<Tensor<1,dim> > values(n());
   std::vector<Tensor<2,dim> > grads;
-  std::vector<Tensor<3,dim> > grad_grads;
+  std::vector<Tensor<3,dim> > hessians;
   values.resize(n());
 
   for (unsigned int face=0;face<2*dim;++face)
@@ -277,7 +277,7 @@ PolynomialsBDM<dim>::compute_node_matrix (Table<2,double>& A) const
 //                << '\t' << moment_weight[1].value(x)
 //        ;
 
-          compute (p, values, grads, grad_grads);
+          compute (p, values, grads, hessians);
 
           for (unsigned int i=0;i<n();++i)
             {
index 6b18aadfea65db991df82ebf60b600c27a7ac51b..18de8f2ca7117aaf9a3c33b787ae6b80fd9ea230 100644 (file)
@@ -38,15 +38,15 @@ void
 PolynomialsNedelec<dim>::compute (const Point<dim> &unit_point,
                                   std::vector<Tensor<1,dim> > &values,
                                   std::vector<Tensor<2,dim> > &grads,
-                                  std::vector<Tensor<3,dim> > &grad_grads)
+                                  std::vector<Tensor<3,dim> > &hessians)
 const
 {
   Assert(values.size () == n_pols || values.size () == 0,
          ExcDimensionMismatch(values.size (), n_pols));
   Assert(grads.size () == n_pols || grads.size () == 0,
          ExcDimensionMismatch(grads.size (), n_pols));
-  Assert(grad_grads.size () == n_pols || grad_grads.size () == 0,
-         ExcDimensionMismatch(grad_grads.size (), n_pols));
+  Assert(hessians.size () == n_pols || hessians.size () == 0,
+         ExcDimensionMismatch(hessians.size (), n_pols));
 
                                                                 // Declare the values, derivatives
                                                                 // and second derivatives vectors of
@@ -57,14 +57,14 @@ const
   std::vector<Tensor<1, dim> >
     unit_point_grads ((grads.size () == 0) ? 0 : n_basis);
   std::vector<Tensor<2, dim> >
-    unit_point_grad_grads ((grad_grads.size () == 0) ? 0 : n_basis);
+    unit_point_hessians ((hessians.size () == 0) ? 0 : n_basis);
 
   switch (dim)
     {
       case 1:
         {
           polynomial_space.compute (unit_point, unit_point_values,
-                                    unit_point_grads, unit_point_grad_grads);
+                                    unit_point_grads, unit_point_hessians);
 
                                                         // Assign the correct values to the
                                                         // corresponding shape functions.
@@ -76,9 +76,9 @@ const
             for (unsigned int i = 0; i < unit_point_grads.size (); ++i)
               grads[i][0][0] = unit_point_grads[i][0];
 
-          if (grad_grads.size () > 0)
-            for (unsigned int i = 0; i < unit_point_grad_grads.size (); ++i)
-              grad_grads[i][0][0][0] = unit_point_grad_grads[i][0][0];
+          if (hessians.size () > 0)
+            for (unsigned int i = 0; i < unit_point_hessians.size (); ++i)
+              hessians[i][0][0][0] = unit_point_hessians[i][0][0];
 
           break;
         }
@@ -86,7 +86,7 @@ const
       case 2:
         {
           polynomial_space.compute (unit_point, unit_point_values,
-                                    unit_point_grads, unit_point_grad_grads);
+                                    unit_point_grads, unit_point_hessians);
 
                                                         // Declare the values, derivatives and
                                                         // second derivatives vectors of
@@ -102,9 +102,9 @@ const
           std::vector<Tensor<1, dim> >
             p_grads ((grads.size () == 0) ? 0 : n_basis);
           std::vector<Tensor<2, dim> >
-            p_grad_grads ((grad_grads.size () == 0) ? 0 : n_basis);
+            p_hessians ((hessians.size () == 0) ? 0 : n_basis);
 
-          polynomial_space.compute (p, p_values, p_grads, p_grad_grads);
+          polynomial_space.compute (p, p_values, p_grads, p_hessians);
 
                                                         // Assign the correct values to the
                                                         // corresponding shape functions.
@@ -190,7 +190,7 @@ const
                    }
             }
 
-          if (grad_grads.size () > 0)
+          if (hessians.size () > 0)
             {
               for (unsigned int i = 0; i <= my_degree; ++i)
                 for (unsigned int j = 0; j < 2; ++j)
@@ -198,22 +198,22 @@ const
                     for (unsigned int k = 0; k < dim; ++k)
                       for (unsigned int l = 0; l < dim; ++l)
                         {
-                          grad_grads[i + j * (my_degree + 1)][0][k][l] = 0.0;
-                          grad_grads[i + (j + 2) * (my_degree + 1)][0][k][l]
-                            = unit_point_grad_grads[i + j * (my_degree + 1)][k]
+                          hessians[i + j * (my_degree + 1)][0][k][l] = 0.0;
+                          hessians[i + (j + 2) * (my_degree + 1)][0][k][l]
+                            = unit_point_hessians[i + j * (my_degree + 1)][k]
                                                    [l];
-                          grad_grads[i + (j + 2) * (my_degree + 1)][1][k][l]
+                          hessians[i + (j + 2) * (my_degree + 1)][1][k][l]
                             = 0.0;
                         }
 
-                    grad_grads[i + j * (my_degree + 1)][1][0][0]
-                      = p_grad_grads[i + j * (my_degree + 1)][1][1];
-                    grad_grads[i + j * (my_degree + 1)][1][0][1]
-                      = p_grad_grads[i + j * (my_degree + 1)][1][0];
-                    grad_grads[i + j * (my_degree + 1)][1][1][0]
-                      = p_grad_grads[i + j * (my_degree + 1)][0][1];
-                    grad_grads[i + j * (my_degree + 1)][1][1][1]
-                      = p_grad_grads[i + j * (my_degree + 1)][0][0];
+                    hessians[i + j * (my_degree + 1)][1][0][0]
+                      = p_hessians[i + j * (my_degree + 1)][1][1];
+                    hessians[i + j * (my_degree + 1)][1][0][1]
+                      = p_hessians[i + j * (my_degree + 1)][1][0];
+                    hessians[i + j * (my_degree + 1)][1][1][0]
+                      = p_hessians[i + j * (my_degree + 1)][0][1];
+                    hessians[i + j * (my_degree + 1)][1][1][1]
+                      = p_hessians[i + j * (my_degree + 1)][0][0];
                   }
 
               if (my_degree > 0)
@@ -223,37 +223,37 @@ const
                       for (unsigned int k = 0; k < dim; ++k)
                         for (unsigned int l = 0; l < dim; ++l)
                           {
-                            grad_grads[(i + GeometryInfo<dim>::lines_per_cell)
+                            hessians[(i + GeometryInfo<dim>::lines_per_cell)
                                        * my_degree + j
                                        + GeometryInfo<dim>::lines_per_cell][0]
                                       [k][l]
-                              = unit_point_grad_grads[i + (j + 2)
+                              = unit_point_hessians[i + (j + 2)
                                                       * (my_degree + 1)][k][l];
-                            grad_grads[(i + GeometryInfo<dim>::lines_per_cell)
+                            hessians[(i + GeometryInfo<dim>::lines_per_cell)
                                        * my_degree + j
                                        + GeometryInfo<dim>::lines_per_cell][1]
                                       [k][l] = 0.0;
-                            grad_grads[i + (j + my_degree
+                            hessians[i + (j + my_degree
                                             + GeometryInfo<dim>::lines_per_cell)
                                        * (my_degree + 1)][0][k][l] = 0.0;
                           }
 
-                      grad_grads[i + (j + my_degree
+                      hessians[i + (j + my_degree
                                         + GeometryInfo<dim>::lines_per_cell)
                                  * (my_degree + 1)][1][0][0]
-                        = p_grad_grads[i + (j + 2) * (my_degree + 1)][1][1];
-                      grad_grads[i + (j + my_degree
+                        = p_hessians[i + (j + 2) * (my_degree + 1)][1][1];
+                      hessians[i + (j + my_degree
                                         + GeometryInfo<dim>::lines_per_cell)
                                  * (my_degree + 1)][1][0][1]
-                        = p_grad_grads[i + (j + 2) * (my_degree + 1)][1][0];
-                      grad_grads[i + (j + my_degree
+                        = p_hessians[i + (j + 2) * (my_degree + 1)][1][0];
+                      hessians[i + (j + my_degree
                                         + GeometryInfo<dim>::lines_per_cell)
                                  * (my_degree + 1)][1][1][0]
-                        = p_grad_grads[i + (j + 2) * (my_degree + 1)][0][1];
-                      grad_grads[i + (j + my_degree
+                        = p_hessians[i + (j + 2) * (my_degree + 1)][0][1];
+                      hessians[i + (j + my_degree
                                         + GeometryInfo<dim>::lines_per_cell)
                                  * (my_degree + 1)][1][1][1]
-                        = p_grad_grads[i + (j + 2) * (my_degree + 1)][0][0];
+                        = p_hessians[i + (j + 2) * (my_degree + 1)][0][0];
                     }
             }
 
@@ -263,7 +263,7 @@ const
       case 3:
         {
           polynomial_space.compute (unit_point, unit_point_values,
-                                    unit_point_grads, unit_point_grad_grads);
+                                    unit_point_grads, unit_point_hessians);
 
                                                                 // Declare the values, derivatives
                                                                 // and second derivatives vectors of
@@ -276,21 +276,21 @@ const
           std::vector<Tensor<1, dim> >
             p1_grads ((grads.size () == 0) ? 0 : n_basis);
           std::vector<Tensor<2, dim> >
-            p1_grad_grads ((grad_grads.size () == 0) ? 0 : n_basis);
+            p1_hessians ((hessians.size () == 0) ? 0 : n_basis);
           std::vector<double> p2_values ((values.size () == 0) ? 0 : n_basis);
           std::vector<Tensor<1, dim> >
             p2_grads ((grads.size () == 0) ? 0 : n_basis);
           std::vector<Tensor<2, dim> >
-            p2_grad_grads ((grad_grads.size () == 0) ? 0 : n_basis);
+            p2_hessians ((hessians.size () == 0) ? 0 : n_basis);
 
           p1 (0) = unit_point (1);
           p1 (1) = unit_point (2);
           p1 (2) = unit_point (0);
-          polynomial_space.compute (p1, p1_values, p1_grads, p1_grad_grads);
+          polynomial_space.compute (p1, p1_values, p1_grads, p1_hessians);
           p2 (0) = unit_point (2);
           p2 (1) = unit_point (0);
           p2 (2) = unit_point (1);
-          polynomial_space.compute (p2, p2_values, p2_grads, p2_grad_grads);
+          polynomial_space.compute (p2, p2_values, p2_grads, p2_hessians);
 
                                                                 // Assign the correct values to the
                                                                 // corresponding shape functions.
@@ -718,7 +718,7 @@ const
                     }
             }
 
-          if (grad_grads.size () > 0)
+          if (hessians.size () > 0)
             {
               for (unsigned int i = 0; i <= my_degree; ++i)
                 {
@@ -731,137 +731,137 @@ const
                               {
                                 for (unsigned int n = 0; n < 2; ++n)
                                   {
-                                    grad_grads[i + (j + 4 * k) * (my_degree
+                                    hessians[i + (j + 4 * k) * (my_degree
                                                                   + 1)][2 * n]
                                               [l][m] = 0.0;
-                                    grad_grads[i + (j + 4 * k + 2) * (my_degree
+                                    hessians[i + (j + 4 * k + 2) * (my_degree
                                                                       + 1)]
                                               [n + 1][l][m] = 0.0;
-                                    grad_grads[i + (j + 2 * (k + 4))
+                                    hessians[i + (j + 2 * (k + 4))
                                                * (my_degree + 1)][n][l][m]
                                       = 0.0;
                                   }
 
-                                grad_grads[i + (j + 4 * k + 2) * (my_degree
+                                hessians[i + (j + 4 * k + 2) * (my_degree
                                                                   + 1)][0][l][m]
-                                  = unit_point_grad_grads[i + (j + k
+                                  = unit_point_hessians[i + (j + k
                                                                * (my_degree
                                                                   + 2))
                                                           * (my_degree + 1)][l]
                                                          [m];
                               }
 
-                          grad_grads[i + (j + 2 * (k + 4)) * (my_degree + 1)]
+                          hessians[i + (j + 2 * (k + 4)) * (my_degree + 1)]
                                     [2][0][0]
-                            = p2_grad_grads[i + (j + k * (my_degree + 2))
+                            = p2_hessians[i + (j + k * (my_degree + 2))
                                             * (my_degree + 1)][1][1];
-                          grad_grads[i + (j + 2 * (k + 4)) * (my_degree + 1)]
+                          hessians[i + (j + 2 * (k + 4)) * (my_degree + 1)]
                                     [2][0][1]
-                            = p2_grad_grads[i + (j + k * (my_degree + 2))
+                            = p2_hessians[i + (j + k * (my_degree + 2))
                                             * (my_degree + 1)][1][2];
-                          grad_grads[i + (j + 2 * (k + 4)) * (my_degree + 1)]
+                          hessians[i + (j + 2 * (k + 4)) * (my_degree + 1)]
                                     [2][0][2]
-                            = p2_grad_grads[i + (j + k * (my_degree + 2))
+                            = p2_hessians[i + (j + k * (my_degree + 2))
                                             * (my_degree + 1)][1][0];
-                          grad_grads[i + (j + 2 * (k + 4)) * (my_degree + 1)]
+                          hessians[i + (j + 2 * (k + 4)) * (my_degree + 1)]
                                     [2][1][0]
-                            = p2_grad_grads[i + (j + k * (my_degree + 2))
+                            = p2_hessians[i + (j + k * (my_degree + 2))
                                             * (my_degree + 1)][2][1];
-                          grad_grads[i + (j + 2 * (k + 4)) * (my_degree + 1)]
+                          hessians[i + (j + 2 * (k + 4)) * (my_degree + 1)]
                                     [2][1][1]
-                            = p2_grad_grads[i + (j + k * (my_degree + 2))
+                            = p2_hessians[i + (j + k * (my_degree + 2))
                                             * (my_degree + 1)][2][2];
-                          grad_grads[i + (j + 2 * (k + 4)) * (my_degree + 1)]
+                          hessians[i + (j + 2 * (k + 4)) * (my_degree + 1)]
                                     [2][1][2]
-                            = p2_grad_grads[i + (j + k * (my_degree + 2))
+                            = p2_hessians[i + (j + k * (my_degree + 2))
                                             * (my_degree + 1)][2][0];
-                          grad_grads[i + (j + 2 * (k + 4)) * (my_degree + 1)]
+                          hessians[i + (j + 2 * (k + 4)) * (my_degree + 1)]
                                     [2][2][0]
-                            = p2_grad_grads[i + (j + k * (my_degree + 2))
+                            = p2_hessians[i + (j + k * (my_degree + 2))
                                             * (my_degree + 1)][0][1];
-                          grad_grads[i + (j + 2 * (k + 4)) * (my_degree + 1)]
+                          hessians[i + (j + 2 * (k + 4)) * (my_degree + 1)]
                                     [2][2][1]
-                            = p2_grad_grads[i + (j + k * (my_degree + 2))
+                            = p2_hessians[i + (j + k * (my_degree + 2))
                                             * (my_degree + 1)][0][2];
-                          grad_grads[i + (j + 2 * (k + 4)) * (my_degree + 1)]
+                          hessians[i + (j + 2 * (k + 4)) * (my_degree + 1)]
                                     [2][2][2]
-                            = p2_grad_grads[i + (j + k * (my_degree + 2))
+                            = p2_hessians[i + (j + k * (my_degree + 2))
                                             * (my_degree + 1)][0][0];
                         }
 
-                      grad_grads[i + j * (my_degree + 1)][1][0][0]
-                        = p1_grad_grads[i + j * (my_degree + 1)
+                      hessians[i + j * (my_degree + 1)][1][0][0]
+                        = p1_hessians[i + j * (my_degree + 1)
                                         * (my_degree + 2)][2][2];
-                      grad_grads[i + j * (my_degree + 1)][1][0][1]
-                        = p1_grad_grads[i + j * (my_degree + 1)
+                      hessians[i + j * (my_degree + 1)][1][0][1]
+                        = p1_hessians[i + j * (my_degree + 1)
                                         * (my_degree + 2)][2][0];
-                      grad_grads[i + j * (my_degree + 1)][1][0][2]
-                        = p1_grad_grads[i + j * (my_degree + 1)
+                      hessians[i + j * (my_degree + 1)][1][0][2]
+                        = p1_hessians[i + j * (my_degree + 1)
                                         * (my_degree + 2)][2][1];
-                      grad_grads[i + j * (my_degree + 1)][1][1][0]
-                        = p1_grad_grads[i + j * (my_degree + 1)
+                      hessians[i + j * (my_degree + 1)][1][1][0]
+                        = p1_hessians[i + j * (my_degree + 1)
                                         * (my_degree + 2)][0][2];
-                      grad_grads[i + j * (my_degree + 1)][1][1][1]
-                        = p1_grad_grads[i + j * (my_degree + 1)
+                      hessians[i + j * (my_degree + 1)][1][1][1]
+                        = p1_hessians[i + j * (my_degree + 1)
                                         * (my_degree + 2)][0][0];
-                      grad_grads[i + j * (my_degree + 1)][1][1][2]
-                        = p1_grad_grads[i + j * (my_degree + 1)
+                      hessians[i + j * (my_degree + 1)][1][1][2]
+                        = p1_hessians[i + j * (my_degree + 1)
                                         * (my_degree + 2)][0][1];
-                      grad_grads[i + j * (my_degree + 1)][1][2][0]
-                        = p1_grad_grads[i + j * (my_degree + 1)
+                      hessians[i + j * (my_degree + 1)][1][2][0]
+                        = p1_hessians[i + j * (my_degree + 1)
                                         * (my_degree + 2)][1][2];
-                      grad_grads[i + j * (my_degree + 1)][1][2][1]
-                        = p1_grad_grads[i + j * (my_degree + 1)
+                      hessians[i + j * (my_degree + 1)][1][2][1]
+                        = p1_hessians[i + j * (my_degree + 1)
                                         * (my_degree + 2)][1][0];
-                      grad_grads[i + j * (my_degree + 1)][1][2][2]
-                        = p1_grad_grads[i + j * (my_degree + 1)
+                      hessians[i + j * (my_degree + 1)][1][2][2]
+                        = p1_hessians[i + j * (my_degree + 1)
                                         * (my_degree + 2)][1][1];
                     }
 
-                  grad_grads[i + 4 * (my_degree + 1)][1][0][0]
-                    = p1_grad_grads[i + my_degree + 1][2][2];
-                  grad_grads[i + 4 * (my_degree + 1)][1][0][1]
-                    = p1_grad_grads[i + my_degree + 1][2][0];
-                  grad_grads[i + 4 * (my_degree + 1)][1][0][2]
-                    = p1_grad_grads[i + my_degree + 1][2][1];
-                  grad_grads[i + 4 * (my_degree + 1)][1][1][0]
-                    = p1_grad_grads[i + my_degree + 1][0][2];
-                  grad_grads[i + 4 * (my_degree + 1)][1][1][1]
-                    = p1_grad_grads[i + my_degree + 1][0][0];
-                  grad_grads[i + 4 * (my_degree + 1)][1][1][2]
-                    = p1_grad_grads[i + my_degree + 1][0][1];
-                  grad_grads[i + 4 * (my_degree + 1)][1][2][0]
-                    = p1_grad_grads[i + my_degree + 1][1][2];
-                  grad_grads[i + 4 * (my_degree + 1)][1][2][1]
-                    = p1_grad_grads[i + my_degree + 1][1][0];
-                  grad_grads[i + 4 * (my_degree + 1)][1][2][2]
-                    = p1_grad_grads[i + my_degree + 1][1][1];
-                  grad_grads[i + 5 * (my_degree + 1)][1][0][0]
-                    = p1_grad_grads[i + (my_degree + 1) * (my_degree + 3)][2]
+                  hessians[i + 4 * (my_degree + 1)][1][0][0]
+                    = p1_hessians[i + my_degree + 1][2][2];
+                  hessians[i + 4 * (my_degree + 1)][1][0][1]
+                    = p1_hessians[i + my_degree + 1][2][0];
+                  hessians[i + 4 * (my_degree + 1)][1][0][2]
+                    = p1_hessians[i + my_degree + 1][2][1];
+                  hessians[i + 4 * (my_degree + 1)][1][1][0]
+                    = p1_hessians[i + my_degree + 1][0][2];
+                  hessians[i + 4 * (my_degree + 1)][1][1][1]
+                    = p1_hessians[i + my_degree + 1][0][0];
+                  hessians[i + 4 * (my_degree + 1)][1][1][2]
+                    = p1_hessians[i + my_degree + 1][0][1];
+                  hessians[i + 4 * (my_degree + 1)][1][2][0]
+                    = p1_hessians[i + my_degree + 1][1][2];
+                  hessians[i + 4 * (my_degree + 1)][1][2][1]
+                    = p1_hessians[i + my_degree + 1][1][0];
+                  hessians[i + 4 * (my_degree + 1)][1][2][2]
+                    = p1_hessians[i + my_degree + 1][1][1];
+                  hessians[i + 5 * (my_degree + 1)][1][0][0]
+                    = p1_hessians[i + (my_degree + 1) * (my_degree + 3)][2]
                                    [2];
-                  grad_grads[i + 5 * (my_degree + 1)][1][0][1]
-                    = p1_grad_grads[i + (my_degree + 1) * (my_degree + 3)][2]
+                  hessians[i + 5 * (my_degree + 1)][1][0][1]
+                    = p1_hessians[i + (my_degree + 1) * (my_degree + 3)][2]
                                    [0];
-                  grad_grads[i + 5 * (my_degree + 1)][1][0][2]
-                    = p1_grad_grads[i + (my_degree + 1) * (my_degree + 3)][2]
+                  hessians[i + 5 * (my_degree + 1)][1][0][2]
+                    = p1_hessians[i + (my_degree + 1) * (my_degree + 3)][2]
                                    [1];
-                  grad_grads[i + 5 * (my_degree + 1)][1][1][0]
-                    = p1_grad_grads[i + (my_degree + 1) * (my_degree + 3)][0]
+                  hessians[i + 5 * (my_degree + 1)][1][1][0]
+                    = p1_hessians[i + (my_degree + 1) * (my_degree + 3)][0]
                                    [2];
-                  grad_grads[i + 5 * (my_degree + 1)][1][1][1]
-                    = p1_grad_grads[i + (my_degree + 1) * (my_degree + 3)][0]
+                  hessians[i + 5 * (my_degree + 1)][1][1][1]
+                    = p1_hessians[i + (my_degree + 1) * (my_degree + 3)][0]
                                    [0];
-                  grad_grads[i + 5 * (my_degree + 1)][1][1][2]
-                    = p1_grad_grads[i + (my_degree + 1) * (my_degree + 3)][0]
+                  hessians[i + 5 * (my_degree + 1)][1][1][2]
+                    = p1_hessians[i + (my_degree + 1) * (my_degree + 3)][0]
                                    [1];
-                  grad_grads[i + 5 * (my_degree + 1)][1][2][0]
-                    = p1_grad_grads[i + (my_degree + 1) * (my_degree + 3)][1]
+                  hessians[i + 5 * (my_degree + 1)][1][2][0]
+                    = p1_hessians[i + (my_degree + 1) * (my_degree + 3)][1]
                                    [2];
-                  grad_grads[i + 5 * (my_degree + 1)][1][2][1]
-                    = p1_grad_grads[i + (my_degree + 1) * (my_degree + 3)][1]
+                  hessians[i + 5 * (my_degree + 1)][1][2][1]
+                    = p1_hessians[i + (my_degree + 1) * (my_degree + 3)][1]
                                    [0];
-                  grad_grads[i + 5 * (my_degree + 1)][1][2][2]
-                    = p1_grad_grads[i + (my_degree + 1) * (my_degree + 3)][1]
+                  hessians[i + 5 * (my_degree + 1)][1][2][2]
+                    = p1_hessians[i + (my_degree + 1) * (my_degree + 3)][1]
                                    [1];
                 }
 
@@ -876,7 +876,7 @@ const
                               {
                                 for (unsigned int n = 0; n < 2; ++n)
                                   {
-                                    grad_grads[((i + 2
+                                    hessians[((i + 2
                                                  * GeometryInfo<dim>::faces_per_cell)
                                                 * my_degree + j
                                                 + GeometryInfo<dim>::lines_per_cell
@@ -885,7 +885,7 @@ const
                                                * my_degree + k
                                                + GeometryInfo<dim>::lines_per_cell]
                                               [n + 1][l][m] = 0.0;
-                                    grad_grads[(i + (j + 2
+                                    hessians[(i + (j + 2
                                                      * GeometryInfo<dim>::faces_per_cell
                                                      + my_degree) * (my_degree
                                                                      + 1)
@@ -893,7 +893,7 @@ const
                                                * my_degree + k
                                                + GeometryInfo<dim>::lines_per_cell]
                                               [2 * n][l][m] = 0.0;
-                                    grad_grads[i + (j + (k + 2
+                                    hessians[i + (j + (k + 2
                                                          * (GeometryInfo<dim>::faces_per_cell
                                                             + my_degree))
                                                     * my_degree
@@ -902,7 +902,7 @@ const
                                       = 0.0;
                                   }
 
-                                grad_grads[((i + 2
+                                hessians[((i + 2
                                              * GeometryInfo<dim>::faces_per_cell)
                                             * my_degree + j
                                             + GeometryInfo<dim>::lines_per_cell
@@ -911,13 +911,13 @@ const
                                            * my_degree + k
                                            + GeometryInfo<dim>::lines_per_cell]
                                           [0][l][m]
-                                  = unit_point_grad_grads[i + (j + (k + 2)
+                                  = unit_point_hessians[i + (j + (k + 2)
                                                                * (my_degree + 2)
                                                           + 2) * (my_degree
                                                                   + 1)][l][m];
                               }
 
-                          grad_grads[(i + (j + 2
+                          hessians[(i + (j + 2
                                            * GeometryInfo<dim>::faces_per_cell
                                            + my_degree)
                                       * (my_degree + 1)
@@ -925,144 +925,144 @@ const
                                      * my_degree + k
                                      + GeometryInfo<dim>::lines_per_cell][1][0]
                                     [0]
-                            = p1_grad_grads[i + ((j + 2) * (my_degree + 2) + k
+                            = p1_hessians[i + ((j + 2) * (my_degree + 2) + k
                                                  + 2) * (my_degree + 1)][2][2];
-                          grad_grads[(i + (j + 2
+                          hessians[(i + (j + 2
                                            * GeometryInfo<dim>::faces_per_cell
                                            + my_degree) * (my_degree + 1)
                                       + GeometryInfo<dim>::lines_per_cell)
                                      * my_degree + k
                                      + GeometryInfo<dim>::lines_per_cell][1][0]
                                     [1]
-                            = p1_grad_grads[i + ((j + 2) * (my_degree + 2) + k
+                            = p1_hessians[i + ((j + 2) * (my_degree + 2) + k
                                                  + 2) * (my_degree + 1)][2][0];
-                          grad_grads[(i + (j + 2
+                          hessians[(i + (j + 2
                                            * GeometryInfo<dim>::faces_per_cell
                                            + my_degree) * (my_degree + 1)
                                       + GeometryInfo<dim>::lines_per_cell)
                                      * my_degree + k
                                      + GeometryInfo<dim>::lines_per_cell][1][0]
                                     [2]
-                            = p1_grad_grads[i + ((j + 2) * (my_degree + 2) + k
+                            = p1_hessians[i + ((j + 2) * (my_degree + 2) + k
                                                  + 2) * (my_degree + 1)][2][1];
-                          grad_grads[(i + (j + 2
+                          hessians[(i + (j + 2
                                            * GeometryInfo<dim>::faces_per_cell
                                            + my_degree) * (my_degree + 1)
                                       + GeometryInfo<dim>::lines_per_cell)
                                      * my_degree + k
                                      + GeometryInfo<dim>::lines_per_cell][1][1]
                                     [0]
-                            = p1_grad_grads[i + ((j + 2) * (my_degree + 2) + k
+                            = p1_hessians[i + ((j + 2) * (my_degree + 2) + k
                                                  + 2) * (my_degree + 1)][0][2];
-                          grad_grads[(i + (j + 2
+                          hessians[(i + (j + 2
                                            * GeometryInfo<dim>::faces_per_cell
                                            + my_degree) * (my_degree + 1)
                                       + GeometryInfo<dim>::lines_per_cell)
                                      * my_degree + k
                                      + GeometryInfo<dim>::lines_per_cell][1][1]
                                     [1]
-                            = p1_grad_grads[i + ((j + 2) * (my_degree + 2) + k
+                            = p1_hessians[i + ((j + 2) * (my_degree + 2) + k
                                                  + 2) * (my_degree + 1)][0][0];
-                          grad_grads[(i + (j + 2
+                          hessians[(i + (j + 2
                                            * GeometryInfo<dim>::faces_per_cell
                                            + my_degree) * (my_degree + 1)
                                       + GeometryInfo<dim>::lines_per_cell)
                                      * my_degree + k
                                      + GeometryInfo<dim>::lines_per_cell][1][1]
                                     [2]
-                            = p1_grad_grads[i + ((j + 2) * (my_degree + 2) + k
+                            = p1_hessians[i + ((j + 2) * (my_degree + 2) + k
                                                  + 2) * (my_degree + 1)][0][1];
-                          grad_grads[(i + (j + 2
+                          hessians[(i + (j + 2
                                            * GeometryInfo<dim>::faces_per_cell
                                            + my_degree) * (my_degree + 1)
                                       + GeometryInfo<dim>::lines_per_cell)
                                      * my_degree + k
                                      + GeometryInfo<dim>::lines_per_cell][1][2]
                                     [0]
-                            = p1_grad_grads[i + ((j + 2) * (my_degree + 2) + k
+                            = p1_hessians[i + ((j + 2) * (my_degree + 2) + k
                                                  + 2) * (my_degree + 1)][1][2];
-                          grad_grads[(i + (j + 2
+                          hessians[(i + (j + 2
                                            * GeometryInfo<dim>::faces_per_cell
                                            + my_degree) * (my_degree + 1)
                                       + GeometryInfo<dim>::lines_per_cell)
                                      * my_degree + k
                                      + GeometryInfo<dim>::lines_per_cell][1][2]
                                     [1]
-                            = p1_grad_grads[i + ((j + 2) * (my_degree + 2) + k
+                            = p1_hessians[i + ((j + 2) * (my_degree + 2) + k
                                                  + 2) * (my_degree + 1)][1][0];
-                          grad_grads[(i + (j + 2
+                          hessians[(i + (j + 2
                                            * GeometryInfo<dim>::faces_per_cell
                                            + my_degree) * (my_degree + 1)
                                       + GeometryInfo<dim>::lines_per_cell)
                                      * my_degree + k
                                      + GeometryInfo<dim>::lines_per_cell][1][2]
                                     [2]
-                            = p1_grad_grads[i + ((j + 2) * (my_degree + 2) + k
+                            = p1_hessians[i + ((j + 2) * (my_degree + 2) + k
                                                  + 2) * (my_degree + 1)][1][1];
-                          grad_grads[i + (j + (k + 2
+                          hessians[i + (j + (k + 2
                                                * (GeometryInfo<dim>::faces_per_cell
                                                   + my_degree)) * my_degree
                                           + GeometryInfo<dim>::lines_per_cell)
                                      * (my_degree + 1)][2][0][0]
-                            = p2_grad_grads[i + (j + (k + 2) * (my_degree + 2)
+                            = p2_hessians[i + (j + (k + 2) * (my_degree + 2)
                                                  + 2) * (my_degree + 1)][1][1];
-                          grad_grads[i + (j + (k + 2
+                          hessians[i + (j + (k + 2
                                                * (GeometryInfo<dim>::faces_per_cell
                                                   + my_degree)) * my_degree
                                           + GeometryInfo<dim>::lines_per_cell)
                                      * (my_degree + 1)][2][0][1]
-                            = p2_grad_grads[i + (j + (k + 2) * (my_degree + 2)
+                            = p2_hessians[i + (j + (k + 2) * (my_degree + 2)
                                                  + 2) * (my_degree + 1)][1][2];
-                          grad_grads[i + (j + (k + 2
+                          hessians[i + (j + (k + 2
                                                * (GeometryInfo<dim>::faces_per_cell
                                                   + my_degree))
                                           * my_degree
                                           + GeometryInfo<dim>::lines_per_cell)
                                      * (my_degree + 1)][2][0][2]
-                            = p2_grad_grads[i + (j + (k + 2) * (my_degree + 2)
+                            = p2_hessians[i + (j + (k + 2) * (my_degree + 2)
                                                  + 2) * (my_degree + 1)][1][0];
-                          grad_grads[i + (j + (k + 2
+                          hessians[i + (j + (k + 2
                                                * (GeometryInfo<dim>::faces_per_cell
                                                   + my_degree))
                                           * my_degree
                                           + GeometryInfo<dim>::lines_per_cell)
                                      * (my_degree + 1)][2][1][0]
-                            = p2_grad_grads[i + (j + (k + 2) * (my_degree + 2)
+                            = p2_hessians[i + (j + (k + 2) * (my_degree + 2)
                                                  + 2) * (my_degree + 1)][2][1];
-                          grad_grads[i + (j + (k + 2
+                          hessians[i + (j + (k + 2
                                                * (GeometryInfo<dim>::faces_per_cell
                                                   + my_degree)) * my_degree
                                           + GeometryInfo<dim>::lines_per_cell)
                                      * (my_degree + 1)][2][1][1]
-                            = p2_grad_grads[i + (j + (k + 2) * (my_degree + 2)
+                            = p2_hessians[i + (j + (k + 2) * (my_degree + 2)
                                                  + 2) * (my_degree + 1)][2][2];
-                          grad_grads[i + (j + (k + 2
+                          hessians[i + (j + (k + 2
                                                * (GeometryInfo<dim>::faces_per_cell
                                                   + my_degree)) * my_degree
                                           + GeometryInfo<dim>::lines_per_cell)
                                      * (my_degree + 1)][2][1][2]
-                            = p2_grad_grads[i + (j + (k + 2) * (my_degree + 2)
+                            = p2_hessians[i + (j + (k + 2) * (my_degree + 2)
                                                  + 2) * (my_degree + 1)][2][0];
-                          grad_grads[i + (j + (k + 2
+                          hessians[i + (j + (k + 2
                                                * (GeometryInfo<dim>::faces_per_cell
                                                   + my_degree)) * my_degree
                                           + GeometryInfo<dim>::lines_per_cell)
                                      * (my_degree + 1)][2][2][0]
-                            = p2_grad_grads[i + (j + (k + 2) * (my_degree + 2)
+                            = p2_hessians[i + (j + (k + 2) * (my_degree + 2)
                                                  + 2) * (my_degree + 1)][0][1];
-                          grad_grads[i + (j + (k + 2
+                          hessians[i + (j + (k + 2
                                                * (GeometryInfo<dim>::faces_per_cell
                                                   + my_degree)) * my_degree
                                           + GeometryInfo<dim>::lines_per_cell)
                                      * (my_degree + 1)][2][2][1]
-                           = p2_grad_grads[i + (j + (k + 2) * (my_degree + 2)
+                           = p2_hessians[i + (j + (k + 2) * (my_degree + 2)
                                                 + 2) * (my_degree + 1)][0][2];
-                          grad_grads[i + (j + (k + 2
+                          hessians[i + (j + (k + 2
                                                * (GeometryInfo<dim>::faces_per_cell
                                                   + my_degree)) * my_degree
                                           + GeometryInfo<dim>::lines_per_cell)
                                      * (my_degree + 1)][2][2][2]
-                            = p2_grad_grads[i + (j + (k + 2) * (my_degree + 2)
+                            = p2_hessians[i + (j + (k + 2) * (my_degree + 2)
                                                  + 2) * (my_degree + 1)][0][0];
                         }
 
@@ -1075,12 +1075,12 @@ const
                                   {
                                     for (unsigned int o = 0; o < 2; ++o)
                                       {
-                                        grad_grads[i + (j + (2 * (k + 2 * n)
+                                        hessians[i + (j + (2 * (k + 2 * n)
                                                              + 1) * my_degree
                                                         + GeometryInfo<dim>::lines_per_cell)
                                                    * (my_degree + 1)][o + n][l][m]
                                           = 0.0;
-                                        grad_grads[(i + 2 * (k + 2 * (n + 1))
+                                        hessians[(i + 2 * (k + 2 * (n + 1))
                                                     * (my_degree + 1)
                                                     + GeometryInfo<dim>::lines_per_cell)
                                                    * my_degree + j
@@ -1088,245 +1088,245 @@ const
                                                   [o + k][l][m] = 0.0;
                                       }
 
-                                    grad_grads[(i + 2 * k * (my_degree + 1)
+                                    hessians[(i + 2 * k * (my_degree + 1)
                                                 + GeometryInfo<dim>::lines_per_cell)
                                                * my_degree + j
                                                + GeometryInfo<dim>::lines_per_cell]
                                               [2 * n][l][m] = 0.0;
-                                    grad_grads[i + (j + (2 * k + 9)
+                                    hessians[i + (j + (2 * k + 9)
                                                     * my_degree
                                                     + GeometryInfo<dim>::lines_per_cell)
                                                * (my_degree + 1)][2 * n][l][m]
                                       = 0.0;
                                   }
 
-                                grad_grads[i + (j + (2 * k + 5) * my_degree
+                                hessians[i + (j + (2 * k + 5) * my_degree
                                                 + GeometryInfo<dim>::lines_per_cell)
                                              * (my_degree + 1)]
                                           [0][l][m]
-                                  = unit_point_grad_grads[i + ((j + 2)
+                                  = unit_point_hessians[i + ((j + 2)
                                                                * (my_degree
                                                                   + 2) + k)
                                                           * (my_degree + 1)][l]
                                                          [m];
-                                grad_grads[(i + 2 * (k + 4) * (my_degree + 1)
+                                hessians[(i + 2 * (k + 4) * (my_degree + 1)
                                             + GeometryInfo<dim>::lines_per_cell)
                                            * my_degree + j
                                            + GeometryInfo<dim>::lines_per_cell]
                                           [0][l][m]
-                                  = unit_point_grad_grads[i + (j + k
+                                  = unit_point_hessians[i + (j + k
                                                                * (my_degree
                                                                   + 2) + 2)
                                                           * (my_degree + 1)][l]
                                                          [m];
                               }
 
-                          grad_grads[(i + 2 * k * (my_degree + 1)
+                          hessians[(i + 2 * k * (my_degree + 1)
                                       + GeometryInfo<dim>::lines_per_cell)
                                      * my_degree + j
                                      + GeometryInfo<dim>::lines_per_cell][1][0]
                                     [0]
-                            = p1_grad_grads[i + (j + k * (my_degree + 2) + 2)
+                            = p1_hessians[i + (j + k * (my_degree + 2) + 2)
                                             * (my_degree + 1)][2][2];
-                          grad_grads[(i + 2 * k * (my_degree + 1)
+                          hessians[(i + 2 * k * (my_degree + 1)
                                       + GeometryInfo<dim>::lines_per_cell)
                                      * my_degree + j
                                      + GeometryInfo<dim>::lines_per_cell][1][0]
                                     [1]
-                            = p1_grad_grads[i + (j + k * (my_degree + 2) + 2)
+                            = p1_hessians[i + (j + k * (my_degree + 2) + 2)
                                             * (my_degree + 1)][2][0];
-                          grad_grads[(i + 2 * k * (my_degree + 1)
+                          hessians[(i + 2 * k * (my_degree + 1)
                                       + GeometryInfo<dim>::lines_per_cell)
                                      * my_degree + j
                                      + GeometryInfo<dim>::lines_per_cell][1][0]
                                     [2]
-                            = p1_grad_grads[i + (j + k * (my_degree + 2) + 2)
+                            = p1_hessians[i + (j + k * (my_degree + 2) + 2)
                                             * (my_degree + 1)][2][1];
-                          grad_grads[(i + 2 * k * (my_degree + 1)
+                          hessians[(i + 2 * k * (my_degree + 1)
                                       + GeometryInfo<dim>::lines_per_cell)
                                      * my_degree + j
                                      + GeometryInfo<dim>::lines_per_cell][1][1]
                                     [0]
-                            = p1_grad_grads[i + (j + k * (my_degree + 2) + 2)
+                            = p1_hessians[i + (j + k * (my_degree + 2) + 2)
                                             * (my_degree + 1)][0][2];
-                          grad_grads[(i + 2 * k * (my_degree + 1)
+                          hessians[(i + 2 * k * (my_degree + 1)
                                       + GeometryInfo<dim>::lines_per_cell)
                                      * my_degree + j
                                      + GeometryInfo<dim>::lines_per_cell][1][1]
                                     [1]
-                            = p1_grad_grads[i + (j + k * (my_degree + 2) + 2)
+                            = p1_hessians[i + (j + k * (my_degree + 2) + 2)
                                             * (my_degree + 1)][0][0];
-                          grad_grads[(i + 2 * k * (my_degree + 1)
+                          hessians[(i + 2 * k * (my_degree + 1)
                                       + GeometryInfo<dim>::lines_per_cell)
                                      * my_degree + j
                                      + GeometryInfo<dim>::lines_per_cell][1][1]
                                     [2]
-                            = p1_grad_grads[i + (j + k * (my_degree + 2) + 2)
+                            = p1_hessians[i + (j + k * (my_degree + 2) + 2)
                                             * (my_degree + 1)][0][1];
-                          grad_grads[(i + 2 * k * (my_degree + 1)
+                          hessians[(i + 2 * k * (my_degree + 1)
                                       + GeometryInfo<dim>::lines_per_cell)
                                      * my_degree + j
                                      + GeometryInfo<dim>::lines_per_cell][1][2]
                                     [0]
-                            = p1_grad_grads[i + (j + k * (my_degree + 2) + 2)
+                            = p1_hessians[i + (j + k * (my_degree + 2) + 2)
                                             * (my_degree + 1)][1][2];
-                          grad_grads[(i + 2 * k * (my_degree + 1)
+                          hessians[(i + 2 * k * (my_degree + 1)
                                       + GeometryInfo<dim>::lines_per_cell)
                                      * my_degree + j
                                      + GeometryInfo<dim>::lines_per_cell][1][2]
                                     [1]
-                            = p1_grad_grads[i + (j + k * (my_degree + 2) + 2)
+                            = p1_hessians[i + (j + k * (my_degree + 2) + 2)
                                             * (my_degree + 1)][1][0];
-                          grad_grads[(i + 2 * k * (my_degree + 1)
+                          hessians[(i + 2 * k * (my_degree + 1)
                                       + GeometryInfo<dim>::lines_per_cell)
                                      * my_degree + j
                                      + GeometryInfo<dim>::lines_per_cell][1][2]
                                     [2]
-                            = p1_grad_grads[i + (j + k * (my_degree + 2) + 2)
+                            = p1_hessians[i + (j + k * (my_degree + 2) + 2)
                                             * (my_degree + 1)][1][1];
-                          grad_grads[i + (j + (2 * k + 1) * my_degree
+                          hessians[i + (j + (2 * k + 1) * my_degree
                                           + GeometryInfo<dim>::lines_per_cell)
                                      * (my_degree + 1)][2][0][0]
-                            = p2_grad_grads[i + ((j + 2) * (my_degree + 2) + k)
+                            = p2_hessians[i + ((j + 2) * (my_degree + 2) + k)
                                             * (my_degree + 1)][1][1];
-                          grad_grads[i + (j + (2 * k + 1) * my_degree
+                          hessians[i + (j + (2 * k + 1) * my_degree
                                           + GeometryInfo<dim>::lines_per_cell)
                                      * (my_degree + 1)][2][0][1]
-                            = p2_grad_grads[i + ((j + 2) * (my_degree + 2) + k)
+                            = p2_hessians[i + ((j + 2) * (my_degree + 2) + k)
                                             * (my_degree + 1)][1][2];
-                          grad_grads[i + (j + (2 * k + 1) * my_degree
+                          hessians[i + (j + (2 * k + 1) * my_degree
                                           + GeometryInfo<dim>::lines_per_cell)
                                      * (my_degree + 1)][2][0][2]
-                            = p2_grad_grads[i + ((j + 2) * (my_degree + 2) + k)
+                            = p2_hessians[i + ((j + 2) * (my_degree + 2) + k)
                                             * (my_degree + 1)][1][0];
-                          grad_grads[i + (j + (2 * k + 1) * my_degree
+                          hessians[i + (j + (2 * k + 1) * my_degree
                                           + GeometryInfo<dim>::lines_per_cell)
                                      * (my_degree + 1)][2][1][0]
-                            = p2_grad_grads[i + ((j + 2) * (my_degree + 2) + k)
+                            = p2_hessians[i + ((j + 2) * (my_degree + 2) + k)
                                             * (my_degree + 1)][2][1];
-                          grad_grads[i + (j + (2 * k + 1) * my_degree
+                          hessians[i + (j + (2 * k + 1) * my_degree
                                           + GeometryInfo<dim>::lines_per_cell)
                                      * (my_degree + 1)][2][1][1]
-                            = p2_grad_grads[i + ((j + 2) * (my_degree + 2) + k)
+                            = p2_hessians[i + ((j + 2) * (my_degree + 2) + k)
                                             * (my_degree + 1)][2][2];
-                          grad_grads[i + (j + (2 * k + 1) * my_degree
+                          hessians[i + (j + (2 * k + 1) * my_degree
                                           + GeometryInfo<dim>::lines_per_cell)
                                      * (my_degree + 1)][2][1][2]
-                            = p2_grad_grads[i + ((j + 2) * (my_degree + 2) + k)
+                            = p2_hessians[i + ((j + 2) * (my_degree + 2) + k)
                                             * (my_degree + 1)][2][0];
-                          grad_grads[i + (j + (2 * k + 1) * my_degree
+                          hessians[i + (j + (2 * k + 1) * my_degree
                                           + GeometryInfo<dim>::lines_per_cell)
                                      * (my_degree + 1)][2][2][0]
-                            = p2_grad_grads[i + ((j + 2) * (my_degree + 2) + k)
+                            = p2_hessians[i + ((j + 2) * (my_degree + 2) + k)
                                             * (my_degree + 1)][0][1];
-                          grad_grads[i + (j + (2 * k + 1) * my_degree
+                          hessians[i + (j + (2 * k + 1) * my_degree
                                           + GeometryInfo<dim>::lines_per_cell)
                                      * (my_degree + 1)][2][2][1]
-                            = p2_grad_grads[i + ((j + 2) * (my_degree + 2) + k)
+                            = p2_hessians[i + ((j + 2) * (my_degree + 2) + k)
                                             * (my_degree + 1)][0][2];
-                          grad_grads[i + (j + (2 * k + 1) * my_degree
+                          hessians[i + (j + (2 * k + 1) * my_degree
                                           + GeometryInfo<dim>::lines_per_cell)
                                      * (my_degree + 1)][2][2][2]
-                            = p2_grad_grads[i + ((j + 2) * (my_degree + 2) + k)
+                            = p2_hessians[i + ((j + 2) * (my_degree + 2) + k)
                                             * (my_degree + 1)][0][0];
-                          grad_grads[(i + 2 * (k + 2) * (my_degree + 1)
+                          hessians[(i + 2 * (k + 2) * (my_degree + 1)
                                       + GeometryInfo<dim>::lines_per_cell)
                                      * my_degree + j
                                      + GeometryInfo<dim>::lines_per_cell][2][0][0]
-                            = p2_grad_grads[i + (j + k * (my_degree + 2) + 2)
+                            = p2_hessians[i + (j + k * (my_degree + 2) + 2)
                                             * (my_degree + 1)][1][1];
-                          grad_grads[(i + 2 * (k + 2) * (my_degree + 1)
+                          hessians[(i + 2 * (k + 2) * (my_degree + 1)
                                       + GeometryInfo<dim>::lines_per_cell)
                                      * my_degree + j
                                      + GeometryInfo<dim>::lines_per_cell][2][0][1]
-                            = p2_grad_grads[i + (j + k * (my_degree + 2) + 2)
+                            = p2_hessians[i + (j + k * (my_degree + 2) + 2)
                                             * (my_degree + 1)][1][2];
-                          grad_grads[(i + 2 * (k + 2) * (my_degree + 1)
+                          hessians[(i + 2 * (k + 2) * (my_degree + 1)
                                       + GeometryInfo<dim>::lines_per_cell)
                                      * my_degree + j
                                      + GeometryInfo<dim>::lines_per_cell][2][0][2]
-                            = p2_grad_grads[i + (j + k * (my_degree + 2) + 2)
+                            = p2_hessians[i + (j + k * (my_degree + 2) + 2)
                                             * (my_degree + 1)][1][0];
-                          grad_grads[(i + 2 * (k + 2) * (my_degree + 1)
+                          hessians[(i + 2 * (k + 2) * (my_degree + 1)
                                       + GeometryInfo<dim>::lines_per_cell)
                                      * my_degree + j
                                      + GeometryInfo<dim>::lines_per_cell][2][1][0]
-                            = p2_grad_grads[i + (j + k * (my_degree + 2) + 2)
+                            = p2_hessians[i + (j + k * (my_degree + 2) + 2)
                                             * (my_degree + 1)][2][1];
-                          grad_grads[(i + 2 * (k + 2) * (my_degree + 1)
+                          hessians[(i + 2 * (k + 2) * (my_degree + 1)
                                       + GeometryInfo<dim>::lines_per_cell)
                                      * my_degree + j
                                      + GeometryInfo<dim>::lines_per_cell][2][1][1]
-                            = p2_grad_grads[i + (j + k * (my_degree + 2) + 2)
+                            = p2_hessians[i + (j + k * (my_degree + 2) + 2)
                                             * (my_degree + 1)][2][2];
-                          grad_grads[(i + 2 * (k + 2) * (my_degree + 1)
+                          hessians[(i + 2 * (k + 2) * (my_degree + 1)
                                       + GeometryInfo<dim>::lines_per_cell)
                                      * my_degree + j
                                      + GeometryInfo<dim>::lines_per_cell][2][1][2]
-                            = p2_grad_grads[i + (j + k * (my_degree + 2) + 2)
+                            = p2_hessians[i + (j + k * (my_degree + 2) + 2)
                                             * (my_degree + 1)][2][0];
-                          grad_grads[(i + 2 * (k + 2) * (my_degree + 1)
+                          hessians[(i + 2 * (k + 2) * (my_degree + 1)
                                       + GeometryInfo<dim>::lines_per_cell)
                                      * my_degree + j
                                      + GeometryInfo<dim>::lines_per_cell][2][2][0]
-                            = p2_grad_grads[i + (j + k * (my_degree + 2) + 2)
+                            = p2_hessians[i + (j + k * (my_degree + 2) + 2)
                                             * (my_degree + 1)][0][1];
-                          grad_grads[(i + 2 * (k + 2) * (my_degree + 1)
+                          hessians[(i + 2 * (k + 2) * (my_degree + 1)
                                       + GeometryInfo<dim>::lines_per_cell)
                                      * my_degree + j
                                      + GeometryInfo<dim>::lines_per_cell][2][2][1]
-                            = p2_grad_grads[i + (j + k * (my_degree + 2) + 2)
+                            = p2_hessians[i + (j + k * (my_degree + 2) + 2)
                                             * (my_degree + 1)][0][2];
-                          grad_grads[(i + 2 * (k + 2) * (my_degree + 1)
+                          hessians[(i + 2 * (k + 2) * (my_degree + 1)
                                       + GeometryInfo<dim>::lines_per_cell)
                                      * my_degree + j
                                      + GeometryInfo<dim>::lines_per_cell][2][2][2]
-                            = p2_grad_grads[i + (j + k * (my_degree + 2) + 2)
+                            = p2_hessians[i + (j + k * (my_degree + 2) + 2)
                                             * (my_degree + 1)][0][0];
-                          grad_grads[i + (j + (2 * k + 9) * my_degree
+                          hessians[i + (j + (2 * k + 9) * my_degree
                                           + GeometryInfo<dim>::lines_per_cell)
                                      * (my_degree + 1)][1][0][0]
-                            = p1_grad_grads[i + ((j + 2) * (my_degree + 2) + k)
+                            = p1_hessians[i + ((j + 2) * (my_degree + 2) + k)
                                             * (my_degree + 1)][2][2];
-                          grad_grads[i + (j + (2 * k + 9) * my_degree
+                          hessians[i + (j + (2 * k + 9) * my_degree
                                           + GeometryInfo<dim>::lines_per_cell)
                                      * (my_degree + 1)][1][0][1]
-                            = p1_grad_grads[i + ((j + 2) * (my_degree + 2) + k)
+                            = p1_hessians[i + ((j + 2) * (my_degree + 2) + k)
                                             * (my_degree + 1)][2][0];
-                          grad_grads[i + (j + (2 * k + 9) * my_degree
+                          hessians[i + (j + (2 * k + 9) * my_degree
                                           + GeometryInfo<dim>::lines_per_cell)
                                      * (my_degree + 1)][1][0][2]
-                            = p1_grad_grads[i + ((j + 2) * (my_degree + 2) + k)
+                            = p1_hessians[i + ((j + 2) * (my_degree + 2) + k)
                                             * (my_degree + 1)][2][1];
-                          grad_grads[i + (j + (2 * k + 9) * my_degree
+                          hessians[i + (j + (2 * k + 9) * my_degree
                                           + GeometryInfo<dim>::lines_per_cell)
                                      * (my_degree + 1)][1][1][0]
-                            = p1_grad_grads[i + ((j + 2) * (my_degree + 2) + k)
+                            = p1_hessians[i + ((j + 2) * (my_degree + 2) + k)
                                             * (my_degree + 1)][0][2];
-                          grad_grads[i + (j + (2 * k + 9) * my_degree
+                          hessians[i + (j + (2 * k + 9) * my_degree
                                           + GeometryInfo<dim>::lines_per_cell)
                                      * (my_degree + 1)][1][1][1]
-                            = p1_grad_grads[i + ((j + 2) * (my_degree + 2) + k)
+                            = p1_hessians[i + ((j + 2) * (my_degree + 2) + k)
                                             * (my_degree + 1)][0][0];
-                          grad_grads[i + (j + (2 * k + 9) * my_degree
+                          hessians[i + (j + (2 * k + 9) * my_degree
                                           + GeometryInfo<dim>::lines_per_cell)
                                      * (my_degree + 1)][1][1][2]
-                            = p1_grad_grads[i + ((j + 2) * (my_degree + 2) + k)
+                            = p1_hessians[i + ((j + 2) * (my_degree + 2) + k)
                                             * (my_degree + 1)][0][1];
-                          grad_grads[i + (j + (2 * k + 9) * my_degree
+                          hessians[i + (j + (2 * k + 9) * my_degree
                                           + GeometryInfo<dim>::lines_per_cell)
                                      * (my_degree + 1)][1][2][0]
-                            = p1_grad_grads[i + ((j + 2) * (my_degree + 2) + k)
+                            = p1_hessians[i + ((j + 2) * (my_degree + 2) + k)
                                             * (my_degree + 1)][1][2];
-                          grad_grads[i + (j + (2 * k + 9) * my_degree
+                          hessians[i + (j + (2 * k + 9) * my_degree
                                           + GeometryInfo<dim>::lines_per_cell)
                                      * (my_degree + 1)][1][2][1]
-                            = p1_grad_grads[i + ((j + 2) * (my_degree + 2) + k)
+                            = p1_hessians[i + ((j + 2) * (my_degree + 2) + k)
                                             * (my_degree + 1)][1][0];
-                          grad_grads[i + (j + (2 * k + 9) * my_degree
+                          hessians[i + (j + (2 * k + 9) * my_degree
                                           + GeometryInfo<dim>::lines_per_cell)
                                      * (my_degree + 1)][1][2][2]
-                            = p1_grad_grads[i + ((j + 2) * (my_degree + 2) + k)
+                            = p1_hessians[i + ((j + 2) * (my_degree + 2) + k)
                                             * (my_degree + 1)][1][1];
                         }
                     }
index f9c7e0f7c0d0aad59363704ef05660df296397c7..408863fb26b7ac2809dd0683614002179d9c4c17 100644 (file)
@@ -56,14 +56,14 @@ void
 PolynomialsRaviartThomas<dim>::compute (const Point<dim>            &unit_point,
                                         std::vector<Tensor<1,dim> > &values,
                                         std::vector<Tensor<2,dim> > &grads,
-                                        std::vector<Tensor<3,dim> > &grad_grads) const
+                                        std::vector<Tensor<3,dim> > &hessians) const
 {
   Assert(values.size()==n_pols || values.size()==0,
          ExcDimensionMismatch(values.size(), n_pols));
   Assert(grads.size()==n_pols|| grads.size()==0,
          ExcDimensionMismatch(grads.size(), n_pols));
-  Assert(grad_grads.size()==n_pols|| grad_grads.size()==0,
-         ExcDimensionMismatch(grad_grads.size(), n_pols));
+  Assert(hessians.size()==n_pols|| hessians.size()==0,
+         ExcDimensionMismatch(hessians.size(), n_pols));
 
                                    // have a few scratch
                                    // arrays. because we don't want to
@@ -83,12 +83,12 @@ PolynomialsRaviartThomas<dim>::compute (const Point<dim>            &unit_point,
 
   static std::vector<double> p_values;
   static std::vector<Tensor<1,dim> > p_grads;
-  static std::vector<Tensor<2,dim> > p_grad_grads;
+  static std::vector<Tensor<2,dim> > p_hessians;
 
   const unsigned int n_sub = polynomial_space.n();
   p_values.resize((values.size() == 0) ? 0 : n_sub);
   p_grads.resize((grads.size() == 0) ? 0 : n_sub);
-  p_grad_grads.resize((grad_grads.size() == 0) ? 0 : n_sub);
+  p_hessians.resize((hessians.size() == 0) ? 0 : n_sub);
 
   for (unsigned int d=0;d<dim;++d)
     {
@@ -107,7 +107,7 @@ PolynomialsRaviartThomas<dim>::compute (const Point<dim>            &unit_point,
       for (unsigned int c=0;c<dim;++c)
         p(c) = unit_point((c+d)%dim);
 
-      polynomial_space.compute (p, p_values, p_grads, p_grad_grads);
+      polynomial_space.compute (p, p_values, p_grads, p_hessians);
 
       for (unsigned int i=0;i<p_values.size();++i)
           values[i+d*n_sub][d] = p_values[i];
@@ -116,11 +116,11 @@ PolynomialsRaviartThomas<dim>::compute (const Point<dim>            &unit_point,
         for (unsigned int d1=0;d1<dim;++d1)
           grads[i+d*n_sub][d][(d1+d)%dim] = p_grads[i][d1];
 
-      for (unsigned int i=0;i<p_grad_grads.size();++i)
+      for (unsigned int i=0;i<p_hessians.size();++i)
         for (unsigned int d1=0;d1<dim;++d1)
           for (unsigned int d2=0;d2<dim;++d2)
-            grad_grads[i+d*n_sub][d][(d1+d)%dim][(d2+d)%dim]
-              = p_grad_grads[i][d1][d2];
+            hessians[i+d*n_sub][d][(d1+d)%dim][(d2+d)%dim]
+              = p_hessians[i][d1][d2];
     }
 }
 
index 2013737f0ef00b41f67072a445d91231f8e447d9..62d0c3d72372e4f19a84961acb78cbb29f8e722e 100644 (file)
@@ -166,7 +166,7 @@ TensorProductPolynomials<dim>::compute_grad (const unsigned int i,
 
 template <int dim>
 Tensor<2,dim>
-TensorProductPolynomials<dim>::compute_grad_grad (const unsigned int i,
+TensorProductPolynomials<dim>::compute_hessian (const unsigned int i,
                                                   const Point<dim> &p) const
 {
   unsigned int indices[dim];
@@ -184,11 +184,11 @@ TensorProductPolynomials<dim>::compute_grad_grad (const unsigned int i,
       }
   }
 
-  Tensor<2,dim> grad_grad;
+  Tensor<2,dim> hessian;
   for (unsigned int d1=0; d1<dim; ++d1)
     for (unsigned int d2=0; d2<dim; ++d2)
       {
-        grad_grad[d1][d2] = 1.;
+        hessian[d1][d2] = 1.;
         for (unsigned int x=0; x<dim; ++x)
           {
             unsigned int derivative=0;
@@ -199,11 +199,11 @@ TensorProductPolynomials<dim>::compute_grad_grad (const unsigned int i,
                 else
                   derivative=1;
               }
-            grad_grad[d1][d2] *= v[x][derivative];
+            hessian[d1][d2] *= v[x][derivative];
           }
       }
 
-  return grad_grad;
+  return hessian;
 }
 
 
@@ -215,18 +215,18 @@ TensorProductPolynomials<dim>::
 compute (const Point<dim>            &p,
          std::vector<double>         &values,
          std::vector<Tensor<1,dim> > &grads,
-         std::vector<Tensor<2,dim> > &grad_grads) const
+         std::vector<Tensor<2,dim> > &hessians) const
 {
   Assert (values.size()==n_tensor_pols    || values.size()==0,
           ExcDimensionMismatch2(values.size(), n_tensor_pols, 0));
   Assert (grads.size()==n_tensor_pols     || grads.size()==0,
           ExcDimensionMismatch2(grads.size(), n_tensor_pols, 0));
-  Assert (grad_grads.size()==n_tensor_pols|| grad_grads.size()==0,
-          ExcDimensionMismatch2(grad_grads.size(), n_tensor_pols, 0));
+  Assert (hessians.size()==n_tensor_pols|| hessians.size()==0,
+          ExcDimensionMismatch2(hessians.size(), n_tensor_pols, 0));
 
   const bool update_values     = (values.size() == n_tensor_pols),
              update_grads      = (grads.size()==n_tensor_pols),
-             update_grad_grads = (grad_grads.size()==n_tensor_pols);
+             update_hessians = (hessians.size()==n_tensor_pols);
 
                                    // check how many
                                    // values/derivatives we have to
@@ -236,7 +236,7 @@ compute (const Point<dim>            &p,
     n_values_and_derivatives = 1;
   if (update_grads)
     n_values_and_derivatives = 2;
-  if (update_grad_grads)
+  if (update_hessians)
     n_values_and_derivatives = 3;
 
 
@@ -284,11 +284,11 @@ compute (const Point<dim>            &p,
               grads[i][d] *= v(x,indices[x])[d==x];
           }
 
-      if (update_grad_grads)
+      if (update_hessians)
         for (unsigned int d1=0; d1<dim; ++d1)
           for (unsigned int d2=0; d2<dim; ++d2)
             {
-              grad_grads[i][d1][d2] = 1.;
+              hessians[i][d1][d2] = 1.;
               for (unsigned int x=0; x<dim; ++x)
                 {
                   unsigned int derivative=0;
@@ -299,7 +299,7 @@ compute (const Point<dim>            &p,
                       else
                         derivative=1;
                     }
-                  grad_grads[i][d1][d2]
+                  hessians[i][d1][d2]
                     *= v(x,indices[x])[derivative];
                 }
             }
@@ -436,7 +436,7 @@ AnisotropicPolynomials<dim>::compute_grad (const unsigned int i,
 
 template <int dim>
 Tensor<2,dim>
-AnisotropicPolynomials<dim>::compute_grad_grad (const unsigned int i,
+AnisotropicPolynomials<dim>::compute_hessian (const unsigned int i,
                                                   const Point<dim> &p) const
 {
   unsigned int indices[dim];
@@ -446,11 +446,11 @@ AnisotropicPolynomials<dim>::compute_grad_grad (const unsigned int i,
   for (unsigned int d=0; d<dim; ++d)
     polynomials[d][indices[d]].value(p(d), v[d]);
 
-  Tensor<2,dim> grad_grad;
+  Tensor<2,dim> hessian;
   for (unsigned int d1=0; d1<dim; ++d1)
     for (unsigned int d2=0; d2<dim; ++d2)
       {
-        grad_grad[d1][d2] = 1.;
+        hessian[d1][d2] = 1.;
         for (unsigned int x=0; x<dim; ++x)
           {
             unsigned int derivative=0;
@@ -461,11 +461,11 @@ AnisotropicPolynomials<dim>::compute_grad_grad (const unsigned int i,
                 else
                   derivative=1;
               }
-            grad_grad[d1][d2] *= v[x][derivative];
+            hessian[d1][d2] *= v[x][derivative];
           }
       }
 
-  return grad_grad;
+  return hessian;
 }
 
 
@@ -477,18 +477,18 @@ AnisotropicPolynomials<dim>::
 compute (const Point<dim>            &p,
          std::vector<double>         &values,
          std::vector<Tensor<1,dim> > &grads,
-         std::vector<Tensor<2,dim> > &grad_grads) const
+         std::vector<Tensor<2,dim> > &hessians) const
 {
   Assert (values.size()==n_tensor_pols || values.size()==0,
           ExcDimensionMismatch2(values.size(), n_tensor_pols, 0));
   Assert (grads.size()==n_tensor_pols|| grads.size()==0,
           ExcDimensionMismatch2(grads.size(), n_tensor_pols, 0));
-  Assert (grad_grads.size()==n_tensor_pols|| grad_grads.size()==0,
-          ExcDimensionMismatch2(grad_grads.size(), n_tensor_pols, 0));
+  Assert (hessians.size()==n_tensor_pols|| hessians.size()==0,
+          ExcDimensionMismatch2(hessians.size(), n_tensor_pols, 0));
 
   const bool update_values     = (values.size() == n_tensor_pols),
              update_grads      = (grads.size()==n_tensor_pols),
-             update_grad_grads = (grad_grads.size()==n_tensor_pols);
+             update_hessians = (hessians.size()==n_tensor_pols);
 
                                    // check how many
                                    // values/derivatives we have to
@@ -498,7 +498,7 @@ compute (const Point<dim>            &p,
     n_values_and_derivatives = 1;
   if (update_grads)
     n_values_and_derivatives = 2;
-  if (update_grad_grads)
+  if (update_hessians)
     n_values_and_derivatives = 3;
 
 
@@ -541,11 +541,11 @@ compute (const Point<dim>            &p,
               grads[i][d] *= v[x][indices[x]][d==x ? 1 : 0];
           }
 
-      if (update_grad_grads)
+      if (update_hessians)
         for (unsigned int d1=0; d1<dim; ++d1)
           for (unsigned int d2=0; d2<dim; ++d2)
             {
-              grad_grads[i][d1][d2] = 1.;
+              hessians[i][d1][d2] = 1.;
               for (unsigned int x=0; x<dim; ++x)
                 {
                   unsigned int derivative=0;
@@ -556,7 +556,7 @@ compute (const Point<dim>            &p,
                       else
                         derivative=1;
                     }
-                  grad_grads[i][d1][d2]
+                  hessians[i][d1][d2]
                     *= v[x][indices[x]][derivative];
                 }
             }
index 8a5811c4f00556197cda5fe8dd5964b4de07947d..4915211f5ad5c43c3a791f7c569a3042192b033d 100644 (file)
@@ -283,7 +283,7 @@ FiniteElement<dim,spacedim>::shape_grad_component (const unsigned int,
 
 template <int dim, int spacedim>
 Tensor<2,dim>
-FiniteElement<dim,spacedim>::shape_grad_grad (const unsigned int,
+FiniteElement<dim,spacedim>::shape_hessian (const unsigned int,
                                          const Point<dim> &) const
 {
   AssertThrow(false, ExcUnitShapeValuesDoNotExist());
@@ -294,7 +294,7 @@ FiniteElement<dim,spacedim>::shape_grad_grad (const unsigned int,
 
 template <int dim, int spacedim>
 Tensor<2,dim>
-FiniteElement<dim,spacedim>::shape_grad_grad_component (const unsigned int,
+FiniteElement<dim,spacedim>::shape_hessian_component (const unsigned int,
                                                    const Point<dim> &,
                                                    const unsigned int) const
 {
index 850c57e586b1cf6eaf12be93318953a5250ba25a..5877049385ce0470fd74272cd4c7de3b69f4986e 100644 (file)
@@ -167,24 +167,24 @@ FE_DGPNonparametric<dim,spacedim>::shape_grad_component (const unsigned int i,
 
 template <int dim, int spacedim>
 Tensor<2,dim>
-FE_DGPNonparametric<dim,spacedim>::shape_grad_grad (const unsigned int i,
+FE_DGPNonparametric<dim,spacedim>::shape_hessian (const unsigned int i,
                               const Point<dim> &p) const
 {
   Assert (i<this->dofs_per_cell, ExcIndexRange(i, 0, this->dofs_per_cell));
-  return polynomial_space.compute_grad_grad(i, p);
+  return polynomial_space.compute_hessian(i, p);
 }
 
 
 
 template <int dim, int spacedim>
 Tensor<2,dim>
-FE_DGPNonparametric<dim,spacedim>::shape_grad_grad_component (const unsigned int i,
+FE_DGPNonparametric<dim,spacedim>::shape_hessian_component (const unsigned int i,
                                         const Point<dim> &p,
                                         const unsigned int component) const
 {
   Assert (i<this->dofs_per_cell, ExcIndexRange(i, 0, this->dofs_per_cell));
   Assert (component == 0, ExcIndexRange (component, 0, 1));
-  return polynomial_space.compute_grad_grad(i, p);
+  return polynomial_space.compute_hessian(i, p);
 }
 
 
@@ -272,7 +272,7 @@ FE_DGPNonparametric<dim,spacedim>::get_data (
 
   if (flags & update_hessians)
     {
-      data->grad_grads.resize (this->dofs_per_cell);
+      data->hessians.resize (this->dofs_per_cell);
     }
   return data;
 }
@@ -311,7 +311,7 @@ FE_DGPNonparametric<dim,spacedim>::fill_fe_values (
     for (unsigned int i=0; i<n_q_points; ++i)
       {
         polynomial_space.compute(data.quadrature_points[i],
-                                 fe_data.values, fe_data.grads, fe_data.grad_grads);
+                                 fe_data.values, fe_data.grads, fe_data.hessians);
         for (unsigned int k=0; k<this->dofs_per_cell; ++k)
           {
             if (flags & update_values)
@@ -319,7 +319,7 @@ FE_DGPNonparametric<dim,spacedim>::fill_fe_values (
             if (flags & update_gradients)
               data.shape_gradients[k][i] = fe_data.grads[k];
             if (flags & update_hessians)
-              data.shape_hessians[k][i] = fe_data.grad_grads[k];
+              data.shape_hessians[k][i] = fe_data.hessians[k];
           }
       }
 }
@@ -354,7 +354,7 @@ FE_DGPNonparametric<dim,spacedim>::fill_fe_face_values (
     for (unsigned int i=0; i<n_q_points; ++i)
       {
         polynomial_space.compute(data.quadrature_points[i],
-                                 fe_data.values, fe_data.grads, fe_data.grad_grads);
+                                 fe_data.values, fe_data.grads, fe_data.hessians);
         for (unsigned int k=0; k<this->dofs_per_cell; ++k)
           {
             if (flags & update_values)
@@ -362,7 +362,7 @@ FE_DGPNonparametric<dim,spacedim>::fill_fe_face_values (
             if (flags & update_gradients)
               data.shape_gradients[k][i] = fe_data.grads[k];
             if (flags & update_hessians)
-              data.shape_hessians[k][i] = fe_data.grad_grads[k];
+              data.shape_hessians[k][i] = fe_data.hessians[k];
           }
       }
 }
@@ -398,7 +398,7 @@ FE_DGPNonparametric<dim,spacedim>::fill_fe_subface_values (
     for (unsigned int i=0; i<n_q_points; ++i)
       {
         polynomial_space.compute(data.quadrature_points[i],
-                                 fe_data.values, fe_data.grads, fe_data.grad_grads);
+                                 fe_data.values, fe_data.grads, fe_data.hessians);
         for (unsigned int k=0; k<this->dofs_per_cell; ++k)
           {
             if (flags & update_values)
@@ -406,7 +406,7 @@ FE_DGPNonparametric<dim,spacedim>::fill_fe_subface_values (
             if (flags & update_gradients)
               data.shape_gradients[k][i] = fe_data.grads[k];
             if (flags & update_hessians)
-              data.shape_hessians[k][i] = fe_data.grad_grads[k];
+              data.shape_hessians[k][i] = fe_data.hessians[k];
           }
       }
 }
index ab42ebeefc6da7e1ef09acccf9bff9b9a3432912..f19f4d788cdbe99f77134fdfe6bbb57615f3f82c 100644 (file)
@@ -144,7 +144,7 @@ FE_PolyTensor<POLY,dim,spacedim>::shape_value_component (const unsigned int i,
     {
       cached_point = p;
       cached_values.resize(poly_space.n());
-      poly_space.compute(p, cached_values, cached_grads, cached_grad_grads);
+      poly_space.compute(p, cached_values, cached_grads, cached_hessians);
     }
 
   double s = 0;
@@ -183,7 +183,7 @@ FE_PolyTensor<POLY,dim,spacedim>::shape_grad_component (const unsigned int i,
     {
       cached_point = p;
       cached_grads.resize(poly_space.n());
-      poly_space.compute(p, cached_values, cached_grads, cached_grad_grads);
+      poly_space.compute(p, cached_values, cached_grads, cached_hessians);
     }
 
   Tensor<1,dim> s;
@@ -200,7 +200,7 @@ FE_PolyTensor<POLY,dim,spacedim>::shape_grad_component (const unsigned int i,
 
 template <class POLY, int dim, int spacedim>
 Tensor<2,dim>
-FE_PolyTensor<POLY,dim,spacedim>::shape_grad_grad (const unsigned int, const Point<dim> &) const
+FE_PolyTensor<POLY,dim,spacedim>::shape_hessian (const unsigned int, const Point<dim> &) const
 {
   typedef    FiniteElement<dim,spacedim> FEE;
   Assert(false, typename FEE::ExcFENotPrimitive());
@@ -211,26 +211,26 @@ FE_PolyTensor<POLY,dim,spacedim>::shape_grad_grad (const unsigned int, const Poi
 
 template <class POLY, int dim, int spacedim>
 Tensor<2,dim>
-FE_PolyTensor<POLY,dim,spacedim>::shape_grad_grad_component (const unsigned int i,
+FE_PolyTensor<POLY,dim,spacedim>::shape_hessian_component (const unsigned int i,
                                                     const Point<dim> &p,
                                                     const unsigned int component) const
 {
   Assert (i<this->dofs_per_cell, ExcIndexRange(i,0,this->dofs_per_cell));
   Assert (component < dim, ExcIndexRange (component, 0, dim));
 
-  if (cached_point != p || cached_grad_grads.size() == 0)
+  if (cached_point != p || cached_hessians.size() == 0)
     {
       cached_point = p;
-      cached_grad_grads.resize(poly_space.n());
-      poly_space.compute(p, cached_values, cached_grads, cached_grad_grads);
+      cached_hessians.resize(poly_space.n());
+      poly_space.compute(p, cached_values, cached_grads, cached_hessians);
     }
 
   Tensor<2,dim> s;
   if (inverse_node_matrix.n_cols() == 0)
-    return cached_grad_grads[i][component];
+    return cached_hessians[i][component];
   else
     for (unsigned int j=0;j<inverse_node_matrix.n_cols();++j)
-      s += inverse_node_matrix(i,j) * cached_grad_grads[j][component];
+      s += inverse_node_matrix(i,j) * cached_hessians[j][component];
 
   return s;
 }
@@ -266,7 +266,7 @@ FE_PolyTensor<POLY,dim,spacedim>::get_data (
                                    // some scratch arrays
   std::vector<Tensor<1,dim> > values(0);
   std::vector<Tensor<2,dim> > grads(0);
-  std::vector<Tensor<3,dim> > grad_grads(0);
+  std::vector<Tensor<3,dim> > hessians(0);
 
                                    // initialize fields only if really
                                    // necessary. otherwise, don't
@@ -293,7 +293,7 @@ FE_PolyTensor<POLY,dim,spacedim>::get_data (
                                    // that
   if (flags & update_hessians)
     {
-//      grad_grads.resize (this->dofs_per_cell);
+//      hessians.resize (this->dofs_per_cell);
       data->initialize_2nd (this, mapping, quadrature);
     }
 
@@ -307,7 +307,7 @@ FE_PolyTensor<POLY,dim,spacedim>::get_data (
     for (unsigned int k=0; k<n_q_points; ++k)
       {
         poly_space.compute(quadrature.point(k),
-                           values, grads, grad_grads);
+                           values, grads, hessians);
 
         if (flags & update_values)
           {
index 38bccab0d1340427a8392e279a68baef90456f36..cb639831613a0ec37bdca25b2b9a402075e6a763 100644 (file)
@@ -505,7 +505,7 @@ FESystem<dim,spacedim>::shape_grad_component (const unsigned int i,
 
 template <int dim, int spacedim>
 Tensor<2,dim>
-FESystem<dim,spacedim>::shape_grad_grad (const unsigned int i,
+FESystem<dim,spacedim>::shape_hessian (const unsigned int i,
                                          const Point<dim> &p) const
 {
   Assert (i<this->dofs_per_cell, ExcIndexRange(i, 0, this->dofs_per_cell));
@@ -513,14 +513,14 @@ FESystem<dim,spacedim>::shape_grad_grad (const unsigned int i,
           (typename FiniteElement<dim,spacedim>::ExcShapeFunctionNotPrimitive(i)));
 
   return (base_element(this->system_to_base_table[i].first.first)
-          .shape_grad_grad(this->system_to_base_table[i].second, p));
+          .shape_hessian(this->system_to_base_table[i].second, p));
 }
 
 
 
 template <int dim, int spacedim>
 Tensor<2,dim>
-FESystem<dim,spacedim>::shape_grad_grad_component (const unsigned int i,
+FESystem<dim,spacedim>::shape_hessian_component (const unsigned int i,
                                           const Point<dim>  &p,
                                           const unsigned int component) const
 {
@@ -548,7 +548,7 @@ FESystem<dim,spacedim>::shape_grad_grad_component (const unsigned int i,
                                    // primitive; thus, there is no
                                    // need to check this here
   return (base_element(base).
-          shape_grad_grad_component(this->system_to_base_table[i].second,
+          shape_hessian_component(this->system_to_base_table[i].second,
                                     p,
                                     component_in_base));
 }

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.