]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Make the type of normal vectors a Tensor. 1408/head
authorWolfgang Bangerth <bangerth@math.tamu.edu>
Fri, 21 Aug 2015 02:11:21 +0000 (21:11 -0500)
committerWolfgang Bangerth <bangerth@math.tamu.edu>
Fri, 21 Aug 2015 13:55:09 +0000 (08:55 -0500)
As discussed in #496, normal vectors are currently returned by FEValues
as Point<spacedim> objects, but since they are differential vectors, the
correct data type should be Tensor<1,dim>. This patch implements the solution
discussed in #496 by
* changing the return type of FEValues::normal_vector()
* deprecating FEValues::get_normal_vectors()
* introducing FEValues::get_all_normal_vectors() that returns a vector
  of tensors.

The old get_normal_vectors() function was deprecated. In order to
make it work, I also had to change the return type from a reference
to a straight array. This array may be bound to a reference in
many places in user codes, but the style we have used everywhere
is to make these reference variables very localized in scope and
so I don't foresee any problems.

36 files changed:
doc/news/changes.h
examples/step-12/step-12.cc
examples/step-30/step-30.cc
examples/step-33/step-33.cc
examples/step-34/step-34.cc
examples/step-51/step-51.cc
include/deal.II/fe/fe_update_flags.h
include/deal.II/fe/fe_values.h
include/deal.II/fe/mapping_cartesian.h
include/deal.II/integrators/elasticity.h
include/deal.II/integrators/laplace.h
include/deal.II/integrators/maxwell.h
include/deal.II/matrix_free/mapping_data_on_the_fly.h
include/deal.II/numerics/vector_tools.templates.h
source/fe/fe_values.cc
source/fe/mapping_cartesian.cc
source/numerics/data_out_faces.cc
source/numerics/error_estimator.cc
source/numerics/matrix_tools.cc
tests/aniso/mesh_3d_21.cc
tests/bits/rt_2.cc
tests/bits/step-12.cc
tests/bits/step-51.cc
tests/bits/step-51p.cc
tests/codim_one/bem.cc
tests/codim_one/bem_integration.cc
tests/codim_one/gradients.cc
tests/codim_one/surface.cc
tests/deal.II/nedelec_non_rect_face.cc
tests/deal.II/project_boundary_rt_01.cc
tests/fe/fe_q_dg0.cc
tests/fe/mapping.cc
tests/fe/mapping_c1.cc
tests/fe/rt_normal_02.cc
tests/grid/mesh_3d_6.cc
tests/hp/step-12.cc

index dc04d369f46bf6dd17e740f9b2c01d986a75f513..86dd14786f69b71f9d2d3c4bbf0f112a19645b2d 100644 (file)
@@ -38,6 +38,23 @@ inconvenience this causes.
 </p>
 
 <ol>
+  
+  <li> Changed: FEValues::normal_vector() for historical reasons returned a
+  value of type Point, though a normal vector is more adequately described
+  as a Tensor@<1,dim@>. Many similar cases were already clarified in deal.II
+  8.3. The current case has now also been changed: FEValues::normal_vector()
+  now returns a Tensor, rather than a Point.
+  <br>
+  In a similar spirit, the FEValues::get_normal_vectors() function that
+  still returns a vector of Points has been deprecated and a new function,
+  FEValues::get_all_normal_vectors(), that returns a vector of tensors,
+  has been added. This was necessary since there is no way to change the
+  return type of the existing function in a backward compatible way. The
+  old function will be removed in the next version, and the new function
+  will then be renamed to the old name.
+  <br>
+  (Wolfgang Bangerth, 2015/08/20)
+  </li>
 
   <li> Changed: The mesh_converter program has been removed from the
   contrib folder. The equivalent functionality can now be found in
index fa1342b1916749a30a69bca79c6842d93ae997d0..bc39ef2c0ee6a1d0dae807e0696314fa62e221b7 100644 (file)
@@ -357,7 +357,7 @@ namespace Step12
     Vector<double> &local_vector = dinfo.vector(0).block(0);
 
     const std::vector<double> &JxW = fe_v.get_JxW_values ();
-    const std::vector<Point<dim> > &normals = fe_v.get_normal_vectors ();
+    const std::vector<Tensor<1,dim> > &normals = fe_v.get_all_normal_vectors ();
 
     std::vector<double> g(fe_v.n_quadrature_points);
 
@@ -421,7 +421,7 @@ namespace Step12
     // solution and the right hand side does not receive any contributions.
 
     const std::vector<double> &JxW = fe_v.get_JxW_values ();
-    const std::vector<Point<dim> > &normals = fe_v.get_normal_vectors ();
+    const std::vector<Tensor<1,dim> > &normals = fe_v.get_all_normal_vectors ();
 
     for (unsigned int point=0; point<fe_v.n_quadrature_points; ++point)
       {
index cc43d651e42520a0ba54c70837434df20b3c9e71..e721418935942d31b85825ce37d52764308ddfab 100644 (file)
@@ -1,6 +1,6 @@
 /* ---------------------------------------------------------------------
  *
- * Copyright (C) 2007 - 2014 by the deal.II authors
+ * Copyright (C) 2007 - 2015 by the deal.II authors
  *
  * This file is part of the deal.II library.
  *
@@ -234,7 +234,7 @@ namespace Step30
     Vector<double> &cell_vector) const
   {
     const std::vector<double> &JxW = fe_v.get_JxW_values ();
-    const std::vector<Point<dim> > &normals = fe_v.get_normal_vectors ();
+    const std::vector<Tensor<1,dim> > &normals = fe_v.get_all_normal_vectors ();
 
     std::vector<Point<dim> > beta (fe_v.n_quadrature_points);
     std::vector<double> g(fe_v.n_quadrature_points);
@@ -272,7 +272,7 @@ namespace Step30
     FullMatrix<double> &ue_ve_matrix) const
   {
     const std::vector<double> &JxW = fe_v.get_JxW_values ();
-    const std::vector<Point<dim> > &normals = fe_v.get_normal_vectors ();
+    const std::vector<Tensor<1,dim> > &normals = fe_v.get_all_normal_vectors ();
 
     std::vector<Point<dim> > beta (fe_v.n_quadrature_points);
 
index a807803b7eaf5134d871ab96ad6c1530136f4c5e..821943bf9f4ef6fee49cf22cfa6bb51c94560e72 100644 (file)
@@ -260,7 +260,7 @@ namespace Step33
     // $\alpha$. It's form has also been given already in the introduction:
     template <typename InputVector>
     static
-    void numerical_normal_flux (const Point<dim>                   &normal,
+    void numerical_normal_flux (const Tensor<1,dim>                &normal,
                                 const InputVector                  &Wplus,
                                 const InputVector                  &Wminus,
                                 const double                        alpha,
@@ -374,7 +374,7 @@ namespace Step33
     static
     void
     compute_Wminus (const BoundaryKind  (&boundary_kind)[n_components],
-                    const Point<dim>     &normal_vector,
+                    const Tensor<1,dim>  &normal_vector,
                     const DataVector     &Wplus,
                     const Vector<double> &boundary_values,
                     const DataVector     &Wminus)
index 2d94b432f69ba3a82208f05a7384636d815a85dd..dd54cbb4d73c5e2bdbb638fbd60d6d7ad450dbfc 100644 (file)
@@ -601,8 +601,8 @@ namespace Step34
         fe_v.reinit(cell);
         cell->get_dof_indices(local_dof_indices);
 
-        const std::vector<Point<dim> > &q_points = fe_v.get_quadrature_points();
-        const std::vector<Point<dim> > &normals = fe_v.get_normal_vectors();
+        const std::vector<Point<dim> >    &q_points = fe_v.get_quadrature_points();
+        const std::vector<Tensor<1,dim> > &normals  = fe_v.get_all_normal_vectors();
         wind.vector_value_list(q_points, cell_wind);
 
         // We then form the integral over the current cell for all degrees of
@@ -687,8 +687,8 @@ namespace Step34
                 std::vector<Vector<double> > singular_cell_wind( singular_quadrature.size(),
                                                                  Vector<double>(dim) );
 
-                const std::vector<Point<dim> > &singular_normals = fe_v_singular.get_normal_vectors();
-                const std::vector<Point<dim> > &singular_q_points = fe_v_singular.get_quadrature_points();
+                const std::vector<Tensor<1,dim> > &singular_normals  = fe_v_singular.get_all_normal_vectors();
+                const std::vector<Point<dim> >    &singular_q_points = fe_v_singular.get_quadrature_points();
 
                 wind.vector_value_list(singular_q_points, singular_cell_wind);
 
@@ -957,8 +957,8 @@ namespace Step34
       {
         fe_v.reinit(cell);
 
-        const std::vector<Point<dim> > &q_points = fe_v.get_quadrature_points();
-        const std::vector<Point<dim> > &normals = fe_v.get_normal_vectors();
+        const std::vector<Point<dim> >    &q_points = fe_v.get_quadrature_points();
+        const std::vector<Tensor<1,dim> > &normals  = fe_v.get_all_normal_vectors();
 
         cell->get_dof_indices(dofs);
         fe_v.get_function_values(phi, local_phi);
index 8826af2918e9950d47d12debc44b04e5d18bcd6a..eda88d2dce1aa606e98358b7e97fd459bfcd5b99 100644 (file)
@@ -810,7 +810,7 @@ namespace Step51
             const double JxW = scratch.fe_face_values.JxW(q);
             const Point<dim> quadrature_point =
               scratch.fe_face_values.quadrature_point(q);
-            const Point<dim> normal = scratch.fe_face_values.normal_vector(q);
+            const Tensor<1,dim> normal = scratch.fe_face_values.normal_vector(q);
             const Tensor<1,dim> convection
               = scratch.convection_velocity.value(quadrature_point);
 
index e9a7f56d90db184ca67b175f046871e4b2ba9ac3..4c40e6dd105e5b3c4df0168b6dc26f23197b0044 100644 (file)
@@ -411,14 +411,12 @@ namespace internal
       std::vector<Point<spacedim> >  quadrature_points;
 
       /**
-       * List of outward normal vectors at the quadrature points. This field is
-       * filled in by the finite element class.
+       * List of outward normal vectors at the quadrature points.
        */
-      std::vector<Point<spacedim> >  normal_vectors;
+      std::vector<Tensor<1,spacedim> >  normal_vectors;
 
       /**
-       * List of boundary forms at the quadrature points. This field is filled in
-       * by the finite element class.
+       * List of boundary forms at the quadrature points.
        */
       std::vector<Tensor<1,spacedim> >  boundary_forms;
     };
