]> https://gitweb.dealii.org/ - dealii-svn.git/commitdiff
Change the way the transform_{co,contra}variant functions work, by providing them...
authorwolf <wolf@0785d39b-7218-0410-832d-ea1e28bc413d>
Mon, 7 Jun 2004 14:42:34 +0000 (14:42 +0000)
committerwolf <wolf@0785d39b-7218-0410-832d-ea1e28bc413d>
Mon, 7 Jun 2004 14:42:34 +0000 (14:42 +0000)
git-svn-id: https://svn.dealii.org/trunk@9391 0785d39b-7218-0410-832d-ea1e28bc413d

16 files changed:
deal.II/deal.II/include/fe/fe_nedelec.h
deal.II/deal.II/include/fe/fe_poly.h
deal.II/deal.II/include/fe/fe_raviart_thomas.h
deal.II/deal.II/include/fe/fe_values.h
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/fe.cc
deal.II/deal.II/source/fe/fe_nedelec.cc
deal.II/deal.II/source/fe/fe_poly.cc
deal.II/deal.II/source/fe/fe_raviart_thomas.cc
deal.II/deal.II/source/fe/fe_values.cc
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 0fd9674dc5d33cab47ba137825f1f774f8134c06..4755163d5a3492da04bb260d19321d75d24d7af2 100644 (file)
@@ -580,7 +580,7 @@ class FE_Nedelec : public FiniteElement<dim>
                                          * multiplication with the
                                          * Jacobian of the mapping.
                                          */
-       Table<2,Tensor<1,dim> > shape_values;
+       std::vector<std::vector<Tensor<1,dim> > > shape_values;
 
                                         /**
                                          * Array with shape function
@@ -600,7 +600,7 @@ class FE_Nedelec : public FiniteElement<dim>
                                          * multiplication) when
                                          * visiting an actual cell.
                                          */
-       Table<2,Tensor<2,dim> > shape_gradients;
+       std::vector<std::vector<Tensor<2,dim> > > shape_gradients;
     };
     
                                     /**
index 8a96788969a7108946699adb98f44b4614436afb..39818dcba2603e072a14587c86464ac3f743e265 100644 (file)
@@ -375,7 +375,7 @@ class FE_Poly : public FiniteElement<dim>
                                          * them over when visiting a
                                          * concrete cell.
                                          */
-       Table<2,double> shape_values;
+       std::vector<std::vector<double> > shape_values;
 
                                         /**
                                          * Array with shape function
@@ -395,7 +395,7 @@ class FE_Poly : public FiniteElement<dim>
                                          * multiplication) when
                                          * visiting an actual cell.
                                          */      
-       Table<2,Tensor<1,dim> > shape_gradients;
+       std::vector<std::vector<Tensor<1,dim> > > shape_gradients;
     };
     
                                     /**
index 60051acb769dd69b44be0bad8305e92dc84fbb02..9532dc1b4de8cec835ece2771ee9cada681dcb21 100644 (file)
@@ -540,7 +540,7 @@ class FE_RaviartThomas : public FiniteElement<dim>
                                          * multiplication with the
                                          * Jacobian of the mapping.
                                          */
-       Table<2,Tensor<1,dim> > shape_values;
+       std::vector<std::vector<Tensor<1,dim> > > shape_values;
 
                                         /**
                                          * Array with shape function
@@ -560,7 +560,7 @@ class FE_RaviartThomas : public FiniteElement<dim>
                                          * multiplication) when
                                          * visiting an actual cell.
                                          */
-       Table<2,Tensor<2,dim> > shape_gradients;
+       std::vector<std::vector<Tensor<2,dim> > > shape_gradients;
     };
     
                                     /**
index 7a411f215cc53f11276aa00552c64cc6691d593f..d1acd508cc0f85703f98995b75255129aa5afce1 100644 (file)
@@ -105,13 +105,13 @@ class FEValuesData
                                      * is the same as for the
                                      * ShapeVector data type.
                                      */
-    typedef Table<2,Tensor<1,dim> > GradientVector;
+    typedef std::vector<std::vector<Tensor<1,dim> > > GradientVector;
 
                                     /**
                                      * Likewise for second order
                                      * derivatives.
                                      */
-    typedef Table<2,Tensor<2,dim> > GradGradVector;
+    typedef std::vector<std::vector<Tensor<2,dim> > > GradGradVector;
     
                                     /**
                                      * Store the values of the shape
@@ -1342,10 +1342,10 @@ FEValuesBase<dim>::shape_grad (const unsigned int i,
          ExcAccessToUninitializedField());
   Assert (fe->is_primitive (i),
          ExcShapeFunctionNotPrimitive(i));
-  Assert (i<this->shape_gradients.n_rows(),
-         ExcIndexRange (i, 0, this->shape_gradients.n_rows()));
-  Assert (j<this->shape_gradients.n_cols(),
-         ExcIndexRange (j, 0, this->shape_gradients.n_cols()));
+  Assert (i<this->shape_gradients.size(),
+         ExcIndexRange (i, 0, this->shape_gradients.size()));
+  Assert (j<this->shape_gradients[0].size(),
+         ExcIndexRange (j, 0, this->shape_gradients[0].size()));
 
                                   // if the entire FE is primitive,
                                   // then we can take a short-cut:
@@ -1438,10 +1438,10 @@ FEValuesBase<dim>::shape_2nd_derivative (const unsigned int i,
          ExcAccessToUninitializedField());
   Assert (fe->is_primitive (i),
          ExcShapeFunctionNotPrimitive(i));
-  Assert (i<this->shape_2nd_derivatives.n_rows(),
-         ExcIndexRange (i, 0, this->shape_2nd_derivatives.n_rows()));
-  Assert (j<this->shape_2nd_derivatives.n_cols(),
-         ExcIndexRange (j, 0, this->shape_2nd_derivatives.n_cols()));
+  Assert (i<this->shape_2nd_derivatives.size(),
+         ExcIndexRange (i, 0, this->shape_2nd_derivatives.size()));
+  Assert (j<this->shape_2nd_derivatives[0].size(),
+         ExcIndexRange (j, 0, this->shape_2nd_derivatives[0].size()));
 
                                   // if the entire FE is primitive,
                                   // then we can take a short-cut:
index e6ca902b5cec7570e96669132e8e46a9220d9b50..5613229587e5615c9dde658300592774b7df5bde 100644 (file)
@@ -2,7 +2,7 @@
 //    $Id$
 //    Version: $Name$
 //
-//    Copyright (C) 2000, 2001, 2002, 2003 by the deal.II authors
+//    Copyright (C) 2000, 2001, 2002, 2003, 2004 by the deal.II authors
 //
 //    This file is subject to QPL and may not be  distributed
 //    without copyright and license information. Please refer
@@ -237,33 +237,23 @@ class Mapping : public Subscriptor
                                      * transpose if the inverse
                                      * matrix.
                                      *
-                                     * The range of vectors spanned
-                                     * by @p begin and @p end must
-                                     * have as many elements as there
-                                     * are quadrature points (not
-                                     * tested inside the function).
-                                     * Also note the different
-                                     * convention for parameters
-                                     * compared to the standard C++
-                                     * @p transform function: here,
-                                     * first destination, then source
-                                     * are specified, and the number
-                                     * of elements is determined by a
-                                     * range of destination
-                                     * vectors. This convention is
-                                     * due to the way the function is
-                                     * usually called.
-                                     *
-                                     * The vector @p src must
-                                     * contain at least as many
-                                     * elements as there are
-                                     * quadrature points.
+                                     * The list of arguments is as follows:
+                                     * we transform as many elements in the
+                                     * @p input field, starting from @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.
                                      */
     virtual
     void
