]> https://gitweb.dealii.org/ - dealii-svn.git/commitdiff
Use vector2d at a couple of places instead of vector<vector<...> >. This should make...
authorwolf <wolf@0785d39b-7218-0410-832d-ea1e28bc413d>
Tue, 23 Jul 2002 16:54:31 +0000 (16:54 +0000)
committerwolf <wolf@0785d39b-7218-0410-832d-ea1e28bc413d>
Tue, 23 Jul 2002 16:54:31 +0000 (16:54 +0000)
git-svn-id: https://svn.dealii.org/trunk@6268 0785d39b-7218-0410-832d-ea1e28bc413d

17 files changed:
deal.II/deal.II/include/fe/fe_dgp.h
deal.II/deal.II/include/fe/fe_dgq.h
deal.II/deal.II/include/fe/fe_nedelec.h
deal.II/deal.II/include/fe/fe_q.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_dgp.cc
deal.II/deal.II/source/fe/fe_dgq.cc
deal.II/deal.II/source/fe/fe_q.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 1e30f5069895766a6b53dc69263e2132594aeef9..6c0108286cee8e9d848d0901eb20782341056b42 100644 (file)
@@ -406,7 +406,7 @@ class FE_DGP : public FiniteElement<dim>
                                          * them over when visiting a
                                          * concrete cell.
                                          */
-       std::vector<std::vector<double> > shape_values;
+       vector2d<double> shape_values;
        
                                         /**
                                          * Array with shape function
@@ -426,7 +426,7 @@ class FE_DGP : public FiniteElement<dim>
                                          * multiplication) when
                                          * visiting an actual cell.
                                          */                                  
-       std::vector<std::vector<Tensor<1,dim> > > shape_gradients;
+       vector2d<Tensor<1,dim> > shape_gradients;
     };
     
                                     /**
index de35097d631f71471b3c4eb2301ab05322c71bfc..4b0910f232275333dfcf9bb379bdcb3aff06de76 100644 (file)
@@ -434,7 +434,7 @@ class FE_DGQ : public FiniteElement<dim>
                                          * them over when visiting a
                                          * concrete cell.
                                          */
-       std::vector<std::vector<double> > shape_values;
+       vector2d<double> shape_values;
        
                                         /**
                                          * Array with shape function
@@ -454,7 +454,7 @@ class FE_DGQ : public FiniteElement<dim>
                                          * multiplication) when
                                          * visiting an actual cell.
                                          */                                  
-       std::vector<std::vector<Tensor<1,dim> > > shape_gradients;
+       vector2d<Tensor<1,dim> > shape_gradients;
     };
     
                                     /**
index c8590d2d7faa8defaeb4b862888c6ff470d226df..5d5ba486a00c323058ba919b29fae284d4056d60 100644 (file)
@@ -438,7 +438,7 @@ class FE_Nedelec : public FiniteElement<dim>
                                          * multiplication with the
                                          * Jacobian of the mapping.
                                          */
-       std::vector<std::vector<Tensor<1,dim> > > shape_values;
+       vector2d<Tensor<1,dim> > shape_values;
 
                                         /**
                                          * Array with shape function
@@ -458,7 +458,7 @@ class FE_Nedelec : public FiniteElement<dim>
                                          * multiplication) when
                                          * visiting an actual cell.
                                          */
-       std::vector<std::vector<Tensor<2,dim> > > shape_gradients;
+       vector2d<Tensor<2,dim> > shape_gradients;
     };
     
                                     /**
index b1d8a9e46c4060fbe7dc62c56efea218a7ebb45b..0c4aabeeb0f13d231b33185e83eec76d0c61bc5a 100644 (file)
@@ -779,7 +779,7 @@ class FE_Q : public FiniteElement<dim>
                                          * them over when visiting a
                                          * concrete cell.
                                          */
-       std::vector<std::vector<double> > shape_values;
+       vector2d<double> shape_values;
 
                                         /**
                                          * Array with shape function
@@ -799,7 +799,7 @@ class FE_Q : public FiniteElement<dim>
                                          * multiplication) when
                                          * visiting an actual cell.
                                          */      
-       std::vector<std::vector<Tensor<1,dim> > > shape_gradients;
+       vector2d<Tensor<1,dim> > shape_gradients;
     };
     
                                     /**
index bff29f91b059683f78e63a4c40e542eb8befda62..ed6cfed2f81c59b4f07803c79a78f9f89ed39259 100644 (file)
@@ -20,7 +20,7 @@
 #include <base/point.h>
 #include <base/tensor.h>
 #include <base/quadrature.h>
-#include <lac/full_matrix.h>
+#include <base/vector2d.h>
 #include <grid/tria.h>
 #include <grid/tria_iterator.h>
 #include <dofs/dof_handler.h>
@@ -94,8 +94,7 @@ class FEValuesData
                                      * thus have a row in the array
                                      * presently under discussion.
                                      */