index d49fa367630592e9172f38d3ec0cf262b93f2e15..c73190e91401f14f2ce49942b8a4654dfb649e51 100644 (file)
@@ -2078,14 +2078,16 @@ public:
    * For a face, return the outward normal vector to the cell at the
    * <tt>i</tt>th quadrature point.
    *
-   * For a cell of codimension one, return the normal vector, as it is
-   * specified by the numbering of the vertices.
+   * For a cell of codimension one, return the normal vector. There
+   * are of course two normal directions to a manifold in that case,
+   * and this function returns the "up" direction as induced by the
+   * numbering of the vertices.
    *
    * The length of the vector is normalized to one.
    *
    * @dealiiRequiresUpdateFlags{update_normal_vectors}
    */
-  const Point<spacedim> &normal_vector (const unsigned int i) const;
+  const Tensor<1,spacedim> &normal_vector (const unsigned int i) const;
 
   /**
    * Return the normal vectors at the quadrature points. For a face, these are
@@ -2093,8 +2095,28 @@ public:
    * the orientation is given by the numbering of vertices.
    *
    * @dealiiRequiresUpdateFlags{update_normal_vectors}
+   *
+   * @note This function should really be named get_normal_vectors(),
+   *   but this function already exists with a different return type
+   *   that returns a vector of Point objects, rather than a vector of
+   *   Tensor objects. This is a historical accident, but can not
+   *   be fixed in a backward compatible style. That said, the
+   *   get_normal_vectors() function is now deprecated, will be removed
+   *   in the next version, and the current function will then be renamed.
    */
