]> https://gitweb.dealii.org/ - dealii-svn.git/commitdiff
finite elements use new transform functions now
authorkanschat <kanschat@0785d39b-7218-0410-832d-ea1e28bc413d>
Mon, 5 Jan 2009 22:04:45 +0000 (22:04 +0000)
committerkanschat <kanschat@0785d39b-7218-0410-832d-ea1e28bc413d>
Mon, 5 Jan 2009 22:04:45 +0000 (22:04 +0000)
git-svn-id: https://svn.dealii.org/trunk@18087 0785d39b-7218-0410-832d-ea1e28bc413d

deal.II/deal.II/include/fe/fe_poly.templates.h
deal.II/deal.II/include/fe/mapping.h
deal.II/deal.II/source/fe/fe.cc
deal.II/deal.II/source/fe/fe_nedelec.cc
deal.II/deal.II/source/fe/fe_poly_tensor.cc
deal.II/deal.II/source/fe/mapping_q1.cc

index 1b6e3dd802c26ffceee7b9eb88cb62ead5af790d..b579d00b4e1b9bbe6679a217661b838ec12b53a8 100644 (file)
@@ -264,9 +264,9 @@ FE_Poly<TensorProductPolynomials<1>,1,2>::fill_fe_values (const Mapping<1,2> &ma
          Assert (data.shape_gradients[k].size() <=
                  fe_data.shape_gradients[k].size(), 
                  ExcInternalError()); 
-         mapping.transform_covariant(fe_data.shape_gradients[k], 0, 
-                                     data.shape_gradients[k], 
-                                     mapping_data); 
+         mapping.transform(fe_data.shape_gradients[k],
+                           data.shape_gradients[k], 
+                           mapping_data, mapping_covariant); 
        }
     }
   
@@ -307,9 +307,9 @@ FE_Poly<TensorProductPolynomials<2>,2,3>::fill_fe_values (const Mapping<2,3> &ma
         Assert (data.shape_gradients[k].size() <=
                 fe_data.shape_gradients[k].size(), 
                 ExcInternalError());
-        mapping.transform_covariant(fe_data.shape_gradients[k], 0,
-                                    data.shape_gradients[k],
-                                    mapping_data);
+        mapping.transform(fe_data.shape_gradients[k],
+                          data.shape_gradients[k],
+                          mapping_data, mapping_covariant);
        }
     }
   
@@ -350,19 +350,18 @@ FE_Poly<PolynomialSpace<1>,1,2>::fill_fe_values (const Mapping<1,2> &/* mapping
        for (unsigned int i=0; i<quadrature.size(); ++i)
          data.shape_values(k,i) = fe_data.shape_values[k][i];
       
+// TODO: I would think this should work. Guido
+      
       if (flags & update_gradients)
        {
          AssertThrow(false, ExcNotImplemented());
-/*       Assert (data.shape_gradients[k].size() */
-/*               fe_data.shape_gradients[k].size(), */
-/*               ExcInternalError()); */
-/*       mapping.transform_covariant(fe_data.shape_gradients[k], 0, */
-/*                                   data.shape_gradients[k], */
-/*                                   mapping_data); */
+//       mapping.transform(fe_data.shape_gradients[k], 0,
+//                         data.shape_gradients[k],
+//                         mapping_data, mapping_covariant);
        }
     }
   
-  //  const typename QProjector<1>::DataSetDescriptor dsd;
+                                  //  const typename QProjector<1>::DataSetDescriptor dsd;
   if (flags & update_hessians)
     {
       AssertThrow(false, ExcNotImplemented());
@@ -400,9 +399,9 @@ FE_Poly<PolynomialSpace<2>,2,3>::fill_fe_values (const Mapping<2,3> &/* mapping
 /*       Assert (data.shape_gradients[k].size()  */
 /*               fe_data.shape_gradients[k].size(),  */
 /*               ExcInternalError());      */
-/*       mapping.transform_covariant(fe_data.shape_gradients[k], 0,  */
+/*       mapping.transform(fe_data.shape_gradients[k], 0,  */
 /*                                   data.shape_gradients[k],  */
-/*                                   mapping_data);  */
+/*                                   mapping_data, mapping_covariant);  */
        }
     }
   