-//TODO[WB]: use vector2d here    
-    typedef FullMatrix<double> ShapeVector;
+    typedef vector2d<double> ShapeVector;
 
                                     /**
                                      * Storage type for
@@ -103,19 +102,13 @@ class FEValuesData
                                      * is the same as for the
                                      * @ref{ShapeVector} data type.
                                      */
-//TODO[WB]: use vector2d here
-    typedef
-    std::vector<std::vector<Tensor<1,dim> > >
-    GradientVector;
+    typedef vector2d<Tensor<1,dim> > GradientVector;
 
                                     /**
                                      * Likewise for second order
                                      * derivatives.
                                      */
-//TODO[WB]: use vector2d here
-    typedef
-    std::vector<std::vector<Tensor<2,dim> > >
-    GradGradVector;
+    typedef vector2d<Tensor<2,dim> > GradGradVector;
     
                                     /**
                                      * Store the values of the shape
@@ -1279,10 +1272,10 @@ FEValuesBase<dim>::shape_grad (const unsigned int i,
          ExcAccessToUninitializedField());
   Assert (fe->is_primitive (i),
          ExcShapeFunctionNotPrimitive(i));
-  Assert (i<this->shape_gradients.size(),
-         ExcIndexRange (i, 0, this->shape_gradients.size()));
-  Assert (j<this->shape_gradients[i].size(),
-         ExcIndexRange (j, 0, this->shape_gradients[i].size()));
+  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()));
 
                                   // if the entire FE is primitive,
                                   // then we can take a short-cut:
@@ -1376,10 +1369,10 @@ FEValuesBase<dim>::shape_2nd_derivative (const unsigned int i,
          ExcAccessToUninitializedField());
   Assert (fe->is_primitive (i),
          ExcShapeFunctionNotPrimitive(i));
-  Assert (i<this->shape_2nd_derivatives.size(),
-         ExcIndexRange (i, 0, this->shape_2nd_derivatives.size()));
-  Assert (j<this->shape_2nd_derivatives[i].size(),
-         ExcIndexRange (j, 0, this->shape_2nd_derivatives[i].size()));
+  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()));
 
                                   // if the entire FE is primitive,
                                   // then we can take a short-cut:
index 92c69298cbc7bb2d58525b1f215d00646fcb220a..05a0e5a8800ed4db52447cfff5ba9983eecbc3ef 100644 (file)
@@ -18,6 +18,7 @@
 #include <cmath>
 #include <base/point.h>
 #include <base/subscriptor.h>
+#include <base/vector2d.h>
 #include <grid/tria.h>
 #include <dofs/dof_handler.h>
 #include <fe/fe_update_flags.h>
@@ -201,10 +202,10 @@ class Mapping : public Subscriptor
                                      */
     virtual
     void
-    transform_covariant (typename std::vector<Tensor<1,dim> >::iterator begin,
-                        typename std::vector<Tensor<1,dim> >::const_iterator end,
-                        typename std::vector<Tensor<1,dim> >::const_iterator src,
-                        const InternalDataBaseinternal) const = 0;
+    transform_covariant (Tensor<1,dim>          *begin,
+                        Tensor<1,dim>          *end,
+                        const Tensor<1,dim>    *src,
+                        const InternalDataBase &internal) const = 0;
     
                                     /**
                                      * Tranform a field of
@@ -221,10 +222,10 @@ class Mapping : public Subscriptor
                                      */
     virtual
     void
-    transform_contravariant (typename std::vector<Tensor<1,dim> >::iterator begin,
-                            typename std::vector<Tensor<1,dim> >::const_iterator end,
-                            typename std::vector<Tensor<1,dim> >::const_iterator src,
-                            const InternalDataBaseinternal) const = 0;
+    transform_contravariant (Tensor<1,dim>          *begin,
+                            Tensor<1,dim>          *end,
+                            const Tensor<1,dim>    *src,
+                            const InternalDataBase &internal) const = 0;
 
                                     /**
                                      * Indicate fields to be updated
index e08d594c4114a6e2bda37ef4b0f4ca9695098334..0027696eb5939fe4cc6558ac0b139e2193d081da 100644 (file)
@@ -105,20 +105,20 @@ class MappingCartesian : public Mapping<dim>
                                      * @ref{Mapping}.
                                      */
     virtual void
-    transform_covariant (typename std::vector<Tensor<1,dim> >::iterator begin,
-                        typename std::vector<Tensor<1,dim> >::const_iterator end,
-                        typename std::vector<Tensor<1,dim> >::const_iterator src,
-                        const typename Mapping<dim>::InternalDataBase &mapping_data) const;
+    transform_covariant (Tensor<1,dim>          *begin,
+                        Tensor<1,dim>          *end,
+                        const Tensor<1,dim>    *src,
+                        const typename Mapping<dim>::InternalDataBase &internal) const;
     
                                     /**
                                      * Implementation of the interface in
                                      * @ref{Mapping}.
                                      */
     virtual void