-  const std::vector<Point<spacedim> > &get_normal_vectors () const;
+  const std::vector<Tensor<1,spacedim> > &get_all_normal_vectors () const;
+
+  /**
+   * Return the normal vectors at the quadrature points as a vector of
+   * Point objects. This function is deprecated because normal vectors
+   * are correctly represented by rank-1 Tensor objects, not Point objects.
+   * Use get_all_normal_vectors() instead.
+   *
+   * @dealiiRequiresUpdateFlags{update_normal_vectors}
+   *
+   * @deprecated
+   */
+  std::vector<Point<spacedim> > get_normal_vectors () const DEAL_II_DEPRECATED;
 
   /**
    * Transform a set of vectors, one for each quadrature point. The
@@ -3989,7 +4011,7 @@ FEValuesBase<dim,spacedim>::inverse_jacobian (const unsigned int i) const
 
 template <int dim, int spacedim>
 inline
-const Point<spacedim> &
+const Tensor<1,spacedim> &
 FEValuesBase<dim,spacedim>::normal_vector (const unsigned int i) const
 {
   typedef FEValuesBase<dim,spacedim> FVB;
index 01424fee7998d0349cd4d088906a3d26911f26fb..f830b9e001bf91e334d56cac19972bbd370b68df 100644 (file)
@@ -246,7 +246,7 @@ private:
                      const CellSimilarity::Similarity cell_similarity,
                      const InternalData &data,
                      std::vector<Point<dim> > &quadrature_points,
-                     std::vector<Point<dim> > &normal_vectors) const;
+                     std::vector<Tensor<1,dim> > &normal_vectors) const;
 
   /**
    * Value to indicate that a given face or subface number is invalid.
index 40007170a266b3655f7b239c4bbe927bbedc6988..db3ce2d2008d2ab3d611efd5cfb3d9a11ac40e7c 100644 (file)
@@ -127,7 +127,7 @@ namespace LocalIntegrators
       for (unsigned int k=0; k<fe.n_quadrature_points; ++k)
         {
           const double dx = factor * fe.JxW(k);
-          const Point<dim> &n = fe.normal_vector(k);
+          const Tensor<1,dim> n = fe.normal_vector(k);
           for (unsigned int i=0; i<n_dofs; ++i)
             for (unsigned int j=0; j<n_dofs; ++j)
               for (unsigned int d1=0; d1<dim; ++d1)
@@ -138,13 +138,13 @@ namespace LocalIntegrators
                   for (unsigned int d2=0; d2<dim; ++d2)
                     {
                       // v . nabla u n
-                      M(i,j) -= .5*dx* fe.shape_grad_component(j,k,d1)[d2] *n(d2)* v;
+                      M(i,j) -= .5*dx* fe.shape_grad_component(j,k,d1)[d2] *n[d2]* v;
                       // v (nabla u)^T n
-                      M(i,j) -= .5*dx* fe.shape_grad_component(j,k,d2)[d1] *n(d2)* v;
+                      M(i,j) -= .5*dx* fe.shape_grad_component(j,k,d2)[d1] *n[d2]* v;
                       // u  nabla v n
-                      M(i,j) -= .5*dx* fe.shape_grad_component(i,k,d1)[d2] *n(d2)* u;
+                      M(i,j) -= .5*dx* fe.shape_grad_component(i,k,d1)[d2] *n[d2]* u;
                       // u (nabla v)^T n
-                      M(i,j) -= .5*dx* fe.shape_grad_component(i,k,d2)[d1] *n(d2)* u;
+                      M(i,j) -= .5*dx* fe.shape_grad_component(i,k,d2)[d1] *n[d2]* u;
                     }
                 }
         }
@@ -184,7 +184,7 @@ namespace LocalIntegrators
       for (unsigned int k=0; k<fe.n_quadrature_points; ++k)
         {
           const double dx = factor * fe.JxW(k);
-          const Point<dim> &n = fe.normal_vector(k);
+          const Tensor<1,dim> n = fe.normal_vector(k);
           for (unsigned int i=0; i<n_dofs; ++i)
             for (unsigned int d1=0; d1<dim; ++d1)
               {
@@ -196,13 +196,13 @@ namespace LocalIntegrators
                 for (unsigned int d2=0; d2<dim; ++d2)
                   {
                     // v . nabla u n
-                    result(i) -= .5*dx* v * Dinput[d1][k][d2] * n(d2);
+                    result(i) -= .5*dx* v * Dinput[d1][k][d2] * n[d2];
                     // v . (nabla u)^T n
-                    result(i) -= .5*dx* v * Dinput[d2][k][d1] * n(d2);
+                    result(i) -= .5*dx* v * Dinput[d2][k][d1] * n[d2];
                     // u  nabla v n
-                    result(i) -= .5*dx * (u-g) * fe.shape_grad_component(i,k,d1)[d2] * n(d2);
+                    result(i) -= .5*dx * (u-g) * fe.shape_grad_component(i,k,d1)[d2] * n[d2];
                     // u  (nabla v)^T n
-                    result(i) -= .5*dx * (u-g) * fe.shape_grad_component(i,k,d2)[d1] * n(d2);
+                    result(i) -= .5*dx * (u-g) * fe.shape_grad_component(i,k,d2)[d1] * n[d2];
                   }
               }
         }
@@ -239,7 +239,7 @@ namespace LocalIntegrators
       for (unsigned int k=0; k<fe.n_quadrature_points; ++k)
         {
           const double dx = factor * fe.JxW(k);
-          const Point<dim> &n = fe.normal_vector(k);
+          const Tensor<1,dim> n = fe.normal_vector(k);
           for (unsigned int i=0; i<n_dofs; ++i)
             for (unsigned int d1=0; d1<dim; ++d1)
               {
@@ -250,13 +250,13 @@ namespace LocalIntegrators
                 for (unsigned int d2=0; d2<dim; ++d2)
                   {
                     // v . nabla u n
-                    result(i) -= .5*dx* v * Dinput[d1][k][d2] * n(d2);
+                    result(i) -= .5*dx* v * Dinput[d1][k][d2] * n[d2];
                     // v . (nabla u)^T n
-                    result(i) -= .5*dx* v * Dinput[d2][k][d1] * n(d2);
+                    result(i) -= .5*dx* v * Dinput[d2][k][d1] * n[d2];
                     // u  nabla v n
-                    result(i) -= .5*dx * u * fe.shape_grad_component(i,k,d1)[d2] * n(d2);
+                    result(i) -= .5*dx * u * fe.shape_grad_component(i,k,d1)[d2] * n[d2];
                     // u  (nabla v)^T n
-                    result(i) -= .5*dx * u * fe.shape_grad_component(i,k,d2)[d1] * n(d2);
+                    result(i) -= .5*dx * u * fe.shape_grad_component(i,k,d2)[d1] * n[d2];
                   }
               }
         }
@@ -297,7 +297,7 @@ namespace LocalIntegrators
       for (unsigned int k=0; k<fe1.n_quadrature_points; ++k)
         {
           const double dx = fe1.JxW(k);
-          const Point<dim> &n = fe1.normal_vector(k);
+          const Tensor<1,dim> n = fe1.normal_vector(k);
           for (unsigned int i=0; i<n_dofs; ++i)
             for (unsigned int j=0; j<n_dofs; ++j)
               for (unsigned int d1=0; d1<dim; ++d1)
@@ -315,25 +315,25 @@ namespace LocalIntegrators
                   for (unsigned int d2=0; d2<dim; ++d2)
                     {
                       // v . nabla u n
-                      M11(i,j) -= .25 * dx * nu1 * fe1.shape_grad_component(j,k,d1)[d2] * n(d2) * v1;
-                      M12(i,j) -= .25 * dx * nu2 * fe2.shape_grad_component(j,k,d1)[d2] * n(d2) * v1;
-                      M21(i,j) += .25 * dx * nu1 * fe1.shape_grad_component(j,k,d1)[d2] * n(d2) * v2;
-                      M22(i,j) += .25 * dx * nu2 * fe2.shape_grad_component(j,k,d1)[d2] * n(d2) * v2;
+                      M11(i,j) -= .25 * dx * nu1 * fe1.shape_grad_component(j,k,d1)[d2] * n[d2] * v1;
+                      M12(i,j) -= .25 * dx * nu2 * fe2.shape_grad_component(j,k,d1)[d2] * n[d2] * v1;
+                      M21(i,j) += .25 * dx * nu1 * fe1.shape_grad_component(j,k,d1)[d2] * n[d2] * v2;
+                      M22(i,j) += .25 * dx * nu2 * fe2.shape_grad_component(j,k,d1)[d2] * n[d2] * v2;
                       // v (nabla u)^T n
-                      M11(i,j) -= .25 * dx * nu1 * fe1.shape_grad_component(j,k,d2)[d1] * n(d2) * v1;
-                      M12(i,j) -= .25 * dx * nu2 * fe2.shape_grad_component(j,k,d2)[d1] * n(d2) * v1;
-                      M21(i,j) += .25 * dx * nu1 * fe1.shape_grad_component(j,k,d2)[d1] * n(d2) * v2;
-                      M22(i,j) += .25 * dx * nu2 * fe2.shape_grad_component(j,k,d2)[d1] * n(d2) * v2;
+                      M11(i,j) -= .25 * dx * nu1 * fe1.shape_grad_component(j,k,d2)[d1] * n[d2] * v1;
+                      M12(i,j) -= .25 * dx * nu2 * fe2.shape_grad_component(j,k,d2)[d1] * n[d2] * v1;
+                      M21(i,j) += .25 * dx * nu1 * fe1.shape_grad_component(j,k,d2)[d1] * n[d2] * v2;
+                      M22(i,j) += .25 * dx * nu2 * fe2.shape_grad_component(j,k,d2)[d1] * n[d2] * v2;
                       // u  nabla v n
-                      M11(i,j) -= .25 * dx * nu1 * fe1.shape_grad_component(i,k,d1)[d2] * n(d2) * u1;
-                      M12(i,j) += .25 * dx * nu1 * fe1.shape_grad_component(i,k,d1)[d2] * n(d2) * u2;
-                      M21(i,j) -= .25 * dx * nu2 * fe2.shape_grad_component(i,k,d1)[d2] * n(d2) * u1;
-                      M22(i,j) += .25 * dx * nu2 * fe2.shape_grad_component(i,k,d1)[d2] * n(d2) * u2;
+                      M11(i,j) -= .25 * dx * nu1 * fe1.shape_grad_component(i,k,d1)[d2] * n[d2] * u1;
+                      M12(i,j) += .25 * dx * nu1 * fe1.shape_grad_component(i,k,d1)[d2] * n[d2] * u2;
+                      M21(i,j) -= .25 * dx * nu2 * fe2.shape_grad_component(i,k,d1)[d2] * n[d2] * u1;
+                      M22(i,j) += .25 * dx * nu2 * fe2.shape_grad_component(i,k,d1)[d2] * n[d2] * u2;
                       // u (nabla v)^T n
-                      M11(i,j) -= .25 * dx * nu1 * fe1.shape_grad_component(i,k,d2)[d1] * n(d2) * u1;
-                      M12(i,j) += .25 * dx * nu1 * fe1.shape_grad_component(i,k,d2)[d1] * n(d2) * u2;
-                      M21(i,j) -= .25 * dx * nu2 * fe2.shape_grad_component(i,k,d2)[d1] * n(d2) * u1;
-                      M22(i,j) += .25 * dx * nu2 * fe2.shape_grad_component(i,k,d2)[d1] * n(d2) * u2;
+                      M11(i,j) -= .25 * dx * nu1 * fe1.shape_grad_component(i,k,d2)[d1] * n[d2] * u1;
+                      M12(i,j) += .25 * dx * nu1 * fe1.shape_grad_component(i,k,d2)[d1] * n[d2] * u2;
+                      M21(i,j) -= .25 * dx * nu2 * fe2.shape_grad_component(i,k,d2)[d1] * n[d2] * u1;
+                      M22(i,j) += .25 * dx * nu2 * fe2.shape_grad_component(i,k,d2)[d1] * n[d2] * u2;
                     }
                 }
         }
@@ -376,7 +376,7 @@ namespace LocalIntegrators
       for (unsigned int k=0; k<fe1.n_quadrature_points; ++k)
         {
           const double dx = fe1.JxW(k);
-          const Point<dim> &n = fe1.normal_vector(k);
+          const Tensor<1,dim> n = fe1.normal_vector(k);
 
           for (unsigned int i=0; i<n1; ++i)
             for (unsigned int d1=0; d1<dim; ++d1)
@@ -394,17 +394,17 @@ namespace LocalIntegrators
                 for (unsigned int d2=0; d2<dim; ++d2)
                   {
                     // v . nabla u n
-                    result1(i) -= .25*dx* (nu1*Dinput1[d1][k][d2]+nu2*Dinput2[d1][k][d2]) * n(d2) * v1;
-                    result2(i) += .25*dx* (nu1*Dinput1[d1][k][d2]+nu2*Dinput2[d1][k][d2]) * n(d2) * v2;
+                    result1(i) -= .25*dx* (nu1*Dinput1[d1][k][d2]+nu2*Dinput2[d1][k][d2]) * n[d2] * v1;
+                    result2(i) += .25*dx* (nu1*Dinput1[d1][k][d2]+nu2*Dinput2[d1][k][d2]) * n[d2] * v2;
                     // v . (nabla u)^T n
-                    result1(i) -= .25*dx* (nu1*Dinput1[d2][k][d1]+nu2*Dinput2[d2][k][d1]) * n(d2) * v1;
-                    result2(i) += .25*dx* (nu1*Dinput1[d2][k][d1]+nu2*Dinput2[d2][k][d1]) * n(d2) * v2;
+                    result1(i) -= .25*dx* (nu1*Dinput1[d2][k][d1]+nu2*Dinput2[d2][k][d1]) * n[d2] * v1;
+                    result2(i) += .25*dx* (nu1*Dinput1[d2][k][d1]+nu2*Dinput2[d2][k][d1]) * n[d2] * v2;
                     // u  nabla v n
-                    result1(i) -= .25*dx* nu1*fe1.shape_grad_component(i,k,d1)[d2] * n(d2) * (u1-u2);
-                    result2(i) -= .25*dx* nu2*fe2.shape_grad_component(i,k,d1)[d2] * n(d2) * (u1-u2);
+                    result1(i) -= .25*dx* nu1*fe1.shape_grad_component(i,k,d1)[d2] * n[d2] * (u1-u2);
+                    result2(i) -= .25*dx* nu2*fe2.shape_grad_component(i,k,d1)[d2] * n[d2] * (u1-u2);
                     // u  (nabla v)^T n
-                    result1(i) -= .25*dx* nu1*fe1.shape_grad_component(i,k,d2)[d1] * n(d2) * (u1-u2);
-                    result2(i) -= .25*dx* nu2*fe2.shape_grad_component(i,k,d2)[d1] * n(d2) * (u1-u2);
+                    result1(i) -= .25*dx* nu1*fe1.shape_grad_component(i,k,d2)[d1] * n[d2] * (u1-u2);
+                    result2(i) -= .25*dx* nu2*fe2.shape_grad_component(i,k,d2)[d1] * n[d2] * (u1-u2);
                   }
               }
         }
index ee279fc59dab919af441320338d378604596ef02..7379965b13b5030c2eb806738d705cbbfcf4f161 100644 (file)
@@ -173,7 +173,7 @@ namespace LocalIntegrators
       for (unsigned int k=0; k<fe.n_quadrature_points; ++k)
         {
           const double dx = fe.JxW(k) * factor;
-          const Point<dim> &n = fe.normal_vector(k);
+          const Tensor<1,dim> n = fe.normal_vector(k);
           for (unsigned int i=0; i<n_dofs; ++i)
             for (unsigned int j=0; j<n_dofs; ++j)
               for (unsigned int d=0; d<n_comp; ++d)
@@ -217,7 +217,7 @@ namespace LocalIntegrators
       for (unsigned int k=0; k<fe.n_quadrature_points; ++k)
         {
           const double dx = factor * fe.JxW(k);
-          const Point<dim> &n = fe.normal_vector(k);
+          const Tensor<1,dim> n = fe.normal_vector(k);
           for (unsigned int i=0; i<n_dofs; ++i)
             {
               const double dnv = fe.shape_grad(i,k) * n;
@@ -267,7 +267,7 @@ namespace LocalIntegrators
       for (unsigned int k=0; k<fe.n_quadrature_points; ++k)
         {
           const double dx = factor * fe.JxW(k);
-          const Point<dim> &n = fe.normal_vector(k);
+          const Tensor<1,dim> n = fe.normal_vector(k);
           for (unsigned int i=0; i<n_dofs; ++i)
             for (unsigned int d=0; d<n_comp; ++d)
               {
@@ -330,7 +330,7 @@ namespace LocalIntegrators
       for (unsigned int k=0; k<fe1.n_quadrature_points; ++k)
         {
           const double dx = fe1.JxW(k);
-          const Point<dim> &n = fe1.normal_vector(k);
+          const Tensor<1,dim> n = fe1.normal_vector(k);
           for (unsigned int d=0; d<fe1.get_fe().n_components(); ++d)
             {
               for (unsigned int i=0; i<n_dofs; ++i)
@@ -400,7 +400,7 @@ namespace LocalIntegrators
       for (unsigned int k=0; k<fe1.n_quadrature_points; ++k)
         {
           const double dx = fe1.JxW(k);
-          const Point<dim> &n = fe1.normal_vector(k);
+          const Tensor<1,dim> n = fe1.normal_vector(k);
           for (unsigned int i=0; i<n_dofs; ++i)
             {
               for (unsigned int j=0; j<n_dofs; ++j)
@@ -417,30 +417,30 @@ namespace LocalIntegrators
 
                   for (unsigned int d=0; d<dim; ++d)
                     {
-                      u1dotn += n(d)*fe1.shape_value_component(j,k,d);
-                      v1dotn += n(d)*fe1.shape_value_component(i,k,d);
-                      u2dotn += n(d)*fe2.shape_value_component(j,k,d);
-                      v2dotn += n(d)*fe2.shape_value_component(i,k,d);
-
-                      ngradu1n += n*fe1.shape_grad_component(j,k,d)*n(d);
-                      ngradv1n += n*fe1.shape_grad_component(i,k,d)*n(d);
-                      ngradu2n += n*fe2.shape_grad_component(j,k,d)*n(d);
-                      ngradv2n += n*fe2.shape_grad_component(i,k,d)*n(d);
+                      u1dotn += n[d]*fe1.shape_value_component(j,k,d);
+                      v1dotn += n[d]*fe1.shape_value_component(i,k,d);
+                      u2dotn += n[d]*fe2.shape_value_component(j,k,d);
+                      v2dotn += n[d]*fe2.shape_value_component(i,k,d);
+
+                      ngradu1n += n*fe1.shape_grad_component(j,k,d)*n[d];
+                      ngradv1n += n*fe1.shape_grad_component(i,k,d)*n[d];
+                      ngradu2n += n*fe2.shape_grad_component(j,k,d)*n[d];
+                      ngradv2n += n*fe2.shape_grad_component(i,k,d)*n[d];
                     }
 
                   for (unsigned int d=0; d<fe1.get_fe().n_components(); ++d)
                     {
-                      const double vi = fe1.shape_value_component(i,k,d)-v1dotn*n(d);
-                      const double dnvi = n * fe1.shape_grad_component(i,k,d)-ngradv1n*n(d);
+                      const double vi = fe1.shape_value_component(i,k,d)-v1dotn*n[d];
+                      const double dnvi = n * fe1.shape_grad_component(i,k,d)-ngradv1n*n[d];
 
-                      const double ve = fe2.shape_value_component(i,k,d)-v2dotn*n(d);
-                      const double dnve = n * fe2.shape_grad_component(i,k,d)-ngradv2n*n(d);
+                      const double ve = fe2.shape_value_component(i,k,d)-v2dotn*n[d];
+                      const double dnve = n * fe2.shape_grad_component(i,k,d)-ngradv2n*n[d];
 
-                      const double ui = fe1.shape_value_component(j,k,d)-u1dotn*n(d);
-                      const double dnui = n * fe1.shape_grad_component(j,k,d)-ngradu1n*n(d);
+                      const double ui = fe1.shape_value_component(j,k,d)-u1dotn*n[d];
+                      const double dnui = n * fe1.shape_grad_component(j,k,d)-ngradu1n*n[d];
 
-                      const double ue = fe2.shape_value_component(j,k,d)-u2dotn*n(d);
-                      const double dnue = n * fe2.shape_grad_component(j,k,d)-ngradu2n*n(d);
+                      const double ue = fe2.shape_value_component(j,k,d)-u2dotn*n[d];
+                      const double dnue = n * fe2.shape_grad_component(j,k,d)-ngradu2n*n[d];
 
                       M11(i,j) += dx*(-.5*nui*dnvi*ui-.5*nui*dnui*vi+nu*penalty*ui*vi);
                       M12(i,j) += dx*( .5*nui*dnvi*ue-.5*nue*dnue*vi-nu*penalty*vi*ue);
@@ -491,7 +491,7 @@ namespace LocalIntegrators
       for (unsigned int k=0; k<fe1.n_quadrature_points; ++k)
         {
           const double dx = fe1.JxW(k);
-          const Point<dim> &n = fe1.normal_vector(k);
+          const Tensor<1,dim> n = fe1.normal_vector(k);
 
           for (unsigned int i=0; i<n_dofs; ++i)
             {
@@ -560,7 +560,7 @@ namespace LocalIntegrators
       for (unsigned int k=0; k<fe1.n_quadrature_points; ++k)
         {
           const double dx = fe1.JxW(k);
-          const Point<dim> &n = fe1.normal_vector(k);
+          const Tensor<1,dim> n = fe1.normal_vector(k);
 
           for (unsigned int i=0; i<n1; ++i)
             for (unsigned int d=0; d<n_comp; ++d)
index a4f8d667138320dacaa9ccf510b92de59dc5aa94..64432a9ee8a065acc3bafa7be2e15647c8020096 100644 (file)
@@ -296,7 +296,7 @@ namespace LocalIntegrators
       for (unsigned int k=0; k<fe.n_quadrature_points; ++k)
         {
           const double dx = factor * fe.JxW(k);
-          const Point<dim> &n = fe.normal_vector(k);
+          const Tensor<1,dim> n = fe.normal_vector(k);
           for (unsigned int i=0; i<n_dofs; ++i)
             for (unsigned int j=0; j<n_dofs; ++j)
               for (unsigned int d=0; d<d_max; ++d)
@@ -350,7 +350,7 @@ namespace LocalIntegrators
       for (unsigned int k=0; k<fe.n_quadrature_points; ++k)
         {
           const double dx = factor * fe.JxW(k);
-          const Point<dim> &n = fe.normal_vector(k);
+          const Tensor<1,dim> n = fe.normal_vector(k);
           for (unsigned int i=0; i<n_dofs; ++i)
             for (unsigned int j=0; j<n_dofs; ++j)
               for (unsigned int d=0; d<d_max; ++d)
@@ -425,7 +425,7 @@ namespace LocalIntegrators
       for (unsigned int k=0; k<fe1.n_quadrature_points; ++k)
         {
           const double dx = fe1.JxW(k);
-          const Point<dim> &n = fe1.normal_vector(k);
+          const Tensor<1,dim> n = fe1.normal_vector(k);
           for (unsigned int i=0; i<n_dofs; ++i)
             for (unsigned int j=0; j<n_dofs; ++j)
               for (unsigned int d=0; d<d_max; ++d)
index 12b187c14d588f321027bb19a4ac02859281e0b0..099d8c0aa0764ae621b6d6c5191ecdb7b3427b35 100644 (file)
@@ -123,7 +123,7 @@ namespace internal
       get_quadrature_points() const;
 
       /**
-       * Return a vector of quadrature points in real space on the given cell.
+       * Return a vector of normal vectors in real space on the given cell.
        * For compatibility with FEEvaluation, it returns tensors of vectorized
        * arrays, even though all components are equal.
        */