@@ -443,14 +442,8 @@ FE_Poly<POLY,dim,spacedim>::fill_fe_values (const Mapping<dim,spacedim>
          data.shape_values(k,i) = fe_data.shape_values[k][i];
       
       if (flags & update_gradients)
-       {
-         Assert (data.shape_gradients[k].size() <=
-                 fe_data.shape_gradients[k].size(),
-                 ExcInternalError());    
-         mapping.transform_covariant(fe_data.shape_gradients[k], 0,
-                                     data.shape_gradients[k],
-                                     mapping_data);
-       }
+       mapping.transform(fe_data.shape_gradients[k], data.shape_gradients[k],
+                         mapping_data, mapping_covariant);
     }
   
   const typename QProjector<dim>::DataSetDescriptor dsd;
@@ -561,14 +554,9 @@ FE_Poly<POLY,dim,spacedim>::fill_fe_face_values (const Mapping<dim,spacedim>
          data.shape_values(k,i) = fe_data.shape_values[k][i+offset];
       
       if (flags & update_gradients)
-       {
-         Assert (data.shape_gradients[k].size() + offset <=
-                 fe_data.shape_gradients[k].size(),
-                 ExcInternalError());
-         mapping.transform_covariant(make_slice(fe_data.shape_gradients[k], offset, quadrature.size()),
-                                     0, data.shape_gradients[k],
-                                     mapping_data);
-       }
+       mapping.transform(make_slice(fe_data.shape_gradients[k], offset, quadrature.size()),
+                         data.shape_gradients[k],
+                         mapping_data, mapping_covariant);
     }
 
   if (flags & update_hessians)
@@ -686,9 +674,9 @@ FE_Poly<POLY,dim,spacedim>::fill_fe_subface_values (const Mapping<dim,spacedim>
          Assert (data.shape_gradients[k].size() + offset <=
                  fe_data.shape_gradients[k].size(),
                  ExcInternalError());
-         mapping.transform_covariant(make_slice(fe_data.shape_gradients[k], offset, quadrature.size()),
-                                     0, data.shape_gradients[k],
-                                     mapping_data);
+         mapping.transform(make_slice(fe_data.shape_gradients[k], offset, quadrature.size()),
+                           data.shape_gradients[k],
+                           mapping_data, mapping_covariant);
        }
     }
   
index ebb7da2c1a5adba04418e68aa1b7eecec998409e..95779156ee6b0a8c1e0034fab2c70c0b79b71811 100644 (file)
@@ -50,6 +50,14 @@ template <int dim, int spacedim> class FESubfaceValues;
                                       * the transform() functions of
                                       * inheriting classes in order to
                                       * work.
