]> https://gitweb.dealii.org/ - dealii-svn.git/commitdiff
new Mapping::transform implemented, but not used
authorkanschat <kanschat@0785d39b-7218-0410-832d-ea1e28bc413d>
Mon, 5 Jan 2009 21:13:20 +0000 (21:13 +0000)
committerkanschat <kanschat@0785d39b-7218-0410-832d-ea1e28bc413d>
Mon, 5 Jan 2009 21:13:20 +0000 (21:13 +0000)
git-svn-id: https://svn.dealii.org/trunk@18085 0785d39b-7218-0410-832d-ea1e28bc413d

deal.II/deal.II/include/fe/mapping.h
deal.II/deal.II/include/fe/mapping_cartesian.h
deal.II/deal.II/include/fe/mapping_q.h
deal.II/deal.II/include/fe/mapping_q1.h
deal.II/deal.II/source/fe/mapping_cartesian.cc
deal.II/deal.II/source/fe/mapping_q.cc
deal.II/deal.II/source/fe/mapping_q1.cc

index fe9ad1f52e5976e2a4b5f20550f8a132770d3f17..ebb7da2c1a5adba04418e68aa1b7eecec998409e 100644 (file)
@@ -313,30 +313,7 @@ class Mapping : public Subscriptor
                const MappingType type) const = 0;
     
                                     /**
-                                     * Transform a field of covariant
-                                     * vectors. The covariant
-                                     * transformation multiplies a
-                                     * vector from the right with the
-                                     * inverse of the Jacobian matrix
-                                     * of the transformation from
-                                     * unit to real space
-                                     * cell. Alternatively, this is
-                                     * equivalent to a multiplication
-                                     * from the left with the
-                                     * transpose of the inverse
-                                     * matrix.
-                                     *
-                                     * The list of arguments is as follows:
-                                     * we transform as many elements in the
-                                     * @p input field, starting from @p offset,
-                                     * as there are elements in @p
-                                     * output. The @p input array may hold
-                                     * more elements than are needed (some
-                                     * finite element classes use this for a
-                                     * denser storage of data), but it needs
-                                     * to have at least
-                                     * <tt>output.size()</tt> elements
-                                     * starting with element @p offset.
+                                     * @deprecated Use transform() instead.
                                      */
     virtual
     void
@@ -346,16 +323,7 @@ class Mapping : public Subscriptor
                         const InternalDataBase &internal) const = 0;
 
                                      /**
-                                      * Transform a set of matrices
-                                      * covariantly, i.e. multiply
-                                      * each function in the input
-                                      * range by the Jacobian matrices
-                                      * at the different quadrature
-                                      * points from the left.
-                                      *
-                                      * The same applies as to the
-                                      * function above regarding input
-                                      * and output arguments.
+                                     * @deprecated Use transform() instead.
                                       */
     virtual
     void
@@ -364,58 +332,22 @@ class Mapping : public Subscriptor
                         VectorSlice<std::vector<Tensor<2,spacedim> > >      output,
                         const InternalDataBase &internal) const = 0;
 
-//TODO: The argument list here seems wrong
-    
                                     /**
-                                     * Transform a field of
-                                     * contravariant vectors. The
-                                     * contravariant transformation
-                                     * multiplies a vector from the
-                                     * left with the Jacobian matrix
-                                     * of the transformation from
-                                     * unit to real space cell.
-                                     * 
-                                     * The list of arguments is as follows:
-                                     * we transform as many elements in the
-                                     * @p input field, starting from @p offset,
-                                     * as there are elements in @p
-                                     * output. The @p input array may hold
-                                     * more elements than are needed (some
-                                     * finite element classes use this for a
-                                     * denser storage of data), but it needs
-                                     * to have at least
-                                     * <tt>output.size()</tt> elements
-                                     * starting with element @p offset.
+                                     * @deprecated Use transform() instead.
                                      */
     virtual
     void