-    transform_contravariant (typename std::vector<Tensor<1,dim> >::iterator begin,
-                            typename std::vector<Tensor<1,dim> >::const_iterator end,
-                            typename std::vector<Tensor<1,dim> >::const_iterator src,
-                            const typename Mapping<dim>::InternalDataBase &mapping_data) const;
+    transform_contravariant (Tensor<1,dim>          *begin,
+                            Tensor<1,dim>          *end,
+                            const Tensor<1,dim>    *src,
+                            const typename Mapping<dim>::InternalDataBase &internal) const;
 
                                     /**
                                      * Transforms the point @p{p} on
@@ -205,12 +205,12 @@ class MappingCartesian : public Mapping<dim>
                                          *
                                          * Filled once.
                                          */
-        std::vector<std::vector<Tensor<1,dim> > > unit_tangentials;
+        vector2d<Tensor<1,dim> > unit_tangentials;
        
                                         /**
                                          * Auxiliary vectors for internal use.
                                          */
-        std::vector<std::vector<Tensor<1,dim> > > aux;
+        vector2d<Tensor<1,dim> > aux;
     };
     
                                     /**
index bf1934d62c10e59d929174cc48776600b7ac69c1..a935afb8060d16814b002aca2105d32d8fcfb568 100644 (file)
@@ -15,9 +15,9 @@
 
 
 #include <base/config.h>
+#include <base/vector2d.h>
 #include <fe/mapping_q1.h>
 
-
 template <int dim> class TensorProductPolynomials;
 class LagrangeEquidistant;
 
@@ -83,20 +83,20 @@ class MappingQ : public MappingQ1<dim>
                                      * @ref{Mapping}.
                                      */
     virtual void
-    transform_covariant (typename std::vector<Tensor<1,dim> >::iterator begin,
-                        typename std::vector<Tensor<1,dim> >::const_iterator end,
-                        typename std::vector<Tensor<1,dim> >::const_iterator src,
-                        const typename Mapping<dim>::InternalDataBase &mapping_data) const;
+    transform_covariant (Tensor<1,dim>          *begin,
+                        Tensor<1,dim>          *end,
+                        const Tensor<1,dim>    *src,
+                        const typename Mapping<dim>::InternalDataBase &internal) const;
     
                                     /**
                                      * Implementation of the interface in
                                      * @ref{Mapping}.
                                      */
     virtual void
-    transform_contravariant (typename std::vector<Tensor<1,dim> >::iterator begin,
-                            typename std::vector<Tensor<1,dim> >::const_iterator end,
-                            typename std::vector<Tensor<1,dim> >::const_iterator src,
-                            const typename Mapping<dim>::InternalDataBase &mapping_data) const;    
+    transform_contravariant (Tensor<1,dim>          *begin,
+                            Tensor<1,dim>          *end,
+                            const Tensor<1,dim>    *src,
+                            const typename Mapping<dim>::InternalDataBase &internal) const;    
 
                                     /**
                                      * Return the degree of the
@@ -304,7 +304,7 @@ class MappingQ : public MappingQ1<dim>
                                      * this vector is computed.
                                      */
     void
-    set_laplace_on_quad_vector(std::vector<std::vector<double> > &loqvs) const;
+    set_laplace_on_quad_vector(vector2d<double> &loqvs) const;
     
                                     /**
                                      * This function is needed by the
@@ -317,7 +317,7 @@ class MappingQ : public MappingQ1<dim>
                                      * @p{degree>2} this vector is
                                      * computed.
                                      */
-    void set_laplace_on_hex_vector(std::vector<std::vector<double> > &lohvs) const;
+    void set_laplace_on_hex_vector(vector2d<double> &lohvs) const;
     
                                     /**
                                      * Computes the @p{laplace_on_quad(hex)_vector}.
@@ -327,7 +327,7 @@ class MappingQ : public MappingQ1<dim>
                                      * functions if the data is not
                                      * yet hardcoded.
                                      */
-    void compute_laplace_vector(std::vector<std::vector<double> > &lvs) const;
+    void compute_laplace_vector(vector2d<double> &lvs) const;
 
                                     /**
                                      * Takes a
@@ -344,7 +344,7 @@ class MappingQ : public MappingQ1<dim>
                                      * @p{n_inner} computed inner
                                      * points are appended.
                                      */