+                                     *
+                                     * Mappings are usually defined
+                                     * for vectors. If such a
+                                     * MappingType is applied to a
+                                     * rank 2 tensor, it is implied
+                                     * that the resulting Tensor
+                                     * corresponds to the derivative
+                                     * of the vector.
                                       */
 enum MappingType
 {
index 0e17e536dbc4cd7a124c3dcfa4094591b032ac9f..3a44e0290aa5f6e1e61b24e406b5a39bef916d56 100644 (file)
@@ -2,7 +2,7 @@
 //    $Id$
 //    Version: $Name$
 //
-//    Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by the deal.II authors
+//    Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 by the deal.II authors
 //
 //    This file is subject to QPL and may not be  distributed
 //    without copyright and license information. Please refer
@@ -1119,8 +1119,8 @@ FiniteElement<dim,spacedim>::compute_2nd (
             Assert (diff_quot2.size() <=
                     diff_quot[d].size(),
                     ExcInternalError());
-            mapping.transform_covariant (diff_quot[d], 0, diff_quot2,
-                                         mapping_internal);
+            mapping.transform (diff_quot[d], diff_quot2,
+                              mapping_internal, mapping_covariant);
             
             for (unsigned int q=0; q<n_q_points; ++q)
               for (unsigned int d1=0; d1<dim; ++d1)
index 95a5cba93bf9c7ad716657683b5c9436b4ef3118..71901c7b08ecad7b452f57ee5e3525a9abbb4274 100644 (file)
@@ -1035,9 +1035,8 @@ FE_Nedelec<dim,spacedim>::fill_fe_values (const Mapping<dim,spacedim>
                                           // values...
          Assert (fe_data.shape_values[k].size() == n_q_points,
                  ExcInternalError());
-         mapping.transform_covariant(fe_data.shape_values[k], 0,
-                                      shape_values,
-                                      mapping_data);
+         mapping.transform(fe_data.shape_values[k], shape_values,
+                           mapping_data, mapping_covariant);
 
                                           // then copy over to target:
          for (unsigned int q=0; q<n_q_points; ++q)
@@ -1085,15 +1084,14 @@ FE_Nedelec<dim,spacedim>::fill_fe_values (const Mapping<dim,spacedim>
          Assert (fe_data.shape_gradients[k].size() == n_q_points,
                  ExcInternalError());
                                            // do first transformation
-         mapping.transform_covariant(fe_data.shape_gradients[k], 0,
-                                      shape_grads1,
-                                      mapping_data);
+         mapping.transform(fe_data.shape_gradients[k], shape_grads1,
+                           mapping_data, mapping_covariant);
                                            // transpose matrix
           for (unsigned int q=0; q<n_q_points; ++q)
             shape_grads2[q] = transpose(shape_grads1[q]);
                                            // do second transformation
-         mapping.transform_covariant(shape_grads2, 0, shape_grads1,
-                                      mapping_data);
+         mapping.transform(shape_grads2, shape_grads1,
+                           mapping_data, mapping_covariant);
                                            // transpose back
           for (unsigned int q=0; q<n_q_points; ++q)
             shape_grads2[q] = transpose(shape_grads1[q]);
@@ -1178,10 +1176,8 @@ FE_Nedelec<dim,spacedim>::fill_fe_face_values (const Mapping<dim,spacedim>
        {
                                           // first transform shape
                                           // values...
-         mapping.transform_covariant(make_slice(fe_data.shape_values[k], offset, n_q_points),
-                                     0,
-                                      shape_values,
-                                      mapping_data);
+         mapping.transform(make_slice(fe_data.shape_values[k], offset, n_q_points),
+                           shape_values, mapping_data, mapping_covariant);
 
                                           // then copy over to target:
          for (unsigned int q=0; q<n_q_points; ++q)
@@ -1236,15 +1232,14 @@ FE_Nedelec<dim,spacedim>::fill_fe_face_values (const Mapping<dim,spacedim>
                                            // little in between
                                            // 
                                            // do first transformation
-         mapping.transform_covariant(make_slice(fe_data.shape_gradients[k], offset, n_q_points),
-                                     0, shape_grads1,
-                                      mapping_data);
+         mapping.transform(make_slice(fe_data.shape_gradients[k], offset, n_q_points),
+                           shape_grads1, mapping_data, mapping_covariant);
                                            // transpose matrix
           for (unsigned int q=0; q<n_q_points; ++q)
             shape_grads2[q] = transpose(shape_grads1[q]);
                                            // do second transformation
-         mapping.transform_covariant(shape_grads2, 0, shape_grads1,
-                                      mapping_data);
+         mapping.transform(shape_grads2, shape_grads1,
+                           mapping_data, mapping_covariant);
                                            // transpose back
           for (unsigned int q=0; q<n_q_points; ++q)
             shape_grads2[q] = transpose(shape_grads1[q]);
@@ -1327,9 +1322,8 @@ FE_Nedelec<dim,spacedim>::fill_fe_subface_values (const Mapping<dim,spacedim>
        {
                                           // first transform shape
                                           // values...
-         mapping.transform_covariant(make_slice(fe_data.shape_values[k], offset, n_q_points),
-                                     0, shape_values,
-                                      mapping_data);
+         mapping.transform(make_slice(fe_data.shape_values[k], offset, n_q_points),
+                           shape_values, mapping_data, mapping_covariant);
 
                                           // then copy over to target:
          for (unsigned int q=0; q<n_q_points; ++q)
@@ -1382,15 +1376,14 @@ FE_Nedelec<dim,spacedim>::fill_fe_subface_values (const Mapping<dim,spacedim>
                                            // little in between
                                            // 
                                            // do first transformation
-         mapping.transform_covariant(make_slice(fe_data.shape_gradients[k], offset, n_q_points),
-                                     0, shape_grads1,
-                                      mapping_data);
+         mapping.transform(make_slice(fe_data.shape_gradients[k], offset, n_q_points),
+                           shape_grads1, mapping_data, mapping_covariant);
                                            // transpose matrix
           for (unsigned int q=0; q<n_q_points; ++q)
             shape_grads2[q] = transpose(shape_grads1[q]);
                                            // do second transformation
-         mapping.transform_covariant(shape_grads2, 0, shape_grads1,
-                                      mapping_data);
+         mapping.transform(shape_grads2, shape_grads1,
+                           mapping_data, mapping_covariant);
                                            // transpose back
           for (unsigned int q=0; q<n_q_points; ++q)
             shape_grads2[q] = transpose(shape_grads1[q]);
index 80b98afdb98044df6507338c1c271b8770004566..5b53f9613a13ec897e19074475b686afca20870e 100644 (file)
@@ -416,11 +416,11 @@ FE_PolyTensor<POLY,dim,spacedim>::fill_fe_values (
                                                 // transformation
                std::vector<Tensor<1,dim> > shape_values (n_q_points);
                if (mapping_type == covariant)
-                 mapping.transform_covariant(fe_data.shape_values[i], 0,
-                                             shape_values, mapping_data);
+                 mapping.transform(fe_data.shape_values[i],
+                                   shape_values, mapping_data, mapping_covariant);
                else
-                 mapping.transform_contravariant(fe_data.shape_values[i], 0,
-                                                 shape_values, mapping_data);
+                 mapping.transform(fe_data.shape_values[i],
+                                   shape_values, mapping_data, mapping_contravariant);
                    
                                                 // then copy over to target:
                for (unsigned int k=0; k<n_q_points; ++k)
@@ -454,9 +454,8 @@ FE_PolyTensor<POLY,dim,spacedim>::fill_fe_values (
              case independent:
              case independent_on_cartesian:
              {
-               mapping.transform_covariant(fe_data.shape_grads[i], 0,
-                                           shape_grads1,
-                                           mapping_data);
+               mapping.transform(fe_data.shape_grads[i], shape_grads1,
+                                 mapping_data, mapping_covariant);
                for (unsigned int k=0; k<n_q_points; ++k)
                  for (unsigned int d=0; d<dim; ++d)
                    data.shape_gradients[first+d][k] = shape_grads1[k][d];
@@ -465,14 +464,13 @@ FE_PolyTensor<POLY,dim,spacedim>::fill_fe_values (
              
              case covariant:
              {
-               mapping.transform_covariant(fe_data.shape_grads[i], 0,
-                                           shape_grads1,
-                                           mapping_data);
+               mapping.transform(fe_data.shape_grads[i], shape_grads1,
+                                 mapping_data, mapping_covariant);
                for (unsigned int q=0; q<n_q_points; ++q)
                  shape_grads2[q] = transpose(shape_grads1[q]);
                                                 // do second transformation
-               mapping.transform_covariant(shape_grads2, 0, shape_grads1,
-                                           mapping_data);
+               mapping.transform(shape_grads2, shape_grads1,
+                                 mapping_data, mapping_covariant);
                                                 // transpose back
                for (unsigned int q=0; q<n_q_points; ++q)
                  shape_grads2[q] = transpose(shape_grads1[q]);
@@ -486,13 +484,11 @@ FE_PolyTensor<POLY,dim,spacedim>::fill_fe_values (
              
              case contravariant:
              {
-               mapping.transform_covariant(fe_data.shape_grads[i], 0,
-                                           shape_grads1,
-                                           mapping_data);
-
-               mapping.transform_contravariant(shape_grads1, 0,
-                                               shape_grads2,
-                                               mapping_data);
+               mapping.transform(fe_data.shape_grads[i], shape_grads1,
+                                 mapping_data, mapping_covariant);
+               
+               mapping.transform(shape_grads1, shape_grads2,
+                                 mapping_data, mapping_contravariant);
 
                for (unsigned int k=0; k<n_q_points; ++k)
                  for (unsigned int d=0; d<dim; ++d)
@@ -594,11 +590,11 @@ FE_PolyTensor<POLY,dim,spacedim>::fill_fe_face_values (
                                                 // for transformation
                std::vector<Tensor<1,dim> > shape_values (n_q_points);
                if (mapping_type == covariant)
-                 mapping.transform_covariant(make_slice(fe_data.shape_values[i], offset, n_q_points),
-                                             0, shape_values, mapping_data);
+                 mapping.transform(make_slice(fe_data.shape_values[i], offset, n_q_points),
+                                   shape_values, mapping_data, mapping_covariant);
                else
-                 mapping.transform_contravariant(make_slice(fe_data.shape_values[i], offset, n_q_points),
-                                                 0, shape_values, mapping_data);
+                 mapping.transform(make_slice(fe_data.shape_values[i], offset, n_q_points),
+                                   shape_values, mapping_data, mapping_contravariant);
                
                                                 // then copy over to target:
                for (unsigned int k=0; k<n_q_points; ++k)
@@ -643,8 +639,8 @@ FE_PolyTensor<POLY,dim,spacedim>::fill_fe_face_values (
              case independent:
              case independent_on_cartesian:
              {
-               mapping.transform_covariant(make_slice(fe_data.shape_grads[i], offset, n_q_points),
-                                           0, shape_grads1, mapping_data);
+               mapping.transform(make_slice(fe_data.shape_grads[i], offset, n_q_points),
+                                 shape_grads1, mapping_data, mapping_covariant);
                for (unsigned int k=0; k<n_q_points; ++k)
                  for (unsigned int d=0; d<dim; ++d)
                    data.shape_gradients[first+d][k] = shape_grads1[k][d];
@@ -653,13 +649,13 @@ FE_PolyTensor<POLY,dim,spacedim>::fill_fe_face_values (
              
              case covariant:
              {
-               mapping.transform_covariant(make_slice(fe_data.shape_grads[i], offset, n_q_points),
-                                           0, shape_grads1, mapping_data);
+               mapping.transform(make_slice(fe_data.shape_grads[i], offset, n_q_points),
+                                 shape_grads1, mapping_data, mapping_covariant);
                for (unsigned int q=0; q<n_q_points; ++q)
                  shape_grads2[q] = transpose(shape_grads1[q]);
                                                 // do second transformation
-               mapping.transform_covariant(shape_grads2, 0, shape_grads1,
-                                           mapping_data);
+               mapping.transform(shape_grads2, shape_grads1,
+                                 mapping_data, mapping_covariant);
                                                 // transpose back
                for (unsigned int q=0; q<n_q_points; ++q)
                  shape_grads2[q] = transpose(shape_grads1[q]);
@@ -672,13 +668,11 @@ FE_PolyTensor<POLY,dim,spacedim>::fill_fe_face_values (
              
              case contravariant:
              {
-               mapping.transform_covariant(make_slice(fe_data.shape_grads[i], offset, n_q_points),
-                                           0, shape_grads1,
-                                           mapping_data);
+               mapping.transform(make_slice(fe_data.shape_grads[i], offset, n_q_points),
+                                 shape_grads1, mapping_data, mapping_covariant);
 
-               mapping.transform_contravariant(shape_grads1, 0,
-                                               shape_grads2,
-                                               mapping_data);
+               mapping.transform(shape_grads1, shape_grads2,
+                                 mapping_data, mapping_contravariant);
 
                for (unsigned int k=0; k<n_q_points; ++k)
                  for (unsigned int d=0; d<dim; ++d)
@@ -777,11 +771,11 @@ FE_PolyTensor<POLY,dim,spacedim>::fill_fe_subface_values (
                                                 // transformation
                std::vector<Tensor<1,dim> > shape_values (n_q_points);
                if (mapping_type == covariant)
-                 mapping.transform_covariant(make_slice(fe_data.shape_values[i], offset, n_q_points),
-                                             0, shape_values, mapping_data);
+                 mapping.transform(make_slice(fe_data.shape_values[i], offset, n_q_points),
+                                   shape_values, mapping_data, mapping_covariant);
                else
-                 mapping.transform_contravariant(make_slice(fe_data.shape_values[i], offset, n_q_points),
-                                                 0, shape_values, mapping_data);
+                 mapping.transform(make_slice(fe_data.shape_values[i], offset, n_q_points),
+                                   shape_values, mapping_data, mapping_contravariant);
                    
                                                 // then copy over to target:
                for (unsigned int k=0; k<n_q_points; ++k)
@@ -826,8 +820,8 @@ FE_PolyTensor<POLY,dim,spacedim>::fill_fe_subface_values (
              case independent:
              case independent_on_cartesian:
              {
-               mapping.transform_covariant(make_slice(fe_data.shape_grads[i], offset, n_q_points),
-                                           0, shape_grads1, mapping_data);
+               mapping.transform(make_slice(fe_data.shape_grads[i], offset, n_q_points),
+                                 shape_grads1, mapping_data, mapping_covariant);
                for (unsigned int k=0; k<n_q_points; ++k)
                  for (unsigned int d=0; d<dim; ++d)
                    data.shape_gradients[first+d][k] = shape_grads1[k][d];
@@ -836,14 +830,13 @@ FE_PolyTensor<POLY,dim,spacedim>::fill_fe_subface_values (
              
              case covariant:
              {
-               mapping.transform_covariant(make_slice(fe_data.shape_grads[i], offset, n_q_points),
-                                           0, shape_grads1,
-                                           mapping_data);
+               mapping.transform(make_slice(fe_data.shape_grads[i], offset, n_q_points),
+                                 shape_grads1, mapping_data, mapping_covariant);
                for (unsigned int q=0; q<n_q_points; ++q)
                  shape_grads2[q] = transpose(shape_grads1[q]);
                                                 // do second transformation
-               mapping.transform_covariant(shape_grads2, 0, shape_grads1,
-                                           mapping_data);
+               mapping.transform(shape_grads2, shape_grads1,
+                                 mapping_data, mapping_covariant);
                                                 // transpose back
                for (unsigned int q=0; q<n_q_points; ++q)
                  shape_grads2[q] = transpose(shape_grads1[q]);
@@ -856,13 +849,11 @@ FE_PolyTensor<POLY,dim,spacedim>::fill_fe_subface_values (
              
              case contravariant:
              {
-               mapping.transform_covariant(make_slice(fe_data.shape_grads[i], offset, n_q_points),
-                                           0, shape_grads1,
-                                           mapping_data);
+               mapping.transform(make_slice(fe_data.shape_grads[i], offset, n_q_points),
+                                 shape_grads1, mapping_data, mapping_covariant);
 
-               mapping.transform_contravariant(shape_grads1, 0,
-                                               shape_grads2,
-                                               mapping_data);
+               mapping.transform(shape_grads1, shape_grads2,
+                                 mapping_data, mapping_contravariant);
 
                for (unsigned int k=0; k<n_q_points; ++k)
                  for (unsigned int d=0; d<dim; ++d)
index a56229b2a24212e964396ac9bcd4babc51915663..5c0b52828cc1e54145e7252243504f8b80fe2a36 100644 (file)
@@ -897,14 +897,10 @@ MappingQ1<dim,spacedim>::compute_fill_face (const typename Triangulation<dim,spa
                ExcDimensionMismatch(normal_vectors.size(), n_q_points));
       if (update_flags & update_JxW_values)
        Assert (JxW_values.size() == n_q_points,
-               ExcDimensionMismatch(JxW_values.size(), n_q_points));
+               ExcDimensionMismatch(JxW_values.size(), n_q_points));      
       
-      
-      Assert (data.aux[0].size() <= data.unit_tangentials[face_no].size(),
-             ExcInternalError());
-      transform_contravariant(data.unit_tangentials[face_no], 0,
-                              data.aux[0],
-                             data);
+      transform(data.unit_tangentials[face_no], data.aux[0],
+               data, mapping_contravariant);
 
       typename std::vector<Tensor<1,dim> >::iterator
        result = boundary_forms.begin();
@@ -928,10 +924,8 @@ MappingQ1<dim,spacedim>::compute_fill_face (const typename Triangulation<dim,spa
             Assert (data.aux[1].size() <=
                     data.unit_tangentials[face_no+GeometryInfo<dim>::faces_per_cell].size(),
                     ExcInternalError());
-            transform_contravariant(data.unit_tangentials[
-                                      face_no+GeometryInfo<dim>::faces_per_cell], 0,
-                                    data.aux[1],
-                                    data);
+            transform(data.unit_tangentials[face_no+GeometryInfo<dim>::faces_per_cell],
+                     data.aux[1], data, mapping_contravariant);
             for (unsigned int i=0; result != end; ++result, ++i)
               cross_product (*result, data.aux[0][i], data.aux[1][i]);
 
@@ -1240,6 +1234,7 @@ MappingQ1<dim,spacedim>::transform (
 }
 
 
+// This function is deprecated and has been replaced by transform above
 template<int dim, int spacedim>
 void
 MappingQ1<dim,spacedim>::transform_covariant (
@@ -1271,6 +1266,7 @@ MappingQ1<dim,spacedim>::transform_covariant (
 
 
 
+// This function is deprecated and has been replaced by transform above
 template <int dim, int spacedim>
 void
 MappingQ1<dim, spacedim>::transform_covariant (
@@ -1297,6 +1293,8 @@ MappingQ1<dim, spacedim>::transform_covariant (
 
 #if deal_II_dimension == 1
 
+
+// This function is deprecated and has been replaced by transform above
 template <>
 void
 MappingQ1<1, 2>::transform_covariant (
@@ -1312,6 +1310,8 @@ MappingQ1<1, 2>::transform_covariant (
 
 #if deal_II_dimension == 2
 
+
+// This function is deprecated and has been replaced by transform above
 template <>
 void
 MappingQ1<2, 3>::transform_covariant (
@@ -1326,10 +1326,10 @@ MappingQ1<2, 3>::transform_covariant (
 #endif
 
 
+// This function is deprecated and has been replaced by transform above
 template<int dim, int spacedim>
 void
-MappingQ1<dim,spacedim>::
-transform_contravariant (
+MappingQ1<dim,spacedim>::transform_contravariant (
   const VectorSlice<const std::vector<Tensor<1,dim> > > input,
   const unsigned int                 offset,
   VectorSlice<std::vector<Tensor<1,spacedim> > > output,
@@ -1357,6 +1357,7 @@ transform_contravariant (
 
 
 
+// This function is deprecated and has been replaced by transform above
 template<int dim, int spacedim>
 void
 MappingQ1<dim,spacedim>::transform_contravariant (
@@ -1382,6 +1383,7 @@ MappingQ1<dim,spacedim>::transform_contravariant (
 
 #if deal_II_dimension == 1
 
+// This function is deprecated and has been replaced by transform above
 template <>
 void
 MappingQ1<1, 2>::transform_contravariant (
@@ -1397,6 +1399,7 @@ MappingQ1<1, 2>::transform_contravariant (
 
 #if deal_II_dimension == 2
 
+// This function is deprecated and has been replaced by transform above
 template <>
 void
 MappingQ1<2, 3>::transform_contravariant (

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.