index 9ce69f5c9d2678612eb85029cd49edfee7ebbffa..e5821a98d0f2662b33b6232fcea120765b16eeb1 100644 (file)
@@ -4209,7 +4209,7 @@ namespace VectorTools
               // This avoids possible issues with the computation of the tangent.
 
               // Store the normal at this quad point:
-              Point<dim> normal_at_q_point = fe_face_values.normal_vector(q_point);
+              Tensor<1,dim> normal_at_q_point = fe_face_values.normal_vector(q_point);
               for (unsigned int j = 0; j < associated_edge_dofs; ++j)
                 {
                   const unsigned int j_face_idx = associated_edge_dof_to_face_dof[j];
@@ -4226,15 +4226,15 @@ namespace VectorTools
                       // Using n cross phi
                       edge_matrix(i,j)
                       += fe_face_values.JxW (q_point)
-                         * ((phi_i[1]*normal_at_q_point(0) - phi_i[0]*normal_at_q_point(1))
-                            * (phi_j[1]*normal_at_q_point(0) - phi_j[0]*normal_at_q_point(1)));
+                         * ((phi_i[1]*normal_at_q_point[0] - phi_i[0]*normal_at_q_point[1])
+                            * (phi_j[1]*normal_at_q_point[0] - phi_j[0]*normal_at_q_point[1]));
                     }
                   // Using n cross phi
                   edge_rhs(j)
                   += fe_face_values.JxW (q_point)