-    transform_covariant (Tensor<1,dim>          *begin,
-                        Tensor<1,dim>          *end,
-                        const Tensor<1,dim>    *src,
+    transform_covariant (const std::vector<Tensor<1,dim> > &input,
+                         const unsigned int                 offset,
+                         std::vector<Tensor<1,dim> >       &output,
                         const InternalDataBase &internal) const = 0;
 
                                      /**
@@ -276,13 +266,13 @@ class Mapping : public Subscriptor
                                       *
                                       * The same applies as to the
                                       * function above regarding input
-                                      * and output ranges.
+                                      * and output arguments.
                                       */
     virtual
     void
-    transform_covariant (Tensor<2,dim>          *begin,
-                        Tensor<2,dim>          *end,
-                        const Tensor<2,dim>    *src,
+    transform_covariant (const std::vector<Tensor<2,dim> > &input,
+                         const unsigned int                 offset,
+                        std::vector<Tensor<2,dim> >       &output,
                         const InternalDataBase &internal) const = 0;
     
                                     /**
@@ -294,34 +284,24 @@ class Mapping : public Subscriptor
                                      * of the transformation from
                                      * unit to real space cell.
                                      * 
-                                     * The range of vectors spanned
-                                     * by @p begin and @p end must
-                                     * have as many elements as there
-                                     * are quadrature points (not
-                                     * tested inside the function).
-                                     * Also note the different
-                                     * convention for parameters
-                                     * compared to the standard C++
-                                     * @p transform function: here,
-                                     * first destination, then source
-                                     * are specified, and the number
-                                     * of elements is determined by a
-                                     * range of destination
-                                     * vectors. This convention is
-                                     * due to the way the function is
-                                     * usually called.
-                                     *
-                                     * The vector @p src must
-                                     * contain at least as many
-                                     * elements as there are
-                                     * quadrature points.
+                                     * The list of arguments is as follows:
+                                     * we transform as many elements in the
+                                     * @p input field, starting from @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.
                                      */
     virtual
     void
-    transform_contravariant (Tensor<1,dim>          *begin,
-                            Tensor<1,dim>          *end,
-                            const Tensor<1,dim>    *src,
-                            const InternalDataBase &internal) const = 0;
+    transform_contravariant (const std::vector<Tensor<1,dim> > &input,
+                             const unsigned int                 offset,
+                            std::vector<Tensor<1,dim> >       &output,
+                            const typename Mapping<dim>::InternalDataBase &internal) const = 0;
 
                                      /**
                                       * Transform a set of matrices
@@ -340,14 +320,14 @@ class Mapping : public Subscriptor
                                       *
                                       * The same applies as to the
                                       * function above regarding input
-                                      * and output ranges.
+                                      * and output arguments.
                                       */
-    virtual
-    void
-    transform_contravariant (Tensor<2,dim>          *begin,
-                             Tensor<2,dim>          *end,
-                             const Tensor<2,dim>    *src,
-                             const InternalDataBase &internal) const = 0;
+    
+    virtual void
+    transform_contravariant (const std::vector<Tensor<2,dim> > &intput,
+                             const unsigned int                 offset,
+                            std::vector<Tensor<2,dim> > &output,
+                            const typename Mapping<dim>::InternalDataBase &internal) const = 0;
     
                                     /**
                                      * Indicate fields to be updated
index 017e52412943b3c002ea29779ee75527fbc30d5a..b174e0969f583b6add4d649de1b668a1e6448d42 100644 (file)
@@ -80,28 +80,44 @@ class MappingCartesian : public Mapping<dim>
                            std::vector<Tensor<1,dim> >        &boundary_form,
                            std::vector<Point<dim> >        &normal_vectors) const ;
 
+                                    /**
+                                     * Implementation of the
+                                     * interface in Mapping.
+                                     */
     virtual void
-    transform_covariant (Tensor<1,dim>          *begin,
-                        Tensor<1,dim>          *end,
-                        const Tensor<1,dim>    *src,
+    transform_covariant (const std::vector<Tensor<1,dim> > &input,
+                         const unsigned int                 offset,
+                         std::vector<Tensor<1,dim> > &output,
                         const typename Mapping<dim>::InternalDataBase &internal) const;
 
+                                    /**
+                                     * Implementation of the
+                                     * interface in Mapping.
+                                     */
     virtual void
-    transform_covariant (Tensor<2,dim>          *begin,
-                        Tensor<2,dim>          *end,
-                        const Tensor<2,dim>    *src,
+    transform_covariant (const std::vector<Tensor<2,dim> > &input,
+                         const unsigned int                 offset,
+                         std::vector<Tensor<2,dim> >       &output,
                         const typename Mapping<dim>::InternalDataBase &internal) const;
     
+                                    /**
+                                     * Implementation of the
+                                     * interface in Mapping.
+                                     */
     virtual void
-    transform_contravariant (Tensor<1,dim>          *begin,
-                            Tensor<1,dim>          *end,
-                            const Tensor<1,dim>    *src,
+    transform_contravariant (const std::vector<Tensor<1,dim> > &input,
+                             const unsigned int                 offset,
+                            std::vector<Tensor<1,dim> >       &output,
                             const typename Mapping<dim>::InternalDataBase &internal) const;
     
+                                    /**
+                                     * Implementation of the
+                                     * interface in Mapping.
+                                     */
     virtual void
-    transform_contravariant (Tensor<2,dim>          *begin,
-                            Tensor<2,dim>          *end,
-                            const Tensor<2,dim>    *src,
+    transform_contravariant (const std::vector<Tensor<2,dim> > &input,
+                             const unsigned int                 offset,
+                            std::vector<Tensor<2,dim> >       &output,
                             const typename Mapping<dim>::InternalDataBase &internal) const;
 
     virtual Point<dim>
index e5e439ccaa4a3ff57d2ff689a4ff0baa972a1dce..100b4fc95285a56ba44881e723d531fa62391c9f 100644 (file)
@@ -82,9 +82,9 @@ class MappingQ : public MappingQ1<dim>
                                      * interface in Mapping.
                                      */
     virtual void
-    transform_covariant (Tensor<1,dim>          *begin,
-                        Tensor<1,dim>          *end,
-                        const Tensor<1,dim>    *src,
+    transform_covariant (const std::vector<Tensor<1,dim> > &input,
+                         const unsigned int                 offset,
+                         std::vector<Tensor<1,dim> > &output,
                         const typename Mapping<dim>::InternalDataBase &internal) const;
     
                                     /**
@@ -92,9 +92,9 @@ class MappingQ : public MappingQ1<dim>
                                      * interface in Mapping.
                                      */
     virtual void
-    transform_covariant (Tensor<2,dim>          *begin,
-                        Tensor<2,dim>          *end,
-                        const Tensor<2,dim>    *src,
+    transform_covariant (const std::vector<Tensor<2,dim> > &input,
+                         const unsigned int                 offset,
+                         std::vector<Tensor<2,dim> >       &output,
                         const typename Mapping<dim>::InternalDataBase &internal) const;
     
                                     /**
@@ -102,9 +102,9 @@ class MappingQ : public MappingQ1<dim>
                                      * interface in Mapping.
                                      */
     virtual void
-    transform_contravariant (Tensor<1,dim>          *begin,
-                            Tensor<1,dim>          *end,
-                            const Tensor<1,dim>    *src,
+    transform_contravariant (const std::vector<Tensor<1,dim> > &input,
+                             const unsigned int                 offset,
+                            std::vector<Tensor<1,dim> >       &output,
                             const typename Mapping<dim>::InternalDataBase &internal) const;    
 
                                     /**
@@ -112,9 +112,9 @@ class MappingQ : public MappingQ1<dim>
                                      * interface in Mapping.
                                      */
     virtual void
-    transform_contravariant (Tensor<2,dim>          *begin,
-                            Tensor<2,dim>          *end,
-                            const Tensor<2,dim>    *src,
+    transform_contravariant (const std::vector<Tensor<2,dim> > &intput,
+                             const unsigned int                 offset,
+                            std::vector<Tensor<2,dim> >       &output,
                             const typename Mapping<dim>::InternalDataBase &internal) const;    
     
                                     /**
index acc75f0021a28e8caafb016746e7c6dcffbb07df..c67cd38f121a8ab6403b9a19fd0cb053aef35925 100644 (file)
@@ -86,9 +86,9 @@ class MappingQ1 : public Mapping<dim>
                                      * Mapping.
                                      */
     virtual void
-    transform_covariant (Tensor<1,dim>          *begin,
-                        Tensor<1,dim>          *end,
-                        const Tensor<1,dim>    *src,
+    transform_covariant (const std::vector<Tensor<1,dim> > &input,
+                         const unsigned int                 offset,
+                         std::vector<Tensor<1,dim> > &output,
                         const typename Mapping<dim>::InternalDataBase &internal) const;
     
                                     /**
@@ -96,9 +96,9 @@ class MappingQ1 : public Mapping<dim>
                                      * Mapping.
                                      */
     virtual void
-    transform_covariant (Tensor<2,dim>          *begin,
-                        Tensor<2,dim>          *end,
-                        const Tensor<2,dim>    *src,
+    transform_covariant (const std::vector<Tensor<2,dim> > &input,
+                         const unsigned int                 offset,
+                         std::vector<Tensor<2,dim> >       &output,
                         const typename Mapping<dim>::InternalDataBase &internal) const;
     
                                     /**
@@ -106,9 +106,9 @@ class MappingQ1 : public Mapping<dim>
                                      * Mapping.
                                      */
     virtual void
-    transform_contravariant (Tensor<1,dim>          *begin,
-                            Tensor<1,dim>          *end,
-                            const Tensor<1,dim>    *src,
+    transform_contravariant (const std::vector<Tensor<1,dim> > &input,
+                             const unsigned int                 offset,
+                            std::vector<Tensor<1,dim> >       &output,
                             const typename Mapping<dim>::InternalDataBase &internal) const;
     
                                     /**
@@ -116,9 +116,9 @@ class MappingQ1 : public Mapping<dim>
                                      * Mapping.
                                      */
     virtual void
-    transform_contravariant (Tensor<2,dim>          *begin,
-                            Tensor<2,dim>          *end,
-                            const Tensor<2,dim>    *src,
+    transform_contravariant (const std::vector<Tensor<2,dim> > &intput,
+                             const unsigned int                 offset,
+                            std::vector<Tensor<2,dim> > &output,
                             const typename Mapping<dim>::InternalDataBase &internal) const;
     
                                     /**
@@ -305,12 +305,12 @@ class MappingQ1 : public Mapping<dim>
                                          *
                                          * Filled once.
                                          */
-        Table<2,Tensor<1,dim> > unit_tangentials;
+        std::vector<std::vector<Tensor<1,dim> > > unit_tangentials;
        
                                         /**
-                                         * Auxuliary vectors for internal use.
+                                         * Auxiliary vectors for internal use.
                                          */
-        Table<2,Tensor<1,dim> > aux;
+        std::vector<std::vector<Tensor<1,dim> > > aux;
 
                                         /**
                                          * Stores the support points of
index bb210972e0be60a63c279a072661937f04c9ede0..a5f0fdd22a5164c1dd3096bf0215a5d2c9f3722b 100644 (file)
@@ -478,10 +478,10 @@ compute_2nd (const Mapping<dim>                   &mapping,
                        n_nonzero_components_table.end(),
                        0U);
   
-  Assert (data.shape_2nd_derivatives.n_rows() == total_nonzero_components,
+  Assert (data.shape_2nd_derivatives.size() == total_nonzero_components,
          ExcInternalError());
                                   // Number of quadrature points
-  const unsigned int n_q_points = data.shape_2nd_derivatives.n_cols();
+  const unsigned int n_q_points = data.shape_2nd_derivatives[0].size();
 
                                   // first reinit the fe_values
                                   // objects used for the finite
@@ -496,7 +496,8 @@ compute_2nd (const Mapping<dim>                   &mapping,
                                   // quotients of gradients in each
                                   // direction (first index) and at
                                   // all q-points (second index)
-  Table<2,Tensor<1,dim> >    diff_quot (dim, n_q_points);
+  std::vector<std::vector<Tensor<1,dim> > >
+    diff_quot (dim, std::vector<Tensor<1,dim> > (n_q_points));
   std::vector<Tensor<1,dim> > diff_quot2 (n_q_points);
 
                                   // for all nonzero components of
@@ -588,13 +589,13 @@ compute_2nd (const Mapping<dim>                   &mapping,
             Assert (diff_quot2.size() <=
                     diff_quot[d].size(),
                     ExcInternalError());
-            mapping.transform_covariant (&*diff_quot2.begin(), &*diff_quot2.end(),
-                                         diff_quot[d].begin(),
+            mapping.transform_covariant (diff_quot[d], 0, diff_quot2,
                                          mapping_internal);
             
             for (unsigned int q=0; q<n_q_points; ++q)
               for (unsigned int d1=0; d1<dim; ++d1)
-                data.shape_2nd_derivatives[total_index][q][d][d1] = diff_quot2[q][d1];
+                data.shape_2nd_derivatives[total_index][q][d][d1]
+                  = diff_quot2[q][d1];
           }
       }
 }
index de12d5955cc6d97e467c5651d1c1ddf28d4186dc..4ae45426a6af70fbb872475795c89bc5092e00f3 100644 (file)
@@ -2,7 +2,7 @@
 //    $Id$
 //    Version: $Name$
 //
-//    Copyright (C) 2002, 2003 by the deal.II authors
+//    Copyright (C) 2002, 2003, 2004 by the deal.II authors
 //
 //    This file is subject to QPL and may not be  distributed
 //    without copyright and license information. Please refer
@@ -931,10 +931,12 @@ FE_Nedelec<dim>::get_data (const UpdateFlags      update_flags,
                                   // necessary. otherwise, don't
                                   // allocate memory
    if (flags & update_values)
-     data->shape_values.reinit (this->dofs_per_cell, n_q_points);
+     data->shape_values.resize (this->dofs_per_cell,
+                                std::vector<Tensor<1,dim> > (n_q_points));
 
    if (flags & update_gradients)
-     data->shape_gradients.reinit (this->dofs_per_cell, n_q_points);
+     data->shape_gradients.resize (this->dofs_per_cell,
+                                   std::vector<Tensor<2,dim> > (n_q_points));
 
                                   // if second derivatives through
                                   // finite differencing is required,
@@ -1021,9 +1023,8 @@ FE_Nedelec<dim>::fill_fe_values (const Mapping<dim>                   &mapping,
                                           // values...
          Assert (fe_data.shape_values[k].size() == n_q_points,
                  ExcInternalError());
-         mapping.transform_covariant(&*shape_values.begin(),
-                                      &*shape_values.end(),
-                                      fe_data.shape_values[k].begin(),
+         mapping.transform_covariant(fe_data.shape_values[k], 0,
+                                      shape_values,
                                       mapping_data);
 
                                           // then copy over to target:
@@ -1039,9 +1040,9 @@ FE_Nedelec<dim>::fill_fe_values (const Mapping<dim>                   &mapping,
       std::vector<Tensor<2,dim> > shape_grads1 (n_q_points);
       std::vector<Tensor<2,dim> > shape_grads2 (n_q_points);
 
-      Assert (data.shape_gradients.n_rows() == this->dofs_per_cell * dim,
+      Assert (data.shape_gradients.size() == this->dofs_per_cell * dim,
              ExcInternalError());
-      Assert (data.shape_gradients.n_cols() == n_q_points,
+      Assert (data.shape_gradients[0].size() == n_q_points,
              ExcInternalError());
 
                                        // loop over all shape
@@ -1072,17 +1073,14 @@ FE_Nedelec<dim>::fill_fe_values (const Mapping<dim>                   &mapping,
          Assert (fe_data.shape_gradients[k].size() == n_q_points,
                  ExcInternalError());
                                            // do first transformation
-         mapping.transform_covariant(&*shape_grads1.begin(),
-                                      &*shape_grads1.end(),
-                                      fe_data.shape_gradients[k].begin(),
+         mapping.transform_covariant(fe_data.shape_gradients[k], 0,
+                                      shape_grads1,
                                       mapping_data);
                                            // 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_grads1.begin(),
-                                      &*shape_grads1.end(),
-                                      &*shape_grads2.begin(),
+         mapping.transform_covariant(shape_grads2, 0, shape_grads1,
                                       mapping_data);
                                            // transpose back
           for (unsigned int q=0; q<n_q_points; ++q)
@@ -1149,7 +1147,7 @@ FE_Nedelec<dim>::fill_fe_face_values (const Mapping<dim>                   &mapp
                                        // check size of array. in 3d,
                                        // we have faces oriented both
                                        // ways
-      Assert (fe_data.shape_values.n_cols() ==
+      Assert (fe_data.shape_values[0].size() ==
               GeometryInfo<dim>::faces_per_cell * n_q_points *
               (dim == 3 ? 2 : 1),
               ExcInternalError());
@@ -1165,9 +1163,8 @@ FE_Nedelec<dim>::fill_fe_face_values (const Mapping<dim>                   &mapp
        {
                                           // first transform shape
                                           // values...
-         mapping.transform_covariant(&*shape_values.begin(),
-                                      &*shape_values.end(),
-                                      fe_data.shape_values[k].begin()+offset,
+         mapping.transform_covariant(fe_data.shape_values[k], offset,
+                                      shape_values,
                                       mapping_data);
 
                                           // then copy over to target:
@@ -1183,7 +1180,7 @@ FE_Nedelec<dim>::fill_fe_face_values (const Mapping<dim>                   &mapp
                                        // check size of array. in 3d,
                                        // we have faces oriented both
                                        // ways
-      Assert (fe_data.shape_gradients.n_cols() ==
+      Assert (fe_data.shape_gradients[0].size() ==
               GeometryInfo<dim>::faces_per_cell * n_q_points *
               (dim == 3 ? 2 : 1),
               ExcInternalError());
@@ -1191,9 +1188,9 @@ FE_Nedelec<dim>::fill_fe_face_values (const Mapping<dim>                   &mapp
       std::vector<Tensor<2,dim> > shape_grads1 (n_q_points);
       std::vector<Tensor<2,dim> > shape_grads2 (n_q_points);
 
-      Assert (data.shape_gradients.n_rows() == this->dofs_per_cell * dim,
+      Assert (data.shape_gradients.size() == this->dofs_per_cell * dim,
              ExcInternalError());
-      Assert (data.shape_gradients.n_cols() == n_q_points,
+      Assert (data.shape_gradients[0].size() == n_q_points,
              ExcInternalError());
 
                                        // loop over all shape
@@ -1223,17 +1220,14 @@ FE_Nedelec<dim>::fill_fe_face_values (const Mapping<dim>                   &mapp
                                            // little in between
                                            // 
                                            // do first transformation
-         mapping.transform_covariant(&*shape_grads1.begin(),
-                                      &*shape_grads1.end(),
-                                      fe_data.shape_gradients[k].begin()+offset,
+         mapping.transform_covariant(fe_data.shape_gradients[k], offset,
+                                      shape_grads1,
                                       mapping_data);
                                            // 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_grads1.begin(),
-                                      &*shape_grads1.end(),
-                                      &*shape_grads2.begin(),
+         mapping.transform_covariant(shape_grads2, 0, shape_grads1,
                                       mapping_data);
                                            // transpose back
           for (unsigned int q=0; q<n_q_points; ++q)
@@ -1296,7 +1290,7 @@ FE_Nedelec<dim>::fill_fe_subface_values (const Mapping<dim>                   &m
                                   // number of conversions
   if (flags & update_values)
     {
-      Assert (fe_data.shape_values.n_cols() ==
+      Assert (fe_data.shape_values[0].size() ==
              GeometryInfo<dim>::subfaces_per_face *
               GeometryInfo<dim>::faces_per_cell *
              n_q_points,
@@ -1313,9 +1307,8 @@ FE_Nedelec<dim>::fill_fe_subface_values (const Mapping<dim>                   &m
        {
                                           // first transform shape
                                           // values...
-         mapping.transform_covariant(&*shape_values.begin(),
-                                      &*shape_values.end(),
-                                      fe_data.shape_values[k].begin()+offset,
+         mapping.transform_covariant(fe_data.shape_values[k], offset,
+                                      shape_values,
                                       mapping_data);
 
                                           // then copy over to target:
@@ -1328,7 +1321,7 @@ FE_Nedelec<dim>::fill_fe_subface_values (const Mapping<dim>                   &m
       
   if (flags & update_gradients)
     {
-      Assert (fe_data.shape_gradients.n_cols() ==
+      Assert (fe_data.shape_gradients.size() ==
               GeometryInfo<dim>::faces_per_cell *
              GeometryInfo<dim>::subfaces_per_face *
              n_q_points,
@@ -1337,9 +1330,9 @@ FE_Nedelec<dim>::fill_fe_subface_values (const Mapping<dim>                   &m
       std::vector<Tensor<2,dim> > shape_grads1 (n_q_points);
       std::vector<Tensor<2,dim> > shape_grads2 (n_q_points);
 
-      Assert (data.shape_gradients.n_rows() == this->dofs_per_cell * dim,
+      Assert (data.shape_gradients.size() == this->dofs_per_cell * dim,
              ExcInternalError());
-      Assert (data.shape_gradients.n_cols() == n_q_points,
+      Assert (data.shape_gradients[0].size() == n_q_points,
              ExcInternalError());
 
                                        // loop over all shape
@@ -1369,17 +1362,14 @@ FE_Nedelec<dim>::fill_fe_subface_values (const Mapping<dim>                   &m
                                            // little in between
                                            // 
                                            // do first transformation
-         mapping.transform_covariant(&*shape_grads1.begin(),
-                                      &*shape_grads1.end(),
-                                      fe_data.shape_gradients[k].begin()+offset,
+         mapping.transform_covariant(fe_data.shape_gradients[k], offset,
+                                      shape_grads1,
                                       mapping_data);
                                            // 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_grads1.begin(),
-                                      &*shape_grads1.end(),
-                                      &*shape_grads2.begin(),
+         mapping.transform_covariant(shape_grads2, 0, shape_grads1,
                                       mapping_data);
                                            // transpose back
           for (unsigned int q=0; q<n_q_points; ++q)
index 00262b4d2757c130f713ae0cd6ac55b89a9a46e6..83e55ce5faa92a9f3434c1aad734fe17a601f013 100644 (file)
@@ -183,15 +183,15 @@ FE_Poly<POLY,dim>::get_data (const UpdateFlags      update_flags,
   if (flags & update_values)
     {
       values.resize (this->dofs_per_cell);
-      data->shape_values.reinit (this->dofs_per_cell,
-                                n_q_points);
+      data->shape_values.resize (this->dofs_per_cell,
+                                std::vector<double> (n_q_points));
     }
 
   if (flags & update_gradients)
     {
       grads.resize (this->dofs_per_cell);
-      data->shape_gradients.reinit (this->dofs_per_cell,
-                                   n_q_points);
+      data->shape_gradients.resize (this->dofs_per_cell,
+                                   std::vector<Tensor<1,dim> > (n_q_points));
     }
 
                                   // if second derivatives through
@@ -235,11 +235,11 @@ FE_Poly<POLY,dim>::get_data (const UpdateFlags      update_flags,
 template <class POLY, int dim>
 void
 FE_Poly<POLY,dim>::fill_fe_values (const Mapping<dim>                   &mapping,
-                          const typename DoFHandler<dim>::cell_iterator &cell,
-                          const Quadrature<dim>                &quadrature,
-                          typename Mapping<dim>::InternalDataBase &mapping_data,
-                          typename Mapping<dim>::InternalDataBase &fedata,
-                          FEValuesData<dim>                    &data) const
+                                   const typename DoFHandler<dim>::cell_iterator &cell,
+                                   const Quadrature<dim>                &quadrature,
+                                   typename Mapping<dim>::InternalDataBase &mapping_data,
+                                   typename Mapping<dim>::InternalDataBase &fedata,
+                                   FEValuesData<dim>                    &data) const
 {
                                   // convert data object to internal
                                   // data for this class. fails with
@@ -260,11 +260,10 @@ FE_Poly<POLY,dim>::fill_fe_values (const Mapping<dim>                   &mapping
          Assert (data.shape_gradients[k].size() <=
                  fe_data.shape_gradients[k].size(),
                  ExcInternalError());    
-         mapping.transform_covariant(data.shape_gradients[k].begin(),
-                                     data.shape_gradients[k].end(),
-                                     fe_data.shape_gradients[k].begin(),
+         mapping.transform_covariant(fe_data.shape_gradients[k], 0,
+                                      data.shape_gradients[k],
                                      mapping_data);
-       };
+       }
     }
 
   const typename QProjector<dim>::DataSetDescriptor dsd;
@@ -313,11 +312,10 @@ FE_Poly<POLY,dim>::fill_fe_face_values (const Mapping<dim>                   &ma
          Assert (data.shape_gradients[k].size() + offset <=
                  fe_data.shape_gradients[k].size(),
                  ExcInternalError());
-         mapping.transform_covariant(data.shape_gradients[k].begin(),
-                                     data.shape_gradients[k].end(),
-                                     fe_data.shape_gradients[k].begin()+offset,
+         mapping.transform_covariant(fe_data.shape_gradients[k], offset,
+                                      data.shape_gradients[k],
                                      mapping_data);
-       };
+       }
     }
 
   if (flags & update_second_derivatives)
@@ -365,11 +363,10 @@ FE_Poly<POLY,dim>::fill_fe_subface_values (const Mapping<dim>
          Assert (data.shape_gradients[k].size() + offset <=
                  fe_data.shape_gradients[k].size(),
                  ExcInternalError());
-         mapping.transform_covariant(data.shape_gradients[k].begin(),
-                                     data.shape_gradients[k].end(),
-                                     fe_data.shape_gradients[k].begin()+offset,
+         mapping.transform_covariant(fe_data.shape_gradients[k], offset,
+                                      data.shape_gradients[k],
                                      mapping_data);
-       };
+       }
     }
   
   if (flags & update_second_derivatives)
index a7629aca33f256c43667ab03991dce0f3206811e..e045278fe1e9b5cce599f5b9574531e99320cf42 100644 (file)
@@ -2,7 +2,7 @@
 //    $Id$
 //    Version: $Name$
 //
-//    Copyright (C) 2003 by the deal.II authors
+//    Copyright (C) 2003, 2004 by the deal.II authors
 //
 //    This file is subject to QPL and may not be  distributed
 //    without copyright and license information. Please refer
@@ -1445,10 +1445,12 @@ FE_RaviartThomas<dim>::get_data (const UpdateFlags      update_flags,
                                   // necessary. otherwise, don't
                                   // allocate memory
   if (flags & update_values)
-    data->shape_values.reinit (this->dofs_per_cell, n_q_points);
+    data->shape_values.resize (this->dofs_per_cell,
+                               std::vector<Tensor<1,dim> > (n_q_points));
 
   if (flags & update_gradients)
-    data->shape_gradients.reinit (this->dofs_per_cell, n_q_points);
+    data->shape_gradients.resize (this->dofs_per_cell,
+                                  std::vector<Tensor<2,dim> > (n_q_points));
 
                                   // if second derivatives through
                                   // finite differencing is required,
@@ -1535,9 +1537,8 @@ FE_RaviartThomas<dim>::fill_fe_values (const Mapping<dim>                   &map
                                           // values...
          Assert (fe_data.shape_values[k].size() == n_q_points,
                  ExcInternalError());
-         mapping.transform_covariant(&*shape_values.begin(),
-                                      &*shape_values.end(),
-                                      fe_data.shape_values[k].begin(),
+         mapping.transform_covariant(fe_data.shape_values[k], 0,
+                                      shape_values,
                                       mapping_data);
 
                                           // then copy over to target:
@@ -1553,9 +1554,9 @@ FE_RaviartThomas<dim>::fill_fe_values (const Mapping<dim>                   &map
       std::vector<Tensor<2,dim> > shape_grads1 (n_q_points);
       std::vector<Tensor<2,dim> > shape_grads2 (n_q_points);
 
-      Assert (data.shape_gradients.n_rows() == this->dofs_per_cell * dim,
+      Assert (data.shape_gradients.size() == this->dofs_per_cell * dim,
              ExcInternalError());
-      Assert (data.shape_gradients.n_cols() == n_q_points,
+      Assert (data.shape_gradients[0].size() == n_q_points,
              ExcInternalError());
 
                                        // loop over all shape
@@ -1586,17 +1587,14 @@ FE_RaviartThomas<dim>::fill_fe_values (const Mapping<dim>                   &map
          Assert (fe_data.shape_gradients[k].size() == n_q_points,
                  ExcInternalError());
                                            // do first transformation
-         mapping.transform_covariant(&*shape_grads1.begin(),
-                                      &*shape_grads1.end(),
-                                      fe_data.shape_gradients[k].begin(),
+         mapping.transform_covariant(fe_data.shape_gradients[k], 0,
+                                      shape_grads1,
                                       mapping_data);
                                            // 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_grads1.begin(),
-                                      &*shape_grads1.end(),
-                                      &*shape_grads2.begin(),
+         mapping.transform_covariant(shape_grads2, 0, shape_grads1,
                                       mapping_data);
                                            // transpose back
           for (unsigned int q=0; q<n_q_points; ++q)
@@ -1660,7 +1658,7 @@ FE_RaviartThomas<dim>::fill_fe_face_values (const Mapping<dim>
                                   // number of conversions
   if (flags & update_values)
     {
-      Assert (fe_data.shape_values.n_cols() ==
+      Assert (fe_data.shape_values.size() ==
               GeometryInfo<dim>::faces_per_cell * n_q_points,
               ExcInternalError());
       
@@ -1675,9 +1673,8 @@ FE_RaviartThomas<dim>::fill_fe_face_values (const Mapping<dim>
        {
                                           // first transform shape
                                           // values...
-         mapping.transform_covariant(&*shape_values.begin(),
-                                      &*shape_values.end(),
-                                      fe_data.shape_values[k].begin()+offset,
+         mapping.transform_covariant(fe_data.shape_values[k], offset,
+                                      shape_values,
                                       mapping_data);
 
                                           // then copy over to target:
@@ -1690,16 +1687,16 @@ FE_RaviartThomas<dim>::fill_fe_face_values (const Mapping<dim>
       
   if (flags & update_gradients)
     {
-      Assert (fe_data.shape_gradients.n_cols() ==
+      Assert (fe_data.shape_gradients.size() ==
               GeometryInfo<dim>::faces_per_cell * n_q_points,
               ExcInternalError());
 
       std::vector<Tensor<2,dim> > shape_grads1 (n_q_points);
       std::vector<Tensor<2,dim> > shape_grads2 (n_q_points);
 
-      Assert (data.shape_gradients.n_rows() == this->dofs_per_cell * dim,
+      Assert (data.shape_gradients.size() == this->dofs_per_cell * dim,
              ExcInternalError());
-      Assert (data.shape_gradients.n_cols() == n_q_points,
+      Assert (data.shape_gradients[0].size() == n_q_points,
              ExcInternalError());
 
                                        // loop over all shape
@@ -1729,17 +1726,14 @@ FE_RaviartThomas<dim>::fill_fe_face_values (const Mapping<dim>
                                            // little in between
                                            // 
                                            // do first transformation
-         mapping.transform_covariant(&*shape_grads1.begin(),
-                                      &*shape_grads1.end(),
-                                      fe_data.shape_gradients[k].begin()+offset,
+         mapping.transform_covariant(fe_data.shape_gradients[k], offset,
+                                      shape_grads1,
                                       mapping_data);
                                            // 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_grads1.begin(),
-                                      &*shape_grads1.end(),
-                                      &*shape_grads2.begin(),
+         mapping.transform_covariant(shape_grads2, 0, shape_grads1,
                                       mapping_data);
                                            // transpose back
           for (unsigned int q=0; q<n_q_points; ++q)
@@ -1802,7 +1796,7 @@ FE_RaviartThomas<dim>::fill_fe_subface_values (const Mapping<dim>
                                   // number of conversions
   if (flags & update_values)
     {
-      Assert (fe_data.shape_values.n_cols() ==
+      Assert (fe_data.shape_values[0].size() ==
               GeometryInfo<dim>::faces_per_cell *
              GeometryInfo<dim>::subfaces_per_face *
              n_q_points,
@@ -1819,9 +1813,8 @@ FE_RaviartThomas<dim>::fill_fe_subface_values (const Mapping<dim>
        {
                                           // first transform shape
                                           // values...
-         mapping.transform_covariant(&*shape_values.begin(),
-                                      &*shape_values.end(),
-                                      fe_data.shape_values[k].begin()+offset,
+         mapping.transform_covariant(fe_data.shape_values[k], offset,
+                                      shape_values,
                                       mapping_data);
 
                                           // then copy over to target:
@@ -1834,7 +1827,7 @@ FE_RaviartThomas<dim>::fill_fe_subface_values (const Mapping<dim>
       
   if (flags & update_gradients)
     {
-      Assert (fe_data.shape_gradients.n_cols() ==
+      Assert (fe_data.shape_gradients.size() ==
               GeometryInfo<dim>::faces_per_cell *
              GeometryInfo<dim>::subfaces_per_face *
              n_q_points,
@@ -1843,9 +1836,9 @@ FE_RaviartThomas<dim>::fill_fe_subface_values (const Mapping<dim>
       std::vector<Tensor<2,dim> > shape_grads1 (n_q_points);
       std::vector<Tensor<2,dim> > shape_grads2 (n_q_points);
 
-      Assert (data.shape_gradients.n_rows() == this->dofs_per_cell * dim,
+      Assert (data.shape_gradients.size() == this->dofs_per_cell * dim,
              ExcInternalError());
-      Assert (data.shape_gradients.n_cols() == n_q_points,
+      Assert (data.shape_gradients[0].size() == n_q_points,
              ExcInternalError());
 
                                        // loop over all shape
@@ -1875,17 +1868,14 @@ FE_RaviartThomas<dim>::fill_fe_subface_values (const Mapping<dim>
                                            // little in between
                                            // 
                                            // do first transformation
-         mapping.transform_covariant(&*shape_grads1.begin(),
-                                      &*shape_grads1.end(),
-                                      fe_data.shape_gradients[k].begin()+offset,
+         mapping.transform_covariant(fe_data.shape_gradients[k], offset,
+                                      shape_grads1,
                                       mapping_data);
                                            // 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_grads1.begin(),
-                                      &*shape_grads1.end(),
-                                      &*shape_grads2.begin(),
+         mapping.transform_covariant(shape_grads2, 0, shape_grads1,
                                       mapping_data);
                                            // transpose back
           for (unsigned int q=0; q<n_q_points; ++q)
index fdead3292753ef942b8a7ede59c217420b6c8a98..bc65ab2486c5d21536ca39aa71ba393e25d817ff 100644 (file)
@@ -66,12 +66,12 @@ FEValuesData<dim>::initialize (const unsigned int        n_quadrature_points,
                              n_quadrature_points);
 
   if (flags & update_gradients)
-    this->shape_gradients.reinit(n_nonzero_shape_components,
-                                n_quadrature_points);
+    this->shape_gradients.resize (n_nonzero_shape_components,
+                                  std::vector<Tensor<1,dim> > (n_quadrature_points));
 
   if (flags & update_second_derivatives)
-    this->shape_2nd_derivatives.reinit(n_nonzero_shape_components,
-                                      n_quadrature_points);
+    this->shape_2nd_derivatives.resize (n_nonzero_shape_components,
+                                        std::vector<Tensor<2,dim> > (n_quadrature_points));
   
   if (flags & update_q_points)
     this->quadrature_points.resize(n_quadrature_points);
index 447e33623b6c0ed6c9d0b20876e21856ca21b612..587cfa98ad74a5434a859437d04153c535cdd59e 100644 (file)
@@ -432,34 +432,33 @@ MappingCartesian<1>::fill_fe_subface_values (const DoFHandler<1>::cell_iterator
 
 template <int dim>
 void
-MappingCartesian<dim>::transform_covariant (Tensor<1,dim>       *begin,
-                                           Tensor<1,dim>       *end,
-                                           const Tensor<1,dim> *src,
-                                           const typename Mapping<dim>::InternalDataBase &mapping_data) const
+MappingCartesian<dim>::
+transform_covariant (const std::vector<Tensor<1,dim> > &input,
+                     const unsigned int                 offset,
+                     std::vector<Tensor<1,dim> >       &output,
+                     const typename Mapping<dim>::InternalDataBase &mapping_data) const
 {
   const InternalData &data = dynamic_cast<const InternalData&> (mapping_data);
 
   Assert (data.update_flags & update_covariant_transformation,
          ExcAccessToUninitializedField());
+
+  Assert (output.size() + offset <= input.size(), ExcInternalError());
   
                                   // simply scale by inverse Jacobian
                                   // (which is diagonal here)
-  while (begin!=end)
-    {
-      for (unsigned int d=0;d<dim;++d)
-       (*begin)[d] = (*src)[d]/data.length[d];
-      ++begin;
-      ++src;
-    }
+  for (unsigned int i=0; i<output.size(); ++i)
+    for (unsigned int d=0;d<dim;++d)
+      output[i][d] = input[i+offset][d]/data.length[d];
 }
 
 
 
 template <int dim>
 void
-MappingCartesian<dim>::transform_covariant (Tensor<2,dim>       *begin,
-                                           Tensor<2,dim>       *end,
-                                           const Tensor<2,dim> *src,
+MappingCartesian<dim>::transform_covariant (const std::vector<Tensor<2,dim> > &input,
+                                            const unsigned int                 offset,
+                                           std::vector<Tensor<2,dim> >       &output,
                                            const typename Mapping<dim>::InternalDataBase &mapping_data) const
 {
   const InternalData &data = dynamic_cast<const InternalData&> (mapping_data);
@@ -467,26 +466,24 @@ MappingCartesian<dim>::transform_covariant (Tensor<2,dim>       *begin,
   Assert (data.update_flags & update_covariant_transformation,
          ExcAccessToUninitializedField());
   
+  Assert (output.size() + offset <= input.size(), ExcInternalError());
+  
                                   // simply scale by inverse Jacobian
                                   // (which is diagonal here)
-  while (begin!=end)
-    {
-      for (unsigned int d=0; d<dim; ++d)
-        for (unsigned int p=0; p<dim; ++p)
-       (*begin)[d][p] = (*src)[d][p] / data.length[p];
-      ++begin;
-      ++src;
-    }
+  for (unsigned int i=0; i<output.size(); ++i)
+    for (unsigned int d=0; d<dim; ++d)
+      for (unsigned int p=0; p<dim; ++p)
+      output[i][d][p] = input[i+offset][d][p]/data.length[p];
 }
 
 
 
 template <int dim>
 void
-MappingCartesian<dim>::transform_contravariant (Tensor<1,dim>       *begin,
-                                               Tensor<1,dim>       *end,
-                                               const Tensor<1,dim> *src,
-  const typename Mapping<dim>::InternalDataBase &mapping_data) const
+MappingCartesian<dim>::transform_contravariant (const std::vector<Tensor<1,dim> > &input,
+                                                const unsigned int                 offset,
+                                                std::vector<Tensor<1,dim> >       &output,
+                                                const typename Mapping<dim>::InternalDataBase &mapping_data) const
 {
                                   // convert data object to internal
                                   // data for this class. fails with
@@ -497,25 +494,23 @@ MappingCartesian<dim>::transform_contravariant (Tensor<1,dim>       *begin,
   Assert (data.update_flags & update_contravariant_transformation,
          ExcAccessToUninitializedField());
 
-                                  // simply scale by Jacobian
+  Assert (output.size() + offset <= input.size(), ExcInternalError());
+  
+                                  // simply scale by inverse Jacobian
                                   // (which is diagonal here)
-  while (begin!=end)
-    {
-      for (unsigned int d=0; d<dim; ++d)
-       (*begin)[d] = (*src)[d]*data.length[d];
-      ++begin;
-      ++src;
-    }
+  for (unsigned int i=0; i<output.size(); ++i)
+    for (unsigned int d=0;d<dim;++d)
+      output[i][d] = input[i+offset][d] * data.length[d];
 }
 
 
 
 template <int dim>
 void
-MappingCartesian<dim>::transform_contravariant (Tensor<2,dim>       *begin,
-                                               Tensor<2,dim>       *end,
-                                               const Tensor<2,dim> *src,
-  const typename Mapping<dim>::InternalDataBase &mapping_data) const
+MappingCartesian<dim>::transform_contravariant (const std::vector<Tensor<2,dim> > &input,
+                                                const unsigned int                 offset,
+                                                std::vector<Tensor<2,dim> >       &output,
+                                                const typename Mapping<dim>::InternalDataBase &mapping_data) const
 {
                                   // convert data object to internal
                                   // data for this class. fails with
@@ -526,16 +521,14 @@ MappingCartesian<dim>::transform_contravariant (Tensor<2,dim>       *begin,
   Assert (data.update_flags & update_contravariant_transformation,
          ExcAccessToUninitializedField());
 
-                                  // simply scale by Jacobian
+  Assert (output.size() + offset <= input.size(), ExcInternalError());
+  
+                                  // simply scale by inverse Jacobian
                                   // (which is diagonal here)
-  while (begin!=end)
-    {
-      for (unsigned int d=0; d<dim; ++d)
-        for (unsigned int p=0; p<dim; ++p)
-       (*begin)[d][p] = data.length[d] * (*src)[d][p];
-      ++begin;
-      ++src;
-    }
+  for (unsigned int i=0; i<output.size(); ++i)
+    for (unsigned int d=0; d<dim; ++d)
+      for (unsigned int p=0; p<dim; ++p)
+      output[i][d][p] = input[i+offset][d][p] * data.length[p];
 }
 
 
index 75e2687de0b23a513abe8eabec70333ef215cb35..43456f694b78497d1ec699b7f5c1607951a6cd2b 100644 (file)
@@ -1145,14 +1145,16 @@ add_quad_support_points(const typename Triangulation<dim>::cell_iterator &,
 template <int dim>
 void
 MappingQ<dim>::
-transform_covariant (Tensor<1,dim>       *begin,
-                     Tensor<1,dim>       *end,
-                     const Tensor<1,dim> *src,
+transform_covariant (const std::vector<Tensor<1,dim> > &input,
+                     const unsigned int                 offset,
+                     std::vector<Tensor<1,dim> >       &output,
                      const typename Mapping<dim>::InternalDataBase &mapping_data) const
 {
   const typename MappingQ1<dim>::InternalData *q1_data =
     dynamic_cast<const typename MappingQ1<dim>::InternalData *> (&mapping_data);
   Assert(q1_data!=0, ExcInternalError());
+
+  Assert (output.size() + offset <= input.size(), ExcInternalError());
   
   typename std::vector<Tensor<2,dim> >::const_iterator tensor;
 
@@ -1169,23 +1171,25 @@ transform_covariant (Tensor<1,dim>       *begin,
        tensor = data->covariant.begin();    
     }
 
-  while (begin!=end)
-    contract (*(begin++), *(src++), *(tensor++));
+  for (unsigned int i=0; i<output.size(); ++i)
+    contract (output[i], input[i+offset], *(tensor++));
 }
 
 
 
 template <int dim>
 void
-MappingQ<dim>::transform_covariant (Tensor<2,dim>       *begin,
-                                   Tensor<2,dim>       *end,
-                                   const Tensor<2,dim> *src,
-                                   const typename Mapping<dim>::InternalDataBase &mapping_data) const
+MappingQ<dim>::transform_covariant (const std::vector<Tensor<2,dim> > &input,
+                                    const unsigned int                 offset,
+                                    std::vector<Tensor<2,dim> >       &output,
+                                    const typename Mapping<dim>::InternalDataBase &mapping_data) const
 {
   const typename MappingQ1<dim>::InternalData *q1_data =
     dynamic_cast<const typename MappingQ1<dim>::InternalData *> (&mapping_data);
   Assert(q1_data!=0, ExcInternalError());
-  
+
+  Assert (output.size() + offset <= input.size(), ExcInternalError());
+
   typename std::vector<Tensor<2,dim> >::const_iterator tensor;
 
   if (q1_data->is_mapping_q1_data)
@@ -1201,8 +1205,8 @@ MappingQ<dim>::transform_covariant (Tensor<2,dim>       *begin,
        tensor = data->covariant.begin();
     }
 
-  while (begin!=end)
-    contract (*(begin++), *(src++), *(tensor++));
+  for (unsigned int i=0; i<output.size(); ++i)
+    contract (output[i], input[i+offset], *(tensor++));
 }
 
 
@@ -1210,15 +1214,17 @@ MappingQ<dim>::transform_covariant (Tensor<2,dim>       *begin,
 template <int dim>
 void
 MappingQ<dim>::
-transform_contravariant (Tensor<1,dim>       *begin,
-                         Tensor<1,dim>       *end,
-                         const Tensor<1,dim> *src,
+transform_contravariant (const std::vector<Tensor<1,dim> > &input,
+                         const unsigned int                 offset,
+                         std::vector<Tensor<1,dim> >       &output,
                          const typename Mapping<dim>::InternalDataBase &mapping_data) const
 {
   const typename MappingQ1<dim>::InternalData *q1_data =
     dynamic_cast<const typename MappingQ1<dim>::InternalData *> (&mapping_data);
   Assert(q1_data!=0, ExcInternalError());
   
+  Assert (output.size() + offset <= input.size(), ExcInternalError());
+
   typename std::vector<Tensor<2,dim> >::const_iterator tensor;
 
   if (q1_data->is_mapping_q1_data)
@@ -1234,23 +1240,25 @@ transform_contravariant (Tensor<1,dim>       *begin,
        tensor = data->contravariant.begin();    
     }
   
-  while (begin!=end)
-    contract (*(begin++), *(tensor++), *(src++));
+  for (unsigned int i=0; i<output.size(); ++i)
+    contract (output[i], *(tensor++), input[i+offset]);
 }
 
 
 
 template <int dim>
 void
-MappingQ<dim>::transform_contravariant (Tensor<2,dim>       *begin,
-                                       Tensor<2,dim>       *end,
-                                       const Tensor<2,dim> *src,
-                                       const typename Mapping<dim>::InternalDataBase &mapping_data) const
+MappingQ<dim>::transform_contravariant (const std::vector<Tensor<2,dim> > &input,
+                                        const unsigned int                 offset,
+                                        std::vector<Tensor<2,dim> >       &output,
+                                        const typename Mapping<dim>::InternalDataBase &mapping_data) const
 {
   const typename MappingQ1<dim>::InternalData *q1_data =
     dynamic_cast<const typename MappingQ1<dim>::InternalData *> (&mapping_data);
   Assert(q1_data!=0, ExcInternalError());
   
+  Assert (output.size() + offset <= input.size(), ExcInternalError());
+
   typename std::vector<Tensor<2,dim> >::const_iterator tensor;
 
   if (q1_data->is_mapping_q1_data)
@@ -1266,8 +1274,8 @@ MappingQ<dim>::transform_contravariant (Tensor<2,dim>       *begin,
        tensor = data->contravariant.begin();    
     }
 
-  while (begin!=end)
-    contract (*(begin++), *(tensor++), *(src++));
+  for (unsigned int i=0; i<output.size(); ++i)
+    contract (output[i], *(tensor++), input[i+offset]);
 }
 
 
index 06dfca6cbe216398dc75c48e0493ce9a3773e94a..22abf10b9f789058451f61871727f4d6d5a82ced 100644 (file)
@@ -2,7 +2,7 @@
 //    $Id$
 //    Version: $Name$
 //
-//    Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 by the deal.II authors
+//    Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004 by the deal.II authors
 //
 //    This file is subject to QPL and may not be  distributed
 //    without copyright and license information. Please refer
@@ -354,13 +354,13 @@ MappingQ1<dim>::compute_face_data (const UpdateFlags update_flags,
 
   if (data.update_flags & update_boundary_forms)
     {
-      data.aux.reinit(dim-1, n_original_q_points);      
+      data.aux.resize (dim-1, std::vector<Tensor<1,dim> > (n_original_q_points));
       
                                       // Compute tangentials to the
                                       // unit cell.
       const unsigned int nfaces = GeometryInfo<dim>::faces_per_cell;
-      data.unit_tangentials.reinit(nfaces*(dim-1),
-                                  n_original_q_points);
+      data.unit_tangentials.resize (nfaces*(dim-1),
+                                    std::vector<Tensor<1,dim> > (n_original_q_points));
       for (unsigned int i=0; i<nfaces; ++i)
        {
                                           // Base index of the
@@ -607,43 +607,39 @@ MappingQ1<dim>::compute_fill_face (const typename DoFHandler<dim>::cell_iterator
       
       Assert (data.aux[0].size() <= data.unit_tangentials[face_no].size(),
              ExcInternalError());
-      transform_contravariant(data.aux[0].begin(),
-                             data.aux[0].end(),
-                             data.unit_tangentials[face_no].begin(),
+      transform_contravariant(data.unit_tangentials[face_no], 0,
+                              data.aux[0],
                              data);
 
       typename std::vector<Tensor<1,dim> >::iterator
        result = boundary_forms.begin();
       const typename std::vector<Tensor<1,dim> >::iterator
        end = boundary_forms.end();
-      const Tensor<1,dim> *
-       tang1 = data.aux[0].begin();
       
       switch (dim)
        {
          case 2:
           {
-            for (; result != end; ++result, ++tang1)
-              cross_product (*result, *tang1);
+            for (unsigned int i=0; result != end; ++result, ++i)
+              cross_product (*result, data.aux[0][i]);
             break;
           };
 
          case 3:
           {
             Assert (face_no+GeometryInfo<dim>::faces_per_cell <
-                    data.unit_tangentials.n_rows(),
+                    data.unit_tangentials.size(),
                     ExcInternalError());
             Assert (data.aux[1].size() <=
                     data.unit_tangentials[face_no+GeometryInfo<dim>::faces_per_cell].size(),
                     ExcInternalError());
-            transform_contravariant(data.aux[1].begin(),
-                                    data.aux[1].end(),
-                                    data.unit_tangentials[
-                                      face_no+GeometryInfo<dim>::faces_per_cell].begin(),
+            transform_contravariant(data.unit_tangentials[
+                                      face_no+GeometryInfo<dim>::faces_per_cell], 0,
+                                    data.aux[1],
                                     data);
-            const Tensor<1,dim> *tang2 = data.aux[1].begin();
-            for (;result != end; ++result, ++tang1, ++tang2)
-              cross_product (*result, *tang1, *tang2);
+            for (unsigned int i=0; result != end; ++result, ++i)
+              cross_product (*result, data.aux[0][i], data.aux[1][i]);
+
             break;
           };
 
@@ -787,10 +783,10 @@ MappingQ1<1>::fill_fe_subface_values (const DoFHandler<1>::cell_iterator &,
 
 template <int dim>
 void
-MappingQ1<dim>::transform_covariant (Tensor<1,dim>       *begin,
-                                    Tensor<1,dim>       *end,
-                                    const Tensor<1,dim> *src,
-                                    const typename Mapping<dim>::InternalDataBase &mapping_data) const
+MappingQ1<dim>::transform_covariant (const std::vector<Tensor<1,dim> > &input,
+                                     const unsigned int                 offset,
+                                     std::vector<Tensor<1,dim> >       &output,
+                                     const typename Mapping<dim>::InternalDataBase &mapping_data) const
 {
   const InternalData *data_ptr = dynamic_cast<const InternalData *> (&mapping_data);
   Assert(data_ptr!=0, ExcInternalError());
@@ -799,27 +795,20 @@ MappingQ1<dim>::transform_covariant (Tensor<1,dim>       *begin,
   Assert (data.update_flags & update_covariant_transformation,
          ExcAccessToUninitializedField());
 
-//TODO: [GK] Can we do a similar assertion?  
-//  Assert (dst.size() == data.contravariant.size(),
-//       ExcDimensionMismatch(dst.size() + src_offset, data.contravariant.size()));
+  Assert (output.size() + offset <= input.size(), ExcInternalError());
 
-  typename std::vector<Tensor<2,dim> >::const_iterator
-    tensor = data.covariant.begin();
-  
-  while (begin!=end)
-    {
-      contract (*(begin++), *(src++), *(tensor++));
-    }
+  for (unsigned int i=0; i<output.size(); ++i)
+    contract (output[i], input[i+offset], data.covariant[i]);
 }
 
 
 
 template <int dim>
 void
-MappingQ1<dim>::transform_covariant (Tensor<2,dim>       *begin,
-                                    Tensor<2,dim>       *end,
-                                    const Tensor<2,dim> *src,
-                                    const typename Mapping<dim>::InternalDataBase &mapping_data) const
+MappingQ1<dim>::transform_covariant (const std::vector<Tensor<2,dim> > &input,
+                                     const unsigned int                 offset,
+                                     std::vector<Tensor<2,dim> >       &output,
+                                     const typename Mapping<dim>::InternalDataBase &mapping_data) const
 {
   const InternalData *data_ptr = dynamic_cast<const InternalData *> (&mapping_data);
   Assert(data_ptr!=0, ExcInternalError());
@@ -828,17 +817,10 @@ MappingQ1<dim>::transform_covariant (Tensor<2,dim>       *begin,
   Assert (data.update_flags & update_covariant_transformation,
          ExcAccessToUninitializedField());
 
-//TODO: [GK] Can we do a similar assertion?  
-//  Assert (dst.size() == data.contravariant.size(),
-//       ExcDimensionMismatch(dst.size() + src_offset, data.contravariant.size()));
+  Assert (output.size() + offset <= input.size(), ExcInternalError());
 
-  typename std::vector<Tensor<2,dim> >::const_iterator
-    tensor = data.covariant.begin();
-  
-  while (begin!=end)
-    {
-      contract (*(begin++), *(src++), *(tensor++));
-    }
+  for (unsigned int i=0; i<output.size(); ++i)
+    contract (output[i], input[i+offset], data.covariant[i]);
 }
 
 
@@ -846,9 +828,9 @@ MappingQ1<dim>::transform_covariant (Tensor<2,dim>       *begin,
 template <int dim>
 void
 MappingQ1<dim>::
-transform_contravariant (Tensor<1,dim>       *begin,
-                         Tensor<1,dim>       *end,
-                         const Tensor<1,dim> *src,
+transform_contravariant (const std::vector<Tensor<1,dim> > &input,
+                         const unsigned int                 offset,
+                         std::vector<Tensor<1,dim> >       &output,
                          const typename Mapping<dim>::InternalDataBase &mapping_data) const
 {
   const InternalData* data_ptr = dynamic_cast<const InternalData *> (&mapping_data);
@@ -858,11 +840,10 @@ transform_contravariant (Tensor<1,dim>       *begin,
   Assert (data.update_flags & update_contravariant_transformation,
          ExcAccessToUninitializedField());
 
-  typename std::vector<Tensor<2,dim> >::const_iterator
-    tensor = data.contravariant.begin();
-  
-  while (begin!=end)
-    contract (*(begin++), *(tensor++), *(src++));
+  Assert (output.size() + offset <= input.size(), ExcInternalError());
+
+  for (unsigned int i=0; i<output.size(); ++i)
+    contract (output[i], data.contravariant[i], input[i+offset]);
 }
 
 
@@ -870,9 +851,9 @@ transform_contravariant (Tensor<1,dim>       *begin,
 template <int dim>
 void
 MappingQ1<dim>::
-transform_contravariant (Tensor<2,dim>       *begin,
-                         Tensor<2,dim>       *end,
-                         const Tensor<2,dim> *src,
+transform_contravariant (const std::vector<Tensor<2,dim> > &input,
+                         const unsigned int                 offset,
+                         std::vector<Tensor<2,dim> >       &output,
                          const typename Mapping<dim>::InternalDataBase &mapping_data) const
 {
   const InternalData* data_ptr = dynamic_cast<const InternalData *> (&mapping_data);
@@ -882,11 +863,10 @@ transform_contravariant (Tensor<2,dim>       *begin,
   Assert (data.update_flags & update_contravariant_transformation,
          ExcAccessToUninitializedField());
 
-  typename std::vector<Tensor<2,dim> >::const_iterator
-    tensor = data.contravariant.begin();
-  
-  while (begin!=end)
-    contract (*(begin++), *(tensor++), *(src++));
+  Assert (output.size() + offset <= input.size(), ExcInternalError());
+
+  for (unsigned int i=0; i<output.size(); ++i)
+    contract (output[i], data.contravariant[i], input[i+offset]);
 }
 
 

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.