-    transform_contravariant (const VectorSlice<const std::vector<Tensor<1,spacedim> > > input,
+    transform_contravariant (const VectorSlice<const std::vector<Tensor<1,dim> > > input,
                              const unsigned int                 offset,
                             VectorSlice<std::vector<Tensor<1,spacedim> > >      output,
                             const typename Mapping<dim,spacedim>::InternalDataBase &internal) const = 0;
 
                                      /**
-                                      * Transform a set of matrices
-                                      * contravariantly, i.e. multiply
-                                      * each function in the input
-                                      * range by the inverse Jacobian
-                                      * matrices at the different
-                                      * quadrature points from the
-                                      * right. Note that here it is no
-                                      * more equivalent to
-                                      * multiplication with the
-                                      * transpose of the inverse
-                                      * matrices from the left, unless
-                                      * the matrices to be multiplied
-                                      * with are symmetric.
-                                      *
-                                      * The same applies as to the
-                                      * function above regarding input
-                                      * and output arguments.
+                                     * @deprecated Use transform() instead.
                                       */
     
     virtual void
-    transform_contravariant (const VectorSlice<const std::vector<Tensor<2,spacedim> > > intput,
+    transform_contravariant (const VectorSlice<const std::vector<Tensor<2,dim> > > intput,
                              const unsigned int                 offset,
                             const VectorSlice<std::vector<Tensor<2,spacedim> > > output,
                             const typename Mapping<dim,spacedim>::InternalDataBase &internal) const = 0;
index 34c14b6b2aef7fec716d5f6a12b522480df9bf6b..6967368e8d8a2f5961192994c95e14c0a31dde98 100644 (file)
@@ -106,25 +106,25 @@ class MappingCartesian : public Mapping<dim,spacedim>
     
 
     virtual void
-    transform_covariant (const VectorSlice<const std::vector<Tensor<1,spacedim> > > input,
+    transform_covariant (const VectorSlice<const std::vector<Tensor<1,dim> > > input,
                          const unsigned int                 offset,
                         VectorSlice<std::vector<Tensor<1,spacedim> > > output,
                         const typename Mapping<dim, spacedim>::InternalDataBase &internal) const;
     
     virtual void
-    transform_covariant (const VectorSlice<const std::vector<Tensor<2,spacedim> > > input,
+    transform_covariant (const VectorSlice<const std::vector<Tensor<2,dim> > > input,
                          const unsigned int                 offset,
                         VectorSlice<std::vector<Tensor<2,spacedim> > > output,
                         const typename Mapping<dim, spacedim>::InternalDataBase &internal) const;
     
     virtual void
-    transform_contravariant (const VectorSlice<const std::vector<Tensor<1,spacedim> > > input,
+    transform_contravariant (const VectorSlice<const std::vector<Tensor<1,dim> > > input,
                              const unsigned int                 offset,
                             VectorSlice<std::vector<Tensor<1,spacedim> > > output,
                             const typename Mapping<dim, spacedim>::InternalDataBase &internal) const;
     
     virtual void
-    transform_contravariant (const VectorSlice<const std::vector<Tensor<2,spacedim> > > input,
+    transform_contravariant (const VectorSlice<const std::vector<Tensor<2,dim> > > input,
                              const unsigned int                 offset,
                             VectorSlice<std::vector<Tensor<2,spacedim> > > output,
                             const typename Mapping<dim, spacedim>::InternalDataBase &internal) const;
index 6995b18a838b9e0bd4bfdbb0d2267be1285f206e..288f12ce3262ee1f700751dee72d1df195132943 100644 (file)
@@ -153,7 +153,7 @@ class MappingQ : public MappingQ1<dim,spacedim>
                                      * interface in Mapping.
                                      */
     virtual void
-    transform_contravariant (const VectorSlice<const std::vector<Tensor<1,spacedim> > > input,
+    transform_contravariant (const VectorSlice<const std::vector<Tensor<1,dim> > > input,
                              const unsigned int                 offset,
                             VectorSlice<std::vector<Tensor<1,spacedim> > > output,
                             const typename Mapping<dim,spacedim>::InternalDataBase &internal) const;    
@@ -163,7 +163,7 @@ class MappingQ : public MappingQ1<dim,spacedim>
                                      * interface in Mapping.
                                      */
     virtual void
-    transform_contravariant (const VectorSlice<const std::vector<Tensor<2,spacedim> > > input,
+    transform_contravariant (const VectorSlice<const std::vector<Tensor<2,dim> > > input,
                              const unsigned int                 offset,
                             VectorSlice<std::vector<Tensor<2,spacedim> > > output,
                             const typename Mapping<dim,spacedim>::InternalDataBase &internal) const;    
index 73c8b50321c0ece9e8be2aef973b452c48bb06b3..fd9a81d6439b6bd015caed6da18a2663050ca389 100644 (file)
@@ -102,13 +102,13 @@ class MappingQ1 : public Mapping<dim,spacedim>
                         const typename Mapping<dim,spacedim>::InternalDataBase &internal) const;
     
     virtual void
-    transform_contravariant (const VectorSlice<const std::vector<Tensor<1,spacedim> > > input,
+    transform_contravariant (const VectorSlice<const std::vector<Tensor<1,dim> > > input,
                              const unsigned int                 offset,
                             VectorSlice<std::vector<Tensor<1,spacedim> > > output,
                             const typename Mapping<dim,spacedim>::InternalDataBase &internal) const;
     
     virtual void
-    transform_contravariant (const VectorSlice<const std::vector<Tensor<2,spacedim> > > input,
+    transform_contravariant (const VectorSlice<const std::vector<Tensor<2,dim> > > input,
                              const unsigned int                 offset,
                             VectorSlice<std::vector<Tensor<2,spacedim> > > output,
                             const typename Mapping<dim,spacedim>::InternalDataBase &internal) const;
index ff325623767b29b7375cff5513ae242105cb0d25..9613be68526c215c7a2efd729358ce149638f8a4 100644 (file)
@@ -509,17 +509,38 @@ void
 MappingCartesian<dim,spacedim>::transform (
   const VectorSlice<const std::vector<Tensor<1,dim> > > input,
   VectorSlice<std::vector<Tensor<1,spacedim> > > output,
-  const typename Mapping<dim,spacedim>::InternalDataBase &internal,
+  const typename Mapping<dim,spacedim>::InternalDataBase &mapping_data,
   const MappingType mapping_type) const
 {
+  AssertDimension (input.size(), output.size());
+  Assert (dynamic_cast<const InternalData *>(&mapping_data) != 0, 
+         ExcInternalError());  
+  const InternalData &data = dynamic_cast<const InternalData&> (mapping_data);
+  
   switch (mapping_type)
     {
       case mapping_covariant:
-           transform_covariant(input, 0, output, internal);
-           return;
-//       case mapping_contravariant:
-//         transform_contravariant(input, 0, output, internal);
-//         return;
+           if (true)
+             {
+               Assert (data.update_flags & update_covariant_transformation,
+                       typename FEValuesBase<dim>::ExcAccessToUninitializedField());
+               
+               for (unsigned int i=0; i<output.size(); ++i)
+                 for (unsigned int d=0;d<dim;++d)
+                   output[i][d] = input[i][d]/data.length[d];
+               return;
+             }
+      case mapping_contravariant:
+           if (true)
+             {
+               Assert (data.update_flags & update_contravariant_transformation,
+                       typename FEValuesBase<dim>::ExcAccessToUninitializedField());
+               
+               for (unsigned int i=0; i<output.size(); ++i)
+                 for (unsigned int d=0;d<dim;++d)
+                   output[i][d] = input[i][d]*data.length[d];
+               return;
+             }
       default:
            Assert(false, ExcNotImplemented());
     }
@@ -538,9 +559,9 @@ MappingCartesian<dim,spacedim>::transform (
       case mapping_covariant:
            transform_covariant(input, 0, output, internal);
            return;
-//       case mapping_contravariant:
-//         transform_contravariant(input, 0, output, internal);
-//         return;
+       case mapping_contravariant:
+           transform_contravariant(input, 0, output, internal);
+           return;
       default:
            Assert(false, ExcNotImplemented());
     }
@@ -551,7 +572,7 @@ MappingCartesian<dim,spacedim>::transform (
 template<int dim, int spacedim>
 void
 MappingCartesian<dim, spacedim>::transform_covariant (
-  const VectorSlice<const std::vector<Tensor<1,spacedim> > > input,
+  const VectorSlice<const std::vector<Tensor<1,dim> > > input,
   const unsigned int                 offset,
   VectorSlice<std::vector<Tensor<1,spacedim> > > output,
   const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data) const
@@ -563,8 +584,6 @@ MappingCartesian<dim, spacedim>::transform_covariant (
 
   Assert (data.update_flags & update_covariant_transformation,
          typename FEValuesBase<dim>::ExcAccessToUninitializedField());
-
-  Assert (output.size() + offset <= input.size(), ExcInternalError());
   
                                   // simply scale by inverse Jacobian
                                   // (which is diagonal here)
@@ -578,7 +597,7 @@ MappingCartesian<dim, spacedim>::transform_covariant (
 template<int dim, int spacedim>
 void
 MappingCartesian<dim, spacedim>::transform_covariant (
-  const VectorSlice<const std::vector<Tensor<2,spacedim> > > input,
+  const VectorSlice<const std::vector<Tensor<2,dim> > > input,
   const unsigned int                 offset,
   VectorSlice<std::vector<Tensor<2,spacedim> > > output,
   const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data) const
@@ -606,7 +625,7 @@ MappingCartesian<dim, spacedim>::transform_covariant (
 template<int dim, int spacedim>
 void
 MappingCartesian<dim, spacedim>::transform_contravariant (
-  const VectorSlice<const std::vector<Tensor<1,spacedim> > > input,
+  const VectorSlice<const std::vector<Tensor<1,dim> > > input,
   const unsigned int                 offset,
   VectorSlice<std::vector<Tensor<1,spacedim> > > output,
   const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data) const
@@ -637,7 +656,7 @@ MappingCartesian<dim, spacedim>::transform_contravariant (
 template<int dim, int spacedim>
 void
 MappingCartesian<dim, spacedim>::transform_contravariant (
-  const VectorSlice<const std::vector<Tensor<2,spacedim> > > input,
+  const VectorSlice<const std::vector<Tensor<2,dim> > > input,
   const unsigned int                 offset,
   VectorSlice<std::vector<Tensor<2,spacedim> > > output,
   const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data) const
index 45892480b56216516d5056dded10668156477c09..53e84d17b0a7e0d7fd401dfc18f14b0ba64e4a44 100644 (file)
@@ -302,15 +302,15 @@ MappingQ<dim,spacedim>::get_subface_data (const UpdateFlags update_flags,
 template<int dim, int spacedim>
 void
 MappingQ<dim,spacedim>::fill_fe_values (
-                               const typename Triangulation<dim,spacedim>::cell_iterator &cell,
-                              const Quadrature<dim>                                     &q,
-                              typename Mapping<dim,spacedim>::InternalDataBase          &mapping_data,
-                              std::vector<Point<spacedim> >                             &quadrature_points,
-                              std::vector<double>                                       &JxW_values,
-                              std::vector<Tensor<2,spacedim> >                          &jacobians,
-                              std::vector<Tensor<3,spacedim> >                          &jacobian_grads,
-                              std::vector<Tensor<2,spacedim> >                          &inverse_jacobians,
-                              std::vector<Point<spacedim> >                             &cell_normal_vectors) const
+  const typename Triangulation<dim,spacedim>::cell_iterator &cell,
+  const Quadrature<dim>                                     &q,
+  typename Mapping<dim,spacedim>::InternalDataBase          &mapping_data,
+  std::vector<Point<spacedim> >                             &quadrature_points,
+  std::vector<double>                                       &JxW_values,
+  std::vector<Tensor<2,spacedim> >                          &jacobians,
+  std::vector<Tensor<3,spacedim> >                          &jacobian_grads,
+  std::vector<Tensor<2,spacedim> >                          &inverse_jacobians,
+  std::vector<Point<spacedim> >                             &cell_normal_vectors) const
 {
                                   // convert data object to internal
                                   // data for this class. fails with
@@ -345,15 +345,16 @@ MappingQ<dim,spacedim>::fill_fe_values (
 
 template<int dim, int spacedim>
 void
-MappingQ<dim,spacedim>::fill_fe_face_values (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
-                                   const unsigned int       face_no,
-                                   const Quadrature<dim-1> &q,
-                                   typename Mapping<dim,spacedim>::InternalDataBase &mapping_data,
-                                   std::vector<Point<dim> >     &quadrature_points,
-                                   std::vector<double>          &JxW_values,
-                                   std::vector<Tensor<1,dim> >  &exterior_forms,
-                                   std::vector<Point<dim> >     &normal_vectors,
-                                   std::vector<double>          &cell_JxW_values) const
+MappingQ<dim,spacedim>::fill_fe_face_values (
+  const typename Triangulation<dim,spacedim>::cell_iterator &cell,
+  const unsigned int       face_no,
+  const Quadrature<dim-1> &q,
+  typename Mapping<dim,spacedim>::InternalDataBase &mapping_data,
+  std::vector<Point<dim> >     &quadrature_points,
+  std::vector<double>          &JxW_values,
+  std::vector<Tensor<1,dim> >  &exterior_forms,
+  std::vector<Point<dim> >     &normal_vectors,
+  std::vector<double>          &cell_JxW_values) const
 {
                                   // convert data object to internal
                                   // data for this class. fails with
@@ -1214,9 +1215,9 @@ MappingQ<dim,spacedim>::transform (
       case mapping_covariant:
            transform_covariant(input, 0, output, internal);
            return;
-//       case mapping_contravariant:
-//         transform_contravariant(input, 0, output, internal);
-//         return;
+       case mapping_contravariant:
+           transform_contravariant(input, 0, output, internal);
+           return;
       default:
            Assert(false, ExcNotImplemented());
     }
@@ -1236,9 +1237,9 @@ MappingQ<dim,spacedim>::transform (
       case mapping_covariant:
            transform_covariant(input, 0, output, internal);
            return;
-//       case mapping_contravariant:
-//         transform_contravariant(input, 0, output, internal);
-//         return;
+       case mapping_contravariant:
+           transform_contravariant(input, 0, output, internal);
+           return;
       default:
            Assert(false, ExcNotImplemented());
     }
@@ -1275,9 +1276,15 @@ MappingQ<dim,spacedim>::transform_covariant (
       else
        tensor = data->covariant.begin();    
     }
-
+  
+  Tensor<1, spacedim> auxiliary;
+  
   for (unsigned int i=0; i<output.size(); ++i)
-    contract (output[i], input[i+offset], *(tensor++));
+    {
+      for (unsigned int d=0;d<dim;++d)
+       auxiliary[d] = input[i][d];
+      contract (output[i], auxiliary, *(tensor++));
+    }
 }
 
 
@@ -1321,7 +1328,7 @@ MappingQ<dim,spacedim>::transform_covariant (
 template<int dim, int spacedim>
 void
 MappingQ<dim,spacedim>::transform_contravariant (
-  const VectorSlice<const std::vector<Tensor<1,spacedim> > > input,
+  const VectorSlice<const std::vector<Tensor<1,dim> > > input,
   const unsigned int                 offset,
   VectorSlice<std::vector<Tensor<1,spacedim> > > output,
   const typename Mapping<dim,spacedim>::InternalDataBase &mapping_data) const
@@ -1348,8 +1355,14 @@ MappingQ<dim,spacedim>::transform_contravariant (
        tensor = data->contravariant.begin();    
     }
   
+  Tensor<1, spacedim> auxiliary;
+  
   for (unsigned int i=0; i<output.size(); ++i)
-    contract (output[i], *(tensor++), input[i+offset]);
+    {
+      for (unsigned int d=0;d<dim;++d)
+       auxiliary[d] = input[i][d];
+      contract (output[i], *(tensor++), auxiliary);
+    }
 }
 
 
@@ -1357,7 +1370,7 @@ MappingQ<dim,spacedim>::transform_contravariant (
 template<int dim, int spacedim>
 void
 MappingQ<dim,spacedim>::transform_contravariant (
-  const VectorSlice<const std::vector<Tensor<2,spacedim> > > input,
+  const VectorSlice<const std::vector<Tensor<2,dim> > > input,
   const unsigned int                 offset,
   VectorSlice<std::vector<Tensor<2,spacedim> > > output,
   const typename Mapping<dim,spacedim>::InternalDataBase &mapping_data) const
index 83aed8f269cc5681a819aae7a1ff95986f36f69c..a56229b2a24212e964396ac9bcd4babc51915663 100644 (file)
@@ -1168,40 +1168,72 @@ MappingQ1<1,2>::fill_fe_subface_values (const Triangulation<1,2>::cell_iterator
 template<int dim, int spacedim>
 void
 MappingQ1<dim,spacedim>::transform (
-  const VectorSlice<const std::vector<Tensor<1,dim> > > input,
-  VectorSlice<std::vector<Tensor<1,spacedim> > > output,
-  const typename Mapping<dim,spacedim>::InternalDataBase &internal,
+  const VectorSlice<const std::vector<Tensor<1, dim> > > input,
+  VectorSlice<std::vector<Tensor<1, spacedim> > > output,
+  const typename Mapping<dim,spacedim>::InternalDataBase &mapping_data,
   const MappingType mapping_type) const
 {
+  AssertDimension (input.size(), output.size());
+  Assert (dynamic_cast<const InternalData *>(&mapping_data) != 0, 
+         ExcInternalError());
+  const InternalData &data = static_cast<const InternalData&>(mapping_data);
+
+  Tensor<1, spacedim> auxiliary;  
+  
   switch (mapping_type)
     {
       case mapping_covariant:
-           transform_covariant(input, 0, output, internal);
-           return;
-//       case mapping_contravariant:
-//         transform_contravariant(input, 0, output, internal);
-//         return;
+           if (true)
+             {
+               Assert (data.update_flags & update_covariant_transformation,
+                       typename FEValuesBase<dim>::ExcAccessToUninitializedField());
+               
+               for (unsigned int i=0; i<output.size(); ++i)
+                 {
+                   for (unsigned int d=0;d<dim;++d)
+                     auxiliary[d] = input[i][d];
+                   contract (output[i], auxiliary, data.covariant[i]);
+                 }
+               return;
+             }
+      case mapping_contravariant:
+           if (true)
+             {
+               Assert (data.update_flags & update_contravariant_transformation,
+                       typename FEValuesBase<dim>::ExcAccessToUninitializedField());
+               
+               for (unsigned int i=0; i<output.size(); ++i)
+                 {
+                   for (unsigned int d=0;d<dim;++d)
+                     auxiliary[d] = input[i][d];
+                   contract (output[i], data.contravariant[i], auxiliary);
+                 }
+               return;
+             }
       default:
            Assert(false, ExcNotImplemented());
     }
 }
 
+
 template<int dim, int spacedim>
 void
 MappingQ1<dim,spacedim>::transform (
-  const VectorSlice<const std::vector<Tensor<2,dim> > > input,
-  VectorSlice<std::vector<Tensor<2,spacedim> > > output,
+  const VectorSlice<const std::vector<Tensor<2, dim> > > input,
+  VectorSlice<std::vector<Tensor<2, spacedim> > > output,
   const typename Mapping<dim,spacedim>::InternalDataBase &internal,
   const MappingType mapping_type) const
 {
+  AssertDimension (input.size(), output.size());
+  
   switch (mapping_type)
     {
       case mapping_covariant:
            transform_covariant(input, 0, output, internal);
            return;
-//       case mapping_contravariant:
-//         transform_contravariant(input, 0, output, internal);
-//         return;
+       case mapping_contravariant:
+           transform_contravariant(input, 0, output, internal);
+           return;
       default:
            Assert(false, ExcNotImplemented());
     }
@@ -1227,82 +1259,16 @@ MappingQ1<dim,spacedim>::transform_covariant (
   Assert (data.update_flags & update_covariant_transformation,
          typename FEValuesBase<dim>::ExcAccessToUninitializedField());
 
-  Assert (output.size() + offset <= input.size(), ExcInternalError());
-
-  for (unsigned int i=0; i<output.size(); ++i)
-    contract (output[i], input[i+offset], data.covariant[i]);
-}
-
-
-#if deal_II_dimension == 1
-
-template<>
-void
-MappingQ1<1,2>::transform_covariant (
-  const VectorSlice<const std::vector<Tensor<1,1> > > input,
-  const unsigned int                 offset,
-  VectorSlice<std::vector<Tensor<1,2> > > output,
-  const Mapping<1,2>::InternalDataBase &mapping_data) const
-{
-  Assert (offset == 0, ExcInternalError());
-  AssertDimension (input.size(), output.size());
-
-                                  // ensure that the following cast is really correct:
-  Assert (dynamic_cast<const InternalData *>(&mapping_data) != 0, 
-         ExcInternalError());
-  const InternalData &data = static_cast<const InternalData&>(mapping_data);
-
-  Assert (data.update_flags & update_covariant_transformation,
-         FEValuesBase<1>::ExcAccessToUninitializedField());
-
-  Assert (output.size() + offset <= input.size(), ExcInternalError());
-
-  Tensor<1,2> auxiliary;
-  auxiliary[1]=0.;
-
-  for (unsigned int i=0; i<output.size(); ++i)
-  {
-    auxiliary[0]=input[i+offset][0];
-    contract (output[i], auxiliary, data.covariant[i]);
-  }
-}
-
-#endif
-
-#if deal_II_dimension == 2
-
-template<>
-void
-MappingQ1<2,3>::transform_covariant (
-  const VectorSlice<const std::vector<Tensor<1,2> > > input,
-  const unsigned int                 offset,
-  VectorSlice<std::vector<Tensor<1,3> > > output,
-  const Mapping<2,3>::InternalDataBase &mapping_data) const
-{
-  Assert (offset == 0, ExcInternalError());
-  AssertDimension (input.size(), output.size());
-  // ensure that the following cast is really correct:
-  Assert (dynamic_cast<const InternalData *>(&mapping_data) != 0, 
-         ExcInternalError());
-  const InternalData &data = static_cast<const InternalData&>(mapping_data);
-
-  Assert (data.update_flags & update_covariant_transformation,
-         FEValuesBase<2>::ExcAccessToUninitializedField());
-
-  Assert (output.size() + offset <= input.size(), ExcInternalError());
-
-  Tensor<1,3> auxiliary;
-  auxiliary[2]=0.;
-    
+  Tensor<1, spacedim> auxiliary;
+  
   for (unsigned int i=0; i<output.size(); ++i)
-  {
-    auxiliary[0]=input[i+offset][0];
-    auxiliary[1]=input[i+offset][1];
-    contract (output[i], auxiliary, data.covariant[i]);
-  }
+    {
+      for (unsigned int d=0;d<dim;++d)
+       auxiliary[d] = input[i][d];
+      contract (output[i], auxiliary, data.covariant[i]);
+    }
 }
 
-#endif
 
 
 template <int dim, int spacedim>
@@ -1315,16 +1281,16 @@ MappingQ1<dim, spacedim>::transform_covariant (
 {
   Assert (offset == 0, ExcInternalError());
   AssertDimension (input.size(), output.size());
-  // ensure that the following cast is really correct:
+  
+                                  // ensure that the following cast
+                                  // is really correct:
   Assert (dynamic_cast<const InternalData *>(&mapping_data) != 0, 
          ExcInternalError());
   const InternalData &data = static_cast<const InternalData&>(mapping_data);
 
   Assert (data.update_flags & update_covariant_transformation,
          typename FEValuesBase<dim>::ExcAccessToUninitializedField());
-
-  Assert (output.size() + offset <= input.size(), ExcInternalError());
-
+  
   for (unsigned int i=0; i<output.size(); ++i)
     contract (output[i], input[i+offset], data.covariant[i]);
 }
@@ -1364,7 +1330,7 @@ template<int dim, int spacedim>
 void
 MappingQ1<dim,spacedim>::
 transform_contravariant (
-  const VectorSlice<const std::vector<Tensor<1,spacedim> > > input,
+  const VectorSlice<const std::vector<Tensor<1,dim> > > input,
   const unsigned int                 offset,
   VectorSlice<std::vector<Tensor<1,spacedim> > > output,
   const typename Mapping<dim,spacedim>::InternalDataBase &mapping_data) const
@@ -1378,9 +1344,15 @@ transform_contravariant (
          typename FEValuesBase<dim>::ExcAccessToUninitializedField());
 
   Assert (output.size() + offset <= input.size(), ExcInternalError());
-
+  
+  Tensor<1, spacedim> auxiliary;
+  
   for (unsigned int i=0; i<output.size(); ++i)
-    contract (output[i], data.contravariant[i], input[i+offset]);
+    {
+      for (unsigned int d=0;d<dim;++d)
+       auxiliary[d] = input[i][d];      
+      contract (output[i], data.contravariant[i], auxiliary);
+    }
 }
 
 
@@ -1388,7 +1360,7 @@ transform_contravariant (
 template<int dim, int spacedim>
 void
 MappingQ1<dim,spacedim>::transform_contravariant (
-  const VectorSlice<const std::vector<Tensor<2,spacedim> > > input,
+  const VectorSlice<const std::vector<Tensor<2,dim> > > input,
   const unsigned int                 offset,
   VectorSlice<std::vector<Tensor<2,spacedim> > > output,
   const typename Mapping<dim,spacedim>::InternalDataBase &mapping_data) const
@@ -1408,12 +1380,43 @@ MappingQ1<dim,spacedim>::transform_contravariant (
 }
 
 
+#if deal_II_dimension == 1
+
+template <>
+void
+MappingQ1<1, 2>::transform_contravariant (
+    const VectorSlice<const std::vector<Tensor<2,1> > > ,
+    const unsigned int,
+    VectorSlice<std::vector<Tensor<2,2> > > ,
+    const Mapping<1,2>::InternalDataBase &) const
+{
+    Assert(false, ExcNotImplemented());
+}
+
+#endif
+
+#if deal_II_dimension == 2
+
+template <>
+void
+MappingQ1<2, 3>::transform_contravariant (
+    const VectorSlice<const std::vector<Tensor<2,2> > > ,
+    const unsigned int,
+    VectorSlice<std::vector<Tensor<2,3> > > ,
+    const Mapping<2,3>::InternalDataBase &) const
+{
+    Assert(false, ExcNotImplemented());
+}
+
+#endif
+
+
 
 template<int dim, int spacedim>
 Point<spacedim>
-MappingQ1<dim,spacedim>::
-transform_unit_to_real_cell (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
-                             const Point<dim>                                 &p) const
+MappingQ1<dim,spacedim>::transform_unit_to_real_cell (
+  const typename Triangulation<dim,spacedim>::cell_iterator& cell,
+  const Point<dim>& p) const
 {
                                   // Use the get_data function to
                                   // create an InternalData with data

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.