-                     * ((values[q_point] (first_vector_component+1) * normal_at_q_point (0)
-                         - values[q_point] (first_vector_component) * normal_at_q_point (1))
-                        * (phi_j[1]*normal_at_q_point(0) - phi_j[0]*normal_at_q_point(1)));
+                     * ((values[q_point] (first_vector_component+1) * normal_at_q_point[0]
+                         - values[q_point] (first_vector_component) * normal_at_q_point[1])
+                        * (phi_j[1]*normal_at_q_point[0] - phi_j[0]*normal_at_q_point[1]));
                 }
             }
 
@@ -4343,14 +4343,10 @@ namespace VectorTools
           // associated with this face. We also must include the residuals from the
           // shape funcations associated with edges.
           Tensor<1, dim> tmp;
-          Tensor<1, dim> normal_vector,
-                 cross_product_i,
+          Tensor<1, dim> cross_product_i,
                  cross_product_j,
                  cross_product_rhs;
 
-          // Store all normal vectors at quad points:
-          std::vector<Point<dim> > normal_vector_list(fe_face_values.get_normal_vectors());
-
           // Loop to construct face linear system.
           for (unsigned int q_point = 0;
                q_point < fe_face_values.n_quadrature_points; ++q_point)
@@ -4383,10 +4379,8 @@ namespace VectorTools
                 }
 
               // Tensor of normal vector on the face at q_point;
-              for (unsigned int d = 0; d < dim; ++d)
-                {
-                  normal_vector[d] = normal_vector_list[q_point](d);
-                }
+              const Tensor<1,dim> normal_vector = fe_face_values.normal_vector(q_point);
+
               // Now compute the linear system:
               // On a face:
               // The matrix entries are:
@@ -4756,7 +4750,7 @@ namespace VectorTools
       // functions supported on the boundary.
       const FEValuesExtractors::Vector vec (first_vector_component);
       const FiniteElement<2> &fe = cell->get_fe ();
-      const std::vector<Point<2> > &normals = fe_values.get_normal_vectors ();
+      const std::vector<Tensor<1,2> > &normals = fe_values.get_all_normal_vectors ();
       const unsigned int
       face_coordinate_direction[GeometryInfo<2>::faces_per_cell] = {1, 1, 0, 0};
       std::vector<Vector<double> >
@@ -4837,7 +4831,7 @@ namespace VectorTools
       // functions supported on the boundary.
       const FEValuesExtractors::Vector vec (first_vector_component);
       const FiniteElement<3> &fe = cell->get_fe ();