-    void apply_laplace_vector(const std::vector<std::vector<double> > &lvs,
+    void apply_laplace_vector(const vector2d<double>   &lvs,
                              std::vector<Point<dim> > &a) const;
     
                                     /**
@@ -426,7 +426,7 @@ class MappingQ : public MappingQ1<dim>
                                      *   unit_support_points on the
                                      *   boundary of the quad
                                      */
-    std::vector<std::vector<double> > laplace_on_quad_vector;
+    vector2d<double> laplace_on_quad_vector;
     
                                     /**
                                      * Needed by the
@@ -434,7 +434,7 @@ class MappingQ : public MappingQ1<dim>
                                      * (for @p{dim==3}). Filled by the
                                      * constructor.
                                      */
-    std::vector<std::vector<double> > laplace_on_hex_vector;
+    vector2d<double> laplace_on_hex_vector;
 
                                     /**
                                      * Exception.
@@ -514,11 +514,11 @@ template<> void MappingQ<1>::compute_shapes_virtual (
   const std::vector<Point<1> > &unit_points,
   MappingQ1<1>::InternalData   &data) const;
 template <> void MappingQ<1>::set_laplace_on_quad_vector(
-  std::vector<std::vector<double> > &) const;
+  vector2d<double> &) const;
 template <> void MappingQ<3>::set_laplace_on_hex_vector(
-  std::vector<std::vector<double> > &lohvs) const;
+  vector2d<double> &lohvs) const;
 template <> void MappingQ<1>::compute_laplace_vector(
-  std::vector<std::vector<double> > &) const;
+  vector2d<double> &) const;
 template <> void MappingQ<1>::add_line_support_points (
   const Triangulation<1>::cell_iterator &,
   std::vector<Point<1> > &) const;
index 13fb8dab1acdc528bbe8233b87ea0c507bfd91a6..24237bb452cc591612233045ad1e5393b0eb1fb4 100644 (file)
@@ -72,20 +72,20 @@ class MappingQ1 : public Mapping<dim>
                                      * @ref{Mapping}.
                                      */
     virtual void
-    transform_covariant (typename std::vector<Tensor<1,dim> >::iterator begin,
-                        typename std::vector<Tensor<1,dim> >::const_iterator end,
-                        typename std::vector<Tensor<1,dim> >::const_iterator src,
-                        const typename Mapping<dim>::InternalDataBase &mapping_data) const;
+    transform_covariant (Tensor<1,dim>          *begin,
+                        Tensor<1,dim>          *end,
+                        const Tensor<1,dim>    *src,
+                        const typename Mapping<dim>::InternalDataBase &internal) const;
     
                                     /**
                                      * Implementation of the interface in
                                      * @ref{Mapping}.
                                      */
     virtual void
-    transform_contravariant (typename std::vector<Tensor<1,dim> >::iterator begin,
-                            typename std::vector<Tensor<1,dim> >::const_iterator end,
-                            typename std::vector<Tensor<1,dim> >::const_iterator src,
-                            const typename Mapping<dim>::InternalDataBase &mapping_data) const;
+    transform_contravariant (Tensor<1,dim>          *begin,
+                            Tensor<1,dim>          *end,
+                            const Tensor<1,dim>    *src,
+                            const typename Mapping<dim>::InternalDataBase &internal) const;
     
                                     /**
                                      * Implementation of the interface in
@@ -259,12 +259,12 @@ class MappingQ1 : public Mapping<dim>
                                          *
                                          * Filled once.
                                          */
-        std::vector<std::vector<Tensor<1,dim> > > unit_tangentials;
+        vector2d<Tensor<1,dim> > unit_tangentials;
        
                                         /**
                                          * Auxuliary vectors for internal use.
                                          */
-        std::vector<std::vector<Tensor<1,dim> > > aux;
+        vector2d<Tensor<1,dim> > aux;
 
                                         /**
                                          * Stores the support points of
index e703e0868a0ead2cd653a07b11f92991340637c2..f07b5738669cbb353d42eed0a9b226bf9352c4ce 100644 (file)
@@ -415,10 +415,10 @@ compute_2nd (const Mapping<dim>                   &mapping,
   Assert ((fe_internal.update_each | fe_internal.update_once)
          & update_second_derivatives,
          ExcInternalError());
-  Assert (data.shape_2nd_derivatives.size() == this->dofs_per_cell,
+  Assert (data.shape_2nd_derivatives.n_rows() == this->dofs_per_cell,
          ExcInternalError());
                                   // Number of quadrature points
-  const unsigned int n_q_points = data.shape_2nd_derivatives[0].size();
+  const unsigned int n_q_points = data.shape_2nd_derivatives.n_cols();
 
                                   // first reinit the fe_values
                                   // objects used for the finite
@@ -433,8 +433,8 @@ compute_2nd (const Mapping<dim>                   &mapping,
                                   // quotients of gradients in each
                                   // direction (first index) and at
                                   // all q-points (second index)
-  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);
+  vector2d<Tensor<1,dim> >    diff_quot (dim, n_q_points);
+  std::vector<Tensor<1,dim> > diff_quot2 (n_q_points);
 
                                   // for all shape functions at all
                                   // quadrature points and difference
@@ -469,7 +469,7 @@ compute_2nd (const Mapping<dim>                   &mapping,
                                       // cell
       for (unsigned int d=0; d<dim; ++d)
        {
-         mapping.transform_covariant (diff_quot2.begin(), diff_quot2.end(),
+         mapping.transform_covariant (&*diff_quot2.begin(), &*diff_quot2.end(),
                                       diff_quot[d].begin()+offset,
                                       mapping_internal);
 
index 5dddc6750bbee2579e35d53095360070ddfbb2a4..1842b8868673001361c35f74954d107563b0a2b1 100644 (file)
@@ -217,15 +217,15 @@ FE_DGP<dim>::get_data (const UpdateFlags      update_flags,
   if (flags & update_values)
     {
       values.resize (this->dofs_per_cell);
-      data->shape_values.resize(this->dofs_per_cell,
-                               std::vector<double>(n_q_points));
+      data->shape_values.reinit (this->dofs_per_cell,
+                                n_q_points);
     }
 
   if (flags & update_gradients)
     {
       grads.resize (this->dofs_per_cell);
-      data->shape_gradients.resize(this->dofs_per_cell,
-                                  std::vector<Tensor<1,dim> >(n_q_points));
+      data->shape_gradients.reinit (this->dofs_per_cell,
+                                   n_q_points);
     }
 
                                   // if second derivatives through
index b6bf202a9ceb16c191661e2c7c9b189bf4deb066..a64269356eea3e8b17c35b1a34b689d058a6e06f 100644 (file)
@@ -420,15 +420,15 @@ FE_DGQ<dim>::get_data (const UpdateFlags      update_flags,
   if (flags & update_values)
     {
       values.resize (this->dofs_per_cell);
-      data->shape_values.resize(this->dofs_per_cell,
-                               std::vector<double>(n_q_points));
+      data->shape_values.reinit (this->dofs_per_cell,
+                                n_q_points);
     }
 
   if (flags & update_gradients)
     {
       grads.resize (this->dofs_per_cell);
-      data->shape_gradients.resize(this->dofs_per_cell,
-                                  std::vector<Tensor<1,dim> >(n_q_points));
+      data->shape_gradients.reinit (this->dofs_per_cell,
+                                   n_q_points);
     }
 
                                   // if second derivatives through
index 6e8f6bb684a7323fd38ffd874d1122fb9110296c..c8079215ec3c45220cd881668c5d5542a06e190a 100644 (file)
@@ -1110,15 +1110,15 @@ FE_Q<dim>::get_data (const UpdateFlags      update_flags,
   if (flags & update_values)
     {
       values.resize (this->dofs_per_cell);
-      data->shape_values.resize(this->dofs_per_cell,
-                               std::vector<double>(n_q_points));
+      data->shape_values.reinit (this->dofs_per_cell,
+                                n_q_points);
     }
 
   if (flags & update_gradients)
     {
       grads.resize (this->dofs_per_cell);
-      data->shape_gradients.resize(this->dofs_per_cell,
-                                  std::vector<Tensor<1,dim> >(n_q_points));
+      data->shape_gradients.reinit (this->dofs_per_cell,
+                                   n_q_points);
     }
 
                                   // if second derivatives through
index 41cefe5931c35525ae1cd1558e43c14304e2609c..a525ea75c0ce87d7aa96bf36ca7a7f1819f90cd8 100644 (file)
@@ -65,21 +65,16 @@ FEValuesData<dim>::initialize (const unsigned int        n_quadrature_points,
                                   // that we will need to their
                                   // correct size
   if (flags & update_values)
-    this->shape_values.reinit(n_nonzero_shape_components, n_quadrature_points);
+    this->shape_values.reinit(n_nonzero_shape_components,
+                             n_quadrature_points);
 
   if (flags & update_gradients)
-    {
-      this->shape_gradients.resize(n_nonzero_shape_components);
-      for (unsigned int i=0; i<n_nonzero_shape_components; ++i)
-       this->shape_gradients[i].resize(n_quadrature_points);
-    }
+    this->shape_gradients.reinit(n_nonzero_shape_components,
+                                n_quadrature_points);
 
   if (flags & update_second_derivatives)
-    {      
-      this->shape_2nd_derivatives.resize(n_nonzero_shape_components);
-      for (unsigned int i=0; i<n_nonzero_shape_components; ++i)
-       this->shape_2nd_derivatives[i].resize(n_quadrature_points);
-    }
+    this->shape_2nd_derivatives.reinit(n_nonzero_shape_components,
+                                      n_quadrature_points);
   
   if (flags & update_q_points)
     this->quadrature_points.resize(n_quadrature_points);
@@ -295,7 +290,7 @@ template <int dim>
 template <class InputVector>
 void
 FEValuesBase<dim>::
-get_function_grads (const InputVector                                           &fe_function,
+get_function_grads (const InputVector                         &fe_function,
                    std::vector<std::vector<Tensor<1,dim> > > &gradients) const
 {
   Assert (n_quadrature_points == gradients.size(),
@@ -394,7 +389,7 @@ template <int dim>
 template <class InputVector>
 void
 FEValuesBase<dim>::
-get_function_2nd_derivatives (const InputVector                                           &fe_function,
+get_function_2nd_derivatives (const InputVector                         &fe_function,
                              std::vector<std::vector<Tensor<2,dim> > > &second_derivs) const
 {
   Assert (n_quadrature_points == second_derivs.size(),
index c1dac9784ea95330b84d197706f0bb023f87fd11..cc90555189a0cf1022456a8551f02e81edd238f5 100644 (file)
@@ -438,11 +438,10 @@ MappingCartesian<1>::fill_fe_subface_values (const DoFHandler<1>::cell_iterator
 
 template <int dim>
 void
-MappingCartesian<dim>::transform_covariant (
-  typename std::vector<Tensor<1,dim> >::iterator begin,
-  typename std::vector<Tensor<1,dim> >::const_iterator end,
-  typename std::vector<Tensor<1,dim> >::const_iterator src,
-  const typename Mapping<dim>::InternalDataBase &mapping_data) const
+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
 {
   const InternalData &data = dynamic_cast<const InternalData&> (mapping_data);
 
@@ -463,10 +462,9 @@ MappingCartesian<dim>::transform_covariant (
 
 template <int dim>
 void
-MappingCartesian<dim>::transform_contravariant (
-  typename std::vector<Tensor<1,dim> >::iterator begin,
-  typename std::vector<Tensor<1,dim> >::const_iterator end,
-  typename std::vector<Tensor<1,dim> >::const_iterator src,
+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
 {
                                   // convert data object to internal
index 3ac7c029029916125b70a2ace1d197da06ee1a6e..d55bee4885d4980f2950c06cdf8a0c73ce3442f0 100644 (file)
@@ -409,7 +409,7 @@ MappingQ<dim>::fill_fe_subface_values (const typename DoFHandler<dim>::cell_iter
 
 template <>
 void
-MappingQ<1>::set_laplace_on_quad_vector(std::vector<std::vector<double> > &) const
+MappingQ<1>::set_laplace_on_quad_vector(vector2d<double> &) const
 {
   Assert(false, ExcInternalError());
 }
@@ -418,7 +418,7 @@ MappingQ<1>::set_laplace_on_quad_vector(std::vector<std::vector<double> > &) con
 
 template <int dim>
 void
-MappingQ<dim>::set_laplace_on_quad_vector(std::vector<std::vector<double> > &loqvs) const
+MappingQ<dim>::set_laplace_on_quad_vector(vector2d<double> &loqvs) const
 {
   Assert(degree>1, ExcInternalError());
   const unsigned int n_inner_2d=(degree-1)*(degree-1);
@@ -453,13 +453,10 @@ MappingQ<dim>::set_laplace_on_quad_vector(std::vector<std::vector<double> > &loq
     {
                                       // precomputed. copy values to
                                       // the loqvs array
-      loqvs.resize(n_inner_2d);
+      loqvs.reinit(n_inner_2d, n_outer_2d);
       for (unsigned int unit_point=0; unit_point<n_inner_2d; ++unit_point)
-       {
-         loqvs[unit_point].resize(n_outer_2d, 0);
-         for (unsigned int k=0; k<n_outer_2d; ++k)
-           loqvs[unit_point][k]=loqv_ptr[unit_point*n_outer_2d+k];
-       }
+       for (unsigned int k=0; k<n_outer_2d; ++k)
+         loqvs[unit_point][k]=loqv_ptr[unit_point*n_outer_2d+k];
     }
   else
     {
@@ -480,7 +477,7 @@ MappingQ<dim>::set_laplace_on_quad_vector(std::vector<std::vector<double> > &loq
                                   // the sum of weights of the points
                                   // at the outer rim should be
                                   // one. check this
-  for (unsigned int unit_point=0; unit_point<loqvs.size(); ++unit_point)
+  for (unsigned int unit_point=0; unit_point<loqvs.n_rows(); ++unit_point)
     Assert(std::fabs(std::accumulate(loqvs[unit_point].begin(),
                                     loqvs[unit_point].end(),0.)-1)<1e-13,
           ExcInternalError());
@@ -493,7 +490,7 @@ MappingQ<dim>::set_laplace_on_quad_vector(std::vector<std::vector<double> > &loq
 
 template <>
 void
-MappingQ<3>::set_laplace_on_hex_vector(std::vector<std::vector<double> > &lohvs) const
+MappingQ<3>::set_laplace_on_hex_vector(vector2d<double> &lohvs) const
 {
   Assert(degree>1, ExcInternalError());
 
@@ -516,13 +513,10 @@ MappingQ<3>::set_laplace_on_hex_vector(std::vector<std::vector<double> > &lohvs)
     {
                                       // precomputed. copy values to
                                       // the lohvs array
-      lohvs.resize(n_inner);
+      lohvs.reinit(n_inner, n_outer);
       for (unsigned int unit_point=0; unit_point<n_inner; ++unit_point)
-       {
-         lohvs[unit_point].resize(n_outer, 0);
-         for (unsigned int k=0; k<n_outer; ++k)
-           lohvs[unit_point][k]=lohv_ptr[unit_point*n_outer+k];
-       }
+       for (unsigned int k=0; k<n_outer; ++k)
+         lohvs[unit_point][k]=lohv_ptr[unit_point*n_outer+k];
     }
   else
                                     // not precomputed, then do so now
@@ -542,7 +536,7 @@ MappingQ<3>::set_laplace_on_hex_vector(std::vector<std::vector<double> > &lohvs)
 
 template <int dim>
 void
-MappingQ<dim>::set_laplace_on_hex_vector(std::vector<std::vector<double> > &) const
+MappingQ<dim>::set_laplace_on_hex_vector(vector2d<double> &) const
 {
   Assert(false, ExcInternalError());
 }
@@ -554,7 +548,7 @@ MappingQ<dim>::set_laplace_on_hex_vector(std::vector<std::vector<double> > &) co
 
 template <>
 void
-MappingQ<1>::compute_laplace_vector(std::vector<std::vector<double> > &) const
+MappingQ<1>::compute_laplace_vector(vector2d<double> &) const
 {
   Assert(false, ExcInternalError());
 }
@@ -564,9 +558,9 @@ MappingQ<1>::compute_laplace_vector(std::vector<std::vector<double> > &) const
 
 template <int dim>
 void
-MappingQ<dim>::compute_laplace_vector(std::vector<std::vector<double> > &lvs) const
+MappingQ<dim>::compute_laplace_vector(vector2d<double> &lvs) const
 {
-  Assert(lvs.size()==0, ExcInternalError());
+  Assert(lvs.n_rows()==0, ExcInternalError());
   Assert(dim==2 || dim==3, ExcNotImplemented());
   Assert(degree>1, ExcInternalError());
 
@@ -611,17 +605,10 @@ MappingQ<dim>::compute_laplace_vector(std::vector<std::vector<double> > &lvs) co
   
                                   // Resize and initialize the
                                   // lvs
-  lvs.resize(n_inner);
+  lvs.reinit (n_inner, n_outer);
   for (unsigned int i=0; i<n_inner; ++i)
-    lvs[i].resize(n_outer, 0);
-  
-                                  // fill this vector
-  for (unsigned int i=0; i<n_inner; ++i)
-    {
-      std::vector<double> &lv=lvs[i];
-      for (unsigned int k=0; k<n_outer; ++k)
-       lv[k]=-S_1_T(i,k);
-    }
+    for (unsigned int k=0; k<n_outer; ++k)
+      lvs(i,k) = -S_1_T(i,k);
 }
 
 #endif
@@ -630,15 +617,16 @@ MappingQ<dim>::compute_laplace_vector(std::vector<std::vector<double> > &lvs) co
 
 template <int dim>
 void
-MappingQ<dim>::apply_laplace_vector(const std::vector<std::vector<double> > &lvs,
+MappingQ<dim>::apply_laplace_vector(const vector2d<double> &lvs,
                                    std::vector<Point<dim> > &a) const
 {
-  Assert(lvs.size()!=0, ExcLaplaceVectorNotSet(degree));
-  const unsigned int n_inner_apply=lvs.size();
+  Assert(lvs.n_rows()!=0, ExcLaplaceVectorNotSet(degree));
+  const unsigned int n_inner_apply=lvs.n_rows();
   Assert(n_inner_apply==n_inner || n_inner_apply==(degree-1)*(degree-1),
         ExcInternalError());
-  const unsigned int n_outer_apply=lvs[0].size();
-  Assert(a.size()==n_outer_apply, ExcDimensionMismatch(a.size(), n_outer_apply));
+  const unsigned int n_outer_apply=lvs.n_cols();
+  Assert(a.size()==n_outer_apply,
+        ExcDimensionMismatch(a.size(), n_outer_apply));
 
                                   // compute each inner point as
                                   // linear combination of the outer
@@ -648,7 +636,7 @@ MappingQ<dim>::apply_laplace_vector(const std::vector<std::vector<double> > &lvs
                                   // elements of a
   for (unsigned int unit_point=0; unit_point<n_inner_apply; ++unit_point)
     {
-      Assert(lvs[unit_point].size()==n_outer_apply, ExcInternalError());
+      Assert(lvs.n_cols()==n_outer_apply, ExcInternalError());
       Point<dim> p;
       for (unsigned int k=0; k<n_outer_apply; ++k)
        p+=lvs[unit_point][k]*a[k];
@@ -1068,11 +1056,10 @@ MappingQ<dim>::fill_quad_support_points_simple (const typename Triangulation<dim
 
 template <int dim>
 void
-MappingQ<dim>::transform_covariant (
-  typename std::vector<Tensor<1,dim> >::iterator begin,
-  typename std::vector<Tensor<1,dim> >::const_iterator end,
-  typename std::vector<Tensor<1,dim> >::const_iterator src,
-  const typename Mapping<dim>::InternalDataBase &mapping_data) const
+MappingQ<dim>::transform_covariant (Tensor<1,dim>       *begin,
+                                   Tensor<1,dim>       *end,
+                                   const Tensor<1,dim> *src,
+                                   const typename Mapping<dim>::InternalDataBase &mapping_data) const
 {
   const typename MappingQ1<dim>::InternalData *q1_data =
     dynamic_cast<const typename MappingQ1<dim>::InternalData *> (&mapping_data);
@@ -1101,11 +1088,10 @@ MappingQ<dim>::transform_covariant (
 
 template <int dim>
 void
-MappingQ<dim>::transform_contravariant (
-  typename std::vector<Tensor<1,dim> >::iterator begin,
-  typename std::vector<Tensor<1,dim> >::const_iterator end,
-  typename std::vector<Tensor<1,dim> >::const_iterator src,
-  const typename Mapping<dim>::InternalDataBase &mapping_data) const
+MappingQ<dim>::transform_contravariant (Tensor<1,dim>       *begin,
+                                       Tensor<1,dim>       *end,
+                                       const Tensor<1,dim> *src,
+                                       const typename Mapping<dim>::InternalDataBase &mapping_data) const
 {
   const typename MappingQ1<dim>::InternalData *q1_data =
     dynamic_cast<const typename MappingQ1<dim>::InternalData *> (&mapping_data);
index eb3ecc065b8a7a537e68279422fae717e81f8ba6..3a730fe226edfe393de90314bc382509f9f68526 100644 (file)
@@ -344,14 +344,13 @@ MappingQ1<dim>::compute_face_data (const UpdateFlags update_flags,
 #if (deal_II_dimension>1)
   if (data.update_flags & update_boundary_forms)
     {
-      data.aux.resize(dim-1);
-      for (unsigned int i=0;i<dim-1;++i)
-       data.aux[i].resize(n_original_q_points);
+      data.aux.reinit(dim-1, n_original_q_points);      
       
                                       // Compute tangentials to the
                                       // unit cell.
       const unsigned int nfaces = GeometryInfo<dim>::faces_per_cell;
-      data.unit_tangentials.resize(nfaces*(dim-1));
+      data.unit_tangentials.reinit(nfaces*(dim-1),
+                                  n_original_q_points);
       for (unsigned int i=0;i<nfaces;++i)
        {
                                           // Base index of the
@@ -368,7 +367,6 @@ MappingQ1<dim>::compute_face_data (const UpdateFlags update_flags,
                                           // non-zero in i.
          Tensor<1,dim> tangential;
          tangential[(nindex+1)%dim] = (this->normal_directions[i]%2) ? -1 : 1;
-         data.unit_tangentials[i].resize(n_original_q_points);
          std::fill (data.unit_tangentials[i].begin(),
                     data.unit_tangentials[i].end(),
                     tangential);
@@ -384,7 +382,6 @@ MappingQ1<dim>::compute_face_data (const UpdateFlags update_flags,
                                               // right-handed system.
              Tensor<1,dim> tangential;
              tangential[(nindex-1)%dim] = 1.;
-             data.unit_tangentials[i+nfaces].resize(n_original_q_points);
              std::fill (data.unit_tangentials[i+nfaces].begin(),
                         data.unit_tangentials[i+nfaces].end(),
                         tangential);
@@ -610,7 +607,7 @@ MappingQ1<dim>::compute_fill_face (const typename DoFHandler<dim>::cell_iterator
        result = boundary_forms.begin();
       typename std::vector<Tensor<1,dim> >::const_iterator
        end = boundary_forms.end();
-      typename std::vector<Tensor<1,dim> >::const_iterator
+      const Tensor<1,dim> *
        tang1 = data.aux[0].begin();
       
       switch (dim)
@@ -629,8 +626,7 @@ MappingQ1<dim>::compute_fill_face (const typename DoFHandler<dim>::cell_iterator
                                  data.unit_tangentials[
                                    face_no+GeometryInfo<dim>::faces_per_cell].begin(),
                                  data);
-         typename std::vector<Tensor<1,dim> >::const_iterator
-           tang2 = data.aux[1].begin();
+         const Tensor<1,dim> *tang2 = data.aux[1].begin();
          for (;result != end; ++result, ++tang1, ++tang2)
            cross_product (*result, *tang1, *tang2);
          break;
@@ -778,11 +774,10 @@ MappingQ1<1>::fill_fe_subface_values (const DoFHandler<1>::cell_iterator &,
 
 template <int dim>
 void
-MappingQ1<dim>::transform_covariant (
-  typename std::vector<Tensor<1,dim> >::iterator begin,
-  typename std::vector<Tensor<1,dim> >::const_iterator end,
-  typename std::vector<Tensor<1,dim> >::const_iterator src,
-  const typename Mapping<dim>::InternalDataBase &mapping_data) const
+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
 {
   const InternalData *data_ptr = dynamic_cast<const InternalData *> (&mapping_data);
   Assert(data_ptr!=0, ExcInternalError());
@@ -806,11 +801,10 @@ MappingQ1<dim>::transform_covariant (
 
 template <int dim>
 void
-MappingQ1<dim>::transform_contravariant (
-  typename std::vector<Tensor<1,dim> >::iterator begin,
-  typename std::vector<Tensor<1,dim> >::const_iterator end,
-  typename std::vector<Tensor<1,dim> >::const_iterator src,
-  const typename Mapping<dim>::InternalDataBase &mapping_data) const
+MappingQ1<dim>::transform_contravariant (Tensor<1,dim>       *begin,
+                                        Tensor<1,dim>       *end,
+                                        const Tensor<1,dim> *src,
+                                        const typename Mapping<dim>::InternalDataBase &mapping_data) const
 {
   const InternalData* data_ptr = dynamic_cast<const InternalData *> (&mapping_data);
   Assert(data_ptr!=0, ExcInternalError());

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.