-      const std::vector<Point<3> > &normals = fe_values.get_normal_vectors ();
+      const std::vector<Tensor<1,3> > &normals = fe_values.get_all_normal_vectors ();
       const unsigned int
       face_coordinate_directions[GeometryInfo<3>::faces_per_cell][2] = {{1, 2},
         {1, 2},
@@ -5410,7 +5404,7 @@ namespace VectorTools
                       = (cell->face(face_no)->get_boundary().normal_vector
                          (cell->face(face_no),
                           fe_values.quadrature_point(i)));
-                    if (normal_vector * static_cast<Tensor<1,dim> >(fe_values.normal_vector(i)) < 0)
+                    if (normal_vector * fe_values.normal_vector(i) < 0)
                       normal_vector *= -1;
                     Assert (std::fabs(normal_vector.norm() - 1) < 1e-14,
                             ExcInternalError());
@@ -6211,9 +6205,8 @@ namespace VectorTools
                 {
                   // compute (f.n) n
                   const Number f_dot_n
-                    = (data.psi_grads[q][k] * Tensor<1,spacedim,Number>(fe_values.normal_vector(q)));
-                  const Tensor<1,spacedim,Number> f_dot_n_times_n
-                    = f_dot_n * Tensor<1,spacedim,Number>(fe_values.normal_vector(q));
+                    = (data.psi_grads[q][k] * fe_values.normal_vector(q));
+                  const Tensor<1,spacedim,Number> f_dot_n_times_n (f_dot_n * fe_values.normal_vector(q));
 
                   data.psi_grads[q][k] -= (data.function_grads[q][k] + f_dot_n_times_n);
                 }
index bb75e3bc5535e266fc4930f6bb736120953482de..7003914a6d4b7b39bc02493396c56417c592815e 100644 (file)
@@ -3148,8 +3148,8 @@ FEValuesBase<dim,spacedim>::get_cell () const
 
 
 template <int dim, int spacedim>
-const std::vector<Point<spacedim> > &
-FEValuesBase<dim,spacedim>::get_normal_vectors () const
+const std::vector<Tensor<1,spacedim> > &
+FEValuesBase<dim,spacedim>::get_all_normal_vectors () const
 {
   typedef FEValuesBase<dim,spacedim> FEVB;
   Assert (this->update_flags & update_normal_vectors,
@@ -3159,6 +3159,24 @@ FEValuesBase<dim,spacedim>::get_normal_vectors () const
 
 
 
+template <int dim, int spacedim>
+std::vector<Point<spacedim> >
+FEValuesBase<dim,spacedim>::get_normal_vectors () const
+{
+  typedef FEValuesBase<dim,spacedim> FEVB;
+  Assert (this->update_flags & update_normal_vectors,
+          typename FEVB::ExcAccessToUninitializedField("update_normal_vectors"));
+
+  // copy things into a vector of Points, then return that
+  std::vector<Point<spacedim> > tmp (this->normal_vectors.size());
+  for (unsigned int q=0; q<this->normal_vectors.size(); ++q)
+    tmp[q] = Point<spacedim>(this->normal_vectors[q]);
+
+  return tmp;
+}
+
+
+
 template <int dim, int spacedim>
 void
 FEValuesBase<dim,spacedim>::transform (
index 6b192da404673745604deec858795d68ba7c1f04..9a366a9c846cc0da4ef4723d8544e323fd1aa798 100644 (file)
@@ -154,7 +154,7 @@ MappingCartesian<dim, spacedim>::compute_fill (const typename Triangulation<dim,
                                                const CellSimilarity::Similarity cell_similarity,
                                                const InternalData             &data,
                                                std::vector<Point<dim> > &quadrature_points,
-                                               std::vector<Point<dim> > &normal_vectors) const
+                                               std::vector<Tensor<1,dim> > &normal_vectors) const
 {
   const UpdateFlags update_flags = data.update_each;
 
@@ -346,7 +346,7 @@ fill_fe_values (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
   Assert (dynamic_cast<const InternalData *> (&internal_data) != 0, ExcInternalError());
   const InternalData &data = static_cast<const InternalData &> (internal_data);
 
-  std::vector<Point<dim> > dummy;
+  std::vector<Tensor<1,dim> > dummy;
 
   compute_fill (cell, invalid_face_number, invalid_face_number, cell_similarity,
                 data,
index 0768241e7c3adc427b36486f1a9bf5d8ce45fc41..c67af1892bacebf039ddf8a4814220e7f1b1fe7e 100644 (file)
@@ -153,7 +153,12 @@ build_one_patch (const FaceDescriptor *cell_and_face,
               // thus does not depend on the number of components of the data
               // vector
               if (update_flags & update_normal_vectors)
-                data.patch_normals=this_fe_patch_values.get_normal_vectors();
+                {
+//TODO: undo this copying when we can change the data type of
+//  data.patch_normals to Tensor<1,spacedim> as well
+                  for (unsigned int q=0; q<this_fe_patch_values.n_quadrature_points; ++q)
+                    data.patch_normals[q] = Point<dim>(this_fe_patch_values.get_all_normal_vectors()[q]);
+                }
 
               if (n_components == 1)
                 {
index 6278501fe56423128a9bdac938f425b176226700..93383b29cda9cdd22fd91349e21ab3ec33e3326c 100644 (file)
@@ -149,7 +149,7 @@ namespace internal
       /**
        * The normal vectors of the finite element function on one face
        */
-      std::vector<Point<spacedim> > normal_vectors;
+      std::vector<Tensor<1,spacedim> > normal_vectors;
 
       /**
        * Two arrays needed for the values of coefficients in the jumps, if
@@ -364,7 +364,7 @@ namespace internal
       // change the sign. We take the outward normal.
 
       parallel_data.normal_vectors =
-        fe_face_values_cell.get_present_fe_values().get_normal_vectors();
+        fe_face_values_cell.get_present_fe_values().get_all_normal_vectors();
 
       for (unsigned int n=0; n<n_solution_vectors; ++n)
         for (unsigned int component=0; component<n_components; ++component)
index be161e6770baaaff440876eab1d5fc5f9431ce3b..2e46d1581f06e59bc287a2488d6bd5361c32ff5f 100644 (file)
@@ -986,8 +986,8 @@ namespace MatrixCreator
                     if (!base.conforms(FiniteElementData<dim>::H1) &&
                         base.conforms(FiniteElementData<dim>::Hdiv))
                       for (unsigned int point=0; point<fe_values.n_quadrature_points; ++point)
-                        normal_adjustment[point][comp] = fe_values.normal_vector(point)(bcomp)
-                                                         * fe_values.normal_vector(point)(bcomp);
+                        normal_adjustment[point][comp] = fe_values.normal_vector(point)[bcomp]
+                                                         * fe_values.normal_vector(point)[bcomp];
                   }
 
                 for (unsigned int point=0; point<fe_values.n_quadrature_points; ++point)
index 2bb04e40c05dc19bf63081f09f07ed11b21b0f65..53098ef859e199dca8c6bedc12164fbf7ae699fa 100644 (file)
@@ -85,7 +85,7 @@ void check_this (Triangulation<3> &tria)
                                        fe_face_values2.JxW(q)) < 1e-14,
                              ExcInternalError());
                 AssertThrow ((fe_face_values1.normal_vector(q) +
-                              fe_face_values2.normal_vector(q)).square()
+                              fe_face_values2.normal_vector(q)).norm_square()
                              < 1e-20,
                              ExcInternalError());
               }
index f095367ee782d158559ebe9d7f1567b052ae8ce5..235930421c49f749647cb0b02367d95dd79ea777 100644 (file)
@@ -107,9 +107,9 @@ void evaluate_normal (DoFHandler<2>  &dof_handler,
 
               for (unsigned int q_point=0; q_point<n_q_face; ++q_point)
                 {
-                  Point<2> vn = fe_v_face.normal_vector (q_point);
-                  double nx = vn(0);
-                  double ny = vn(1);
+                  Tensor<1,2> vn = fe_v_face.normal_vector (q_point);
+                  double nx = vn[0];
+                  double ny = vn[1];
 
                   double u = this_value[q_point](0);
                   double v = this_value[q_point](1);
index c7d9e4d012013ab5f36db505e42007a9681f6793..e889852c6c4e5e99c883ff22f9531ede19c0a3ef 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2005 - 2014 by the deal.II authors
+// Copyright (C) 2005 - 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -205,7 +205,7 @@ void DGTransportEquation<dim>::assemble_boundary_term(
   Vector<double> &cell_vector) const
 {
   const std::vector<double> &JxW = fe_v.get_JxW_values ();
-  const std::vector<Point<dim> > &normals = fe_v.get_normal_vectors ();
+  const std::vector<Tensor<1,dim> > &normals = fe_v.get_all_normal_vectors ();
 
   std::vector<Point<dim> > beta (fe_v.n_quadrature_points);
   std::vector<double> g(fe_v.n_quadrature_points);
@@ -241,7 +241,7 @@ void DGTransportEquation<dim>::assemble_face_term1(
   FullMatrix<double> &ue_vi_matrix) const
 {
   const std::vector<double> &JxW = fe_v.get_JxW_values ();
-  const std::vector<Point<dim> > &normals = fe_v.get_normal_vectors ();
+  const std::vector<Tensor<1,dim> > &normals = fe_v.get_all_normal_vectors ();
 
   std::vector<Point<dim> > beta (fe_v.n_quadrature_points);
   beta_function.value_list (fe_v.get_quadrature_points(), beta);
@@ -277,7 +277,7 @@ void DGTransportEquation<dim>::assemble_face_term2(
   FullMatrix<double> &ue_ve_matrix) const
 {
   const std::vector<double> &JxW = fe_v.get_JxW_values ();
-  const std::vector<Point<dim> > &normals = fe_v.get_normal_vectors ();
+  const std::vector<Tensor<1,dim> > &normals = fe_v.get_all_normal_vectors ();
 
   std::vector<Point<dim> > beta (fe_v.n_quadrature_points);
 
index 2ae285dd6581037f3486cf8bf79621d3d205bdaf..250b2152231a55fae4ac2939d5aeb8507fabb452 100644 (file)
@@ -638,7 +638,7 @@ namespace Step51
             const double JxW = scratch.fe_face_values.JxW(q);
             const Point<dim> quadrature_point =
               scratch.fe_face_values.quadrature_point(q);
-            const Point<dim> normal = scratch.fe_face_values.normal_vector(q);
+            const Tensor<1,dim> normal = scratch.fe_face_values.normal_vector(q);
             const Tensor<1,dim> convection
             = scratch.convection_velocity.value(quadrature_point);
 
index 11b39616ace720cea69a7c8b7687f5ed26001bb6..27b368443bad7bab5c30fbe41c814cd6d40e3214 100644 (file)
@@ -638,7 +638,7 @@ namespace Step51
             const double JxW = scratch.fe_face_values.JxW(q);
             const Point<dim> quadrature_point =
               scratch.fe_face_values.quadrature_point(q);
-            const Point<dim> normal = scratch.fe_face_values.normal_vector(q);
+            const Tensor<1,dim> normal = scratch.fe_face_values.normal_vector(q);
             const Tensor<1,dim> convection
             = scratch.convection_velocity.value(quadrature_point);
 
index e8e1d6b0dae798192e2885d4d0d5db0212b5c113..7b28ad6d92a2c3ee2250d800aa7929c71742596a 100644 (file)
@@ -266,7 +266,7 @@ BEM<spacedim>::assemble_system()
   FullMatrix<double>        cell_DLP_matrix (dofs_per_cell, dofs_per_cell);
   Vector<double>            cell_rhs (dofs_per_cell);
 
-  std::vector< Point<spacedim> > cell_normals_i, cell_normals_j;
+  std::vector< Tensor<1,spacedim> > cell_normals_i, cell_normals_j;
 
   std::vector<types::global_dof_index> local_dof_indices_i (dofs_per_cell);
   std::vector<types::global_dof_index> local_dof_indices_j (dofs_per_cell);
@@ -289,7 +289,7 @@ BEM<spacedim>::assemble_system()
     {
 
       fe_values_i.reinit (cell_i);
-      cell_normals_i = fe_values_i.get_normal_vectors();
+      cell_normals_i = fe_values_i.get_all_normal_vectors();
       cell_i->get_dof_indices (local_dof_indices_i);
 
 //  if (cell_i->index()%100==0)
@@ -353,7 +353,7 @@ BEM<spacedim>::assemble_system()
       for (cell_j=dof_handler.begin_active(); cell_j!=endc; ++cell_j)
         {
           fe_values_j.reinit (cell_j);
-          cell_normals_j = fe_values_j.get_normal_vectors();
+          cell_normals_j = fe_values_j.get_all_normal_vectors();
           cell_j->get_dof_indices (local_dof_indices_j);
 
           if (cell_j != cell_i)
@@ -570,7 +570,7 @@ BEM<spacedim>::solve()
                                                 update_gradients |
                                                 update_normal_vectors );
 
-  std::vector< Point<spacedim> > cell_normals(q_iterated.size());
+  std::vector< Tensor<1,spacedim> > cell_normals(q_iterated.size());
   std::vector< Point<spacedim> > cell_tangentials(q_iterated.size());
   std::vector<types::global_dof_index> local_dof_indices (fe_q.dofs_per_cell);
 
@@ -596,7 +596,7 @@ BEM<spacedim>::solve()
 //  std::cout<<std::endl;
 
 
-      cell_normals = fe_values_q.get_normal_vectors();
+      cell_normals = fe_values_q.get_all_normal_vectors();
       for (unsigned int i=0; i<q_iterated.size(); ++i)
         {
           cell_tangentials[i][0] = cell_normals[i][1];
index 9b03d82c9442c548fd45b8d71182af6c671f4512..cb3e7fd05a35a4589dc82c9ecf9f95e0a19af937 100644 (file)
@@ -76,7 +76,7 @@ private:
   double term_S(const Tensor<1,3> &r,
                 const Tensor<1,3> &a1,
                 const Tensor<1,3> &a2,
-                const Point<3> &n,
+                const Tensor<1,3> &n,
                 const double &rn_c);
 
   double term_D(const Tensor<1,3> &r,
@@ -123,9 +123,9 @@ LaplaceKernelIntegration<2>::compute_SD_integral_on_cell(vector<double> &dst,
          ExcDimensionMismatch(dst.size(), 2));
   fe_values->reinit(cell);
   vector<DerivativeForm<1,2,3> > jacobians = fe_values->get_jacobians();
-  vector<Point<3> > normals = fe_values->get_normal_vectors();
+  vector<Tensor<1,3> > normals = fe_values->get_all_normal_vectors();
 
-  Point<3> n,n_c;
+  Tensor<1,3> n,n_c;
   Tensor<1,3> r_c = point-cell->center();
   n_c = normals[4];
 
@@ -151,7 +151,7 @@ double
 LaplaceKernelIntegration<dim>::term_S (const Tensor<1,3> &r,
                                        const Tensor<1,3> &a1,
                                        const Tensor<1,3> &a2,
-                                       const Point<3> &n,
+                                       const Tensor<1,3> &n,
                                        const double &rn_c)
 {
   Point<3> ra1, ra2, a12;
index 1f3e330adbfb585eb91c02c7c03726b799cbdc1b..45b51788e646afe08f758ca05d2f92aa97b309e4 100644 (file)
@@ -124,7 +124,7 @@ void test(std::string filename)
 
   FullMatrix<double> cell_matrix (dofs_per_cell, dofs_per_cell);
 
-  std::vector< Point<spacedim> > cell_normals(q_midpoint.size());
+  std::vector< Tensor<1,spacedim> > cell_normals(q_midpoint.size());
   std::vector< Point<spacedim> > cell_tangentials(q_midpoint.size());
   std::vector<double> shape_directional_derivative(dofs_per_cell);
   Vector<double> projected_directional_derivative(triangulation.n_cells());
@@ -140,7 +140,7 @@ void test(std::string filename)
 
       fe_values.reinit(cell);
       cell-> get_dof_indices (local_dof_indices);
-      cell_normals = fe_values.get_normal_vectors();
+      cell_normals = fe_values.get_all_normal_vectors();
 
       // The cell tangential is calculated
       // in the midpoint of the cell. For
index e8e211069e7533b78285bf251b72344b87f9a0cf..8544b17589eb96d449a7e37a1e2ae8217df4774e 100644 (file)
@@ -76,7 +76,7 @@ void test(std::string filename)
   for (; cell!=endc; ++cell)
     {
       fe_values.reinit (cell);
-      const std::vector<Point<spacedim> > &cellnormals = fe_values.get_normal_vectors();
+      const std::vector<Tensor<1,spacedim> > &cellnormals = fe_values.get_all_normal_vectors();
       const std::vector<Point<spacedim> > &quad_points = fe_values.get_quadrature_points();
 
       for (unsigned int i=0; i<fe_values.n_quadrature_points; ++i)
index 182c8021a6e259cb86c38a1bfa56b27e90ea10e4..7d34b01f52d6a71fa3d411dc21ba3940e77bfedb 100644 (file)
@@ -323,7 +323,7 @@ namespace Maxwell
 
     // Neumann storage
     std::vector<Vector<double> > neumann_value_list(n_face_q_points, Vector<double>(fe.n_components()));
-    std::vector<Point<dim> > normal_vector_list(fe_face_values.get_normal_vectors());
+    std::vector<Tensor<1,dim> > normal_vector_list(fe_face_values.get_all_normal_vectors());
     Tensor<1,dim> neumann_value_vector(dim);
     Tensor<1,dim> neumann_value(dim);
     Tensor<1,dim> normal_vector;
index 37d05c837d9b8f11987144ff14861a2a42d1db42..ab4ba2cd704c3a9e580acf8ba4e4a0845f227939 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2007 - 2014 by the deal.II authors
+// Copyright (C) 2007 - 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -111,7 +111,7 @@ double integrate_error(const DoFHandler<dim> &dof,
             {
               double diff = 0.;
               for (unsigned int d=0; d<dim; ++d)
-                diff += fe.normal_vector(k)(d) * (f_values[k](d) - fe_values[k](d));
+                diff += fe.normal_vector(k)[d] * (f_values[k](d) - fe_values[k](d));
               result += fe.JxW(k) * diff * diff;
             }
         }
index 7d5ad972c303ba181a31b901d74d01d7a090c15d..b1afa19bfc9634a256cfd1049723f05acab77b18 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 1998 - 2014 by the deal.II authors
+// Copyright (C) 1998 - 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -251,13 +251,13 @@ namespace Step22
     JumpFunction () : Function<dim>(1) {}
 
     double jump (const Point< dim> &p,
-                 const Point<dim> &normal) const;
+                 const Tensor<1,dim> &normal) const;
   };
 
   template <int dim>
   double
   JumpFunction<dim>::jump (const Point<dim>  &p,
-                           const Point<dim> &normal) const
+                           const Tensor<1,dim> &normal) const
   {
     double x = p[0];
     double y = p[1];
@@ -596,8 +596,8 @@ namespace Step22
                   {
                     fe_v_face.reinit (cell, face_no);
 
-                    const std::vector<Point<dim> > &normals =
-                      fe_v_face.get_normal_vectors ();
+                    const std::vector<Tensor<1,dim> > &normals =
+                      fe_v_face.get_all_normal_vectors ();
                     const std::vector<Point<dim> > &quad_points=
                       fe_v_face.get_quadrature_points();
 
index 6f7d72bae14ec0529c79f59f3f9580334b0222a7..cd4ebc860e473cf3d62ad739f894311a8487b6ba 100644 (file)
@@ -110,7 +110,7 @@ plot_faces(Mapping<dim> &mapping,
           for (unsigned int nx=0; nx<nq; ++nx)
             {
               const Point<dim> x = fe_values.quadrature_point(k);
-              const Point<dim> &n = fe_values.normal_vector(k);
+              const Tensor<1,dim> n = fe_values.normal_vector(k);
               const double ds = fe_values.JxW(k);
 
               deallog << x << '\t' << n << '\t' << ds << std::endl;
@@ -149,8 +149,8 @@ plot_subfaces(Mapping<dim> &mapping,
       {
         fe_values.reinit(cell, face_nr, sub_nr);
 
-        const std::vector<Point<dim> > &normals
-          =fe_values.get_normal_vectors();
+        const std::vector<Tensor<1,dim> > &normals
+          =fe_values.get_all_normal_vectors();
 
         unsigned int k=0;
         for (unsigned int ny=0; ny<((dim>2) ? nq : 1); ++ny)
index 697f0912aaf3851185ead23b2b41fb8e095cbf0a..cc6f45fea27484bc96fcacfe6b92058b35fadaf6 100644 (file)
@@ -96,7 +96,7 @@ int main ()
           // there should now be two
           // normal vectors, one for
           // each vertex of the face
-          Assert (c1_values.get_normal_vectors().size() == 2,
+          Assert (c1_values.get_all_normal_vectors().size() == 2,
                   ExcInternalError());
 
           // check that these two
index 58b57eb7a3e3c76e7b844b3dd97e71fedadb051e..3defae43bfd38583f7bc6f1bb89d3269b81ef067 100644 (file)
@@ -141,9 +141,9 @@ void EvaluateNormal2 (DoFHandler<2> *dof_handler,
 
               for (unsigned int q_point=0; q_point<n_q_face; ++q_point)
                 {
-                  Point<2> vn = fe_v_face.normal_vector (q_point);
-                  double nx = vn(0);
-                  double ny = vn(1);
+                  Tensor<1,2> vn = fe_v_face.normal_vector (q_point);
+                  double nx = vn[0];
+                  double ny = vn[1];
 
                   double u = this_value[q_point + offset](0);
                   double v = this_value[q_point + offset](1);
@@ -230,9 +230,9 @@ void EvaluateNormal (DoFHandler<2> *dof_handler,
 
               for (unsigned int q_point=0; q_point<n_q_face; ++q_point)
                 {
-                  Point<2> vn = fe_v_face.normal_vector (q_point);
-                  double nx = vn(0);
-                  double ny = vn(1);
+                  Tensor<1,2> vn = fe_v_face.normal_vector (q_point);
+                  double nx = vn[0];
+                  double ny = vn[1];
 
                   double u = this_value[q_point](0);
                   double v = this_value[q_point](1);
index cce1d791bf789898edda5feebb7a15d428d13a06..96ae7f4f83a035950cdf158e5751a8704fe064fc 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2003 - 2014 by the deal.II authors
+// Copyright (C) 2003 - 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -80,7 +80,7 @@ void check_this (Triangulation<3> &tria)
           // so their sum should be
           // close to zero
           Assert ((fe_face_values1.normal_vector(0) +
-                   fe_face_values2.normal_vector(0)).square()
+                   fe_face_values2.normal_vector(0)).norm_square()
                   < 1e-20,
                   ExcInternalError());
         }
index abce655f7370495b19bd4758cd38c4b7de83b199..633d86818c65a0c498a22addcb709ec046d28c8c 100644 (file)
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2005 - 2014 by the deal.II authors
+// Copyright (C) 2005 - 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -207,7 +207,7 @@ void DGTransportEquation<dim>::assemble_boundary_term(
   Vector<double> &cell_vector) const
 {
   const std::vector<double> &JxW = fe_v.get_present_fe_values().get_JxW_values ();
-  const std::vector<Point<dim> > &normals = fe_v.get_present_fe_values().get_normal_vectors ();
+  const std::vector<Tensor<1,dim> > &normals = fe_v.get_present_fe_values().get_all_normal_vectors ();
 
   std::vector<Point<dim> > beta (fe_v.get_present_fe_values().n_quadrature_points);
   std::vector<double> g(fe_v.get_present_fe_values().n_quadrature_points);
@@ -244,7 +244,7 @@ void DGTransportEquation<dim>::assemble_face_term1(
   FullMatrix<double> &ue_vi_matrix) const
 {
   const std::vector<double> &JxW = fe_v.get_present_fe_values().get_JxW_values ();
-  const std::vector<Point<dim> > &normals = fe_v.get_present_fe_values().get_normal_vectors ();
+  const std::vector<Tensor<1,dim> > &normals = fe_v.get_present_fe_values().get_all_normal_vectors ();
 
   std::vector<Point<dim> > beta (fe_v.get_present_fe_values().n_quadrature_points);
   beta_function.value_list (fe_v.get_present_fe_values().get_quadrature_points(), beta);
@@ -281,7 +281,7 @@ void DGTransportEquation<dim>::assemble_face_term2(
   FullMatrix<double> &ue_ve_matrix) const
 {
   const std::vector<double> &JxW = fe_v.get_present_fe_values().get_JxW_values ();
-  const std::vector<Point<dim> > &normals = fe_v.get_present_fe_values().get_normal_vectors ();
+  const std::vector<Tensor<1,dim> > &normals = fe_v.get_present_fe_values().get_all_normal_vectors ();
 
   std::vector<Point<dim> > beta (fe_v.get_present_fe_values().n_quadrature_points);
 

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.