]> https://gitweb.dealii.org/ - dealii-svn.git/commitdiff
Small clean-ups.
authorwolf <wolf@0785d39b-7218-0410-832d-ea1e28bc413d>
Sun, 19 Oct 2003 22:27:26 +0000 (22:27 +0000)
committerwolf <wolf@0785d39b-7218-0410-832d-ea1e28bc413d>
Sun, 19 Oct 2003 22:27:26 +0000 (22:27 +0000)
git-svn-id: https://svn.dealii.org/trunk@8111 0785d39b-7218-0410-832d-ea1e28bc413d

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_q_hierarchical.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
deal.II/deal.II/source/fe/mapping_q1_eulerian.cc

index 5106e32986e69ff30eb08680255a8d0fd6318faf..90d06302b15b1809e69359cf6c931365d5ff3290 100644 (file)
@@ -193,7 +193,7 @@ template <int dim>
 std::vector<unsigned int>
 FE_DGP<dim>::get_dpo_vector(unsigned int deg)
 {
-  std::vector<unsigned int> dpo(dim+1, static_cast<unsigned int>(0));
+  std::vector<unsigned int> dpo(dim+1, 0U);
   dpo[dim] = ++deg;
   for (unsigned int i=1;i<dim;++i)
     {
index 79ace133ba9c0ff137df4f2a7a5a0f986d0dc45a..27162f0ccaa35c7757429fa9ce9b97a6b47f3107 100644 (file)
@@ -441,7 +441,7 @@ template <int dim>
 std::vector<unsigned int>
 FE_DGQ<dim>::get_dpo_vector(unsigned int deg)
 {
-  std::vector<unsigned int> dpo(dim+1, static_cast<unsigned int>(0));
+  std::vector<unsigned int> dpo(dim+1, 0U);
   dpo[dim] = ++deg;
   for (unsigned int i=1;i<dim;++i)
     dpo[dim] *= deg;
index f0a3aaa2ea28c565b863f8ae8dd2ed735ddac19d..35ce0dd89ffcd9d08303815b6ff7fb96a7a21fcc 100644 (file)
@@ -656,7 +656,7 @@ template <int dim>
 std::vector<unsigned int>
 FE_Q<dim>::get_dpo_vector(const unsigned int deg)
 {
-  std::vector<unsigned int> dpo(dim+1, static_cast<unsigned int>(1));
+  std::vector<unsigned int> dpo(dim+1, 1U);
   for (unsigned int i=1; i<dpo.size(); ++i)
     dpo[i]=dpo[i-1]*(deg-1);
   return dpo;
index 5a4ff175998276bbfaddd155ad874b5523d27a20..7a3413c53ac75aff4a6ae8ef83ecd591bfa4ad3c 100644 (file)
@@ -636,7 +636,7 @@ template <int dim>
 std::vector<unsigned int>
 FE_Q_Hierarchical<dim>::get_dpo_vector(const unsigned int deg)
 {
-  std::vector<unsigned int> dpo(dim+1, static_cast<unsigned int>(1));
+  std::vector<unsigned int> dpo(dim+1, 1U);
   for (unsigned int i=1; i<dpo.size(); ++i)
     dpo[i]=dpo[i-1]*(deg-1);
   return dpo;
index 5bfcb69184d59db26ab246deebe7e070d45fce12..c750a1657729600d53e78cdfa0627507deab6eda 100644 (file)
@@ -229,82 +229,63 @@ MappingCartesian<dim>::compute_fill (const typename DoFHandler<dim>::cell_iterat
                                   // cells are aligned to coordinate
                                   // axes, they are simply vectors
                                   // with exactly one entry equal to
-                                  // 1 or -1
+                                  // 1 or -1. Furthermore, all
+                                  // normals on a face have the same
+                                  // value
   if (update_flags & update_normal_vectors)
     {
       Assert (normal_vectors.size() == npts,
              ExcDimensionMismatch(normal_vectors.size(), npts));
-      Point<dim> n;
+      Assert (face_no < GeometryInfo<dim>::faces_per_cell,
+              ExcInternalError());
+      
       switch (dim)
         {
           case 2:
           {
-            switch (face_no)
-              {
-                case 0:
-                      n (1) = -1.;
-                      break;
-                case 1:
-                      n (0) = 1.;
-                      break;
-                case 2:
-                      n (1) = 1.;
-                      break;
-                case 3:
-                      n (0) = -1.;
-                      break;
-                default:
-                      Assert (false, ExcInternalError());
-              }
+            static const Point<dim>
+              normals[GeometryInfo<2>::faces_per_cell]
+              = { Point<dim>(0, -1),
+                  Point<dim>(1,  0),
+                  Point<dim>(0,  1),
+                  Point<dim>(-1, 0) };
+            std::fill (normal_vectors.begin(),
+                       normal_vectors.end(),
+                       normals[face_no]);
             break;
           }
 
           case 3:
           {
-            switch (face_no)
-              {
-                case 0:
-                      n (1) = -1.;
-                      break;
-                case 1:
-                      n (1) = 1.;
-                      break;
-                case 2:
-                      n (2) = -1.;
-                      break;
-                case 3:
-                      n (0) = 1.;
-                      break;
-                case 4:
-                      n (2) = 1.;
-                      break;
-                case 5:
-                      n (0) = -1.;
-                      break;
-                default:
-                      Assert (false, ExcInternalError());
-              }
+            static const Point<dim>
+              normals[GeometryInfo<3>::faces_per_cell]
+              = { Point<dim>(0, -1, 0),
+                  Point<dim>(0,  1, 0),
+                  Point<dim>(0,  0, -1),
+                  Point<dim>(1,  0, 0),
+                  Point<dim>(0,  0, 1),
+                  Point<dim>(-1, 0, 0) };
+            std::fill (normal_vectors.begin(),
+                       normal_vectors.end(),
+                       normals[face_no]);
             break;
           }
 
           default:
                 Assert (false, ExcNotImplemented());
         }
-      
-                                      // furthermore, all normal
-                                      // vectors on a face are equal
-      std::fill (normal_vectors.begin(), normal_vectors.end(), n);
     }
 }
 
 
 template <int dim>
 void
-MappingCartesian<dim>::fill_fe_values (const typename DoFHandler<dim>::cell_iterator& cell,
-                                      const Quadrature<dim>& q, 
-                                      typename Mapping<dim>::InternalDataBase& mapping_data,
-                                      std::vector<Point<dim> >& quadrature_points,
-                                      std::vector<double>& JxW_values) const
+MappingCartesian<dim>::
+fill_fe_values (const typename DoFHandler<dim>::cell_iterator& cell,
+                const Quadrature<dim>& q, 
+                typename Mapping<dim>::InternalDataBase& mapping_data,
+                std::vector<Point<dim> >& quadrature_points,
+                std::vector<double>& JxW_values) const
 {
                                   // convert data object to internal
                                   // data for this class. fails with
index 32c89cc490a9520e6d4273616936b04563caf975..f866768009f90e4ad75044ad636206550290088c 100644 (file)
@@ -925,8 +925,9 @@ MappingQ<3>::add_quad_support_points(const Triangulation<3>::cell_iterator &cell
 
 template<int dim>
 void
-MappingQ<dim>::add_quad_support_points(const typename Triangulation<dim>::cell_iterator &,
-                                      std::vector<Point<dim> > &) const
+MappingQ<dim>::
+add_quad_support_points(const typename Triangulation<dim>::cell_iterator &,
+                        std::vector<Point<dim> > &) const
 {
   Assert (dim > 2, ExcImpossibleInDim(dim));
 }
@@ -935,10 +936,11 @@ MappingQ<dim>::add_quad_support_points(const typename Triangulation<dim>::cell_i
 
 template <int dim>
 void
-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
+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);
@@ -958,10 +960,9 @@ MappingQ<dim>::transform_covariant (Tensor<1,dim>       *begin,
       else
        tensor = data->covariant.begin();    
     }
+
   while (begin!=end)
-    {
-      contract (*(begin++), *(src++), *(tensor++));
-    }
+    contract (*(begin++), *(src++), *(tensor++));
 }
 
 
@@ -991,20 +992,20 @@ MappingQ<dim>::transform_covariant (Tensor<2,dim>       *begin,
       else
        tensor = data->covariant.begin();
     }
+
   while (begin!=end)
-    {
-      contract (*(begin++), *(src++), *(tensor++));
-    }
+    contract (*(begin++), *(src++), *(tensor++));
 }
 
 
 
 template <int dim>
 void
-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
+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);
@@ -1024,10 +1025,9 @@ MappingQ<dim>::transform_contravariant (Tensor<1,dim>       *begin,
       else
        tensor = data->contravariant.begin();    
     }
+  
   while (begin!=end)
-    {
-      contract (*(begin++), *(tensor++), *(src++));
-    }
+    contract (*(begin++), *(tensor++), *(src++));
 }
 
 
@@ -1057,19 +1057,18 @@ MappingQ<dim>::transform_contravariant (Tensor<2,dim>       *begin,
       else
        tensor = data->contravariant.begin();    
     }
+
   while (begin!=end)
-    {
-      contract (*(begin++), *(tensor++), *(src++));
-    }
+    contract (*(begin++), *(tensor++), *(src++));
 }
 
 
 
 template <int dim>
 Point<dim>
-MappingQ<dim>::transform_unit_to_real_cell (
-  const typename Triangulation<dim>::cell_iterator &cell,
-  const Point<dim>                                 &p) const
+MappingQ<dim>::
+transform_unit_to_real_cell (const typename Triangulation<dim>::cell_iterator &cell,
+                             const Point<dim>                                 &p) const
 {
                                   // Use the get_data function to
                                   // create an InternalData with data
@@ -1077,55 +1076,53 @@ MappingQ<dim>::transform_unit_to_real_cell (
                                   // transformation shape values
                                   // already computed at point p.
   const Quadrature<dim> point_quadrature(p);
-  InternalData *mdata=dynamic_cast<InternalData *> (
-    get_data(update_transformation_values, point_quadrature));
-  Assert(mdata!=0, ExcInternalError());
+  std::auto_ptr<InternalData>
+    mdata (dynamic_cast<InternalData *> (
+             get_data(update_transformation_values, point_quadrature)));
   
   mdata->use_mapping_q1_on_current_cell = !(use_mapping_q_on_all_cells
                                            || cell->has_boundary_lines());
 
-  typename MappingQ1<dim>::InternalData *p_data=0;
-  if (mdata->use_mapping_q1_on_current_cell)
-    p_data=&mdata->mapping_q1_data;
-  else
-    p_data=mdata;
+  typename MappingQ1<dim>::InternalData
+    *p_data = (mdata->use_mapping_q1_on_current_cell ?
+               &mdata->mapping_q1_data :
+               &*mdata);
 
   compute_mapping_support_points(cell, p_data->mapping_support_points);
   
-  const Point<dim> q=this->transform_unit_to_real_cell_internal(*p_data);
-  delete mdata;
-  return q;
+  return this->transform_unit_to_real_cell_internal(*p_data);
 }
 
 
 
 template <int dim>
 Point<dim>
-MappingQ<dim>::transform_real_to_unit_cell (
-  const typename Triangulation<dim>::cell_iterator &cell,
-  const Point<dim>                                 &p) const
+MappingQ<dim>::
+transform_real_to_unit_cell (const typename Triangulation<dim>::cell_iterator &cell,
+                             const Point<dim>                                 &p) const
 {
                                   // first a Newton iteration based
                                   // on a Q1 mapping
-  Point<dim> p_unit=MappingQ1<dim>::transform_real_to_unit_cell(cell, p);
+  Point<dim> p_unit = MappingQ1<dim>::transform_real_to_unit_cell(cell, p);
   
+                                   // then a Newton iteration based on
+                                   // the full MappingQ if we need
+                                   // this
   if (cell->has_boundary_lines() || use_mapping_q_on_all_cells)
     {
-                                      // then a Newton iteration
-                                      // based on the full MappingQ
       const Quadrature<dim> point_quadrature(p_unit);
-      InternalData *mdata=dynamic_cast<InternalData *> (
-       get_data(update_transformation_values | update_transformation_gradients,
-                point_quadrature));
-      Assert(mdata!=0, ExcInternalError());
-      mdata->use_mapping_q1_on_current_cell=false;
+      std::auto_ptr<InternalData>
+        mdata (dynamic_cast<InternalData *> (
+                 get_data(update_transformation_values |
+                          update_transformation_gradients,
+                          point_quadrature)));
+      
+      mdata->use_mapping_q1_on_current_cell = false;
 
-      std::vector<Point<dim> > &points=mdata->mapping_support_points;
-      compute_mapping_support_points(cell, points);
+      std::vector<Point<dim> > &points = mdata->mapping_support_points;
+      compute_mapping_support_points (cell, points);
 
       this->transform_real_to_unit_cell_internal(cell, p, *mdata, p_unit);
-  
-      delete mdata;
     }
   
   return p_unit;
index 0c322fe21d99d341711473964bd7de50b008e79c..58a1704a9a5b23b324798286ccecd2b01f3a67eb 100644 (file)
@@ -844,10 +844,11 @@ 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,
-                                        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());
@@ -860,18 +861,18 @@ MappingQ1<dim>::transform_contravariant (Tensor<1,dim>       *begin,
     tensor = data.contravariant.begin();
   
   while (begin!=end)
-    {
-      contract (*(begin++), *(tensor++), *(src++));
-    }
+    contract (*(begin++), *(tensor++), *(src++));
 }
 
 
+
 template <int dim>
 void
-MappingQ1<dim>::transform_contravariant (Tensor<2,dim>       *begin,
-                                        Tensor<2,dim>       *end,
-                                        const Tensor<2,dim> *src,
-                                        const typename Mapping<dim>::InternalDataBase &mapping_data) const
+MappingQ1<dim>::
+transform_contravariant (Tensor<2,dim>       *begin,
+                         Tensor<2,dim>       *end,
+                         const Tensor<2,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());
@@ -884,18 +885,16 @@ MappingQ1<dim>::transform_contravariant (Tensor<2,dim>       *begin,
     tensor = data.contravariant.begin();
   
   while (begin!=end)
-    {
-      contract (*(begin++), *(tensor++), *(src++));
-    }
+    contract (*(begin++), *(tensor++), *(src++));
 }
 
 
 
 template <int dim>
 Point<dim>
-MappingQ1<dim>::transform_unit_to_real_cell (
-  const typename Triangulation<dim>::cell_iterator &cell,
-  const Point<dim>                                 &p) const
+MappingQ1<dim>::
+transform_unit_to_real_cell (const typename Triangulation<dim>::cell_iterator &cell,
+                             const Point<dim>                                 &p) const
 {
                                   // Use the get_data function to
                                   // create an InternalData with data
@@ -904,24 +903,23 @@ MappingQ1<dim>::transform_unit_to_real_cell (
                                   // already computed at point p.
   const Quadrature<dim> point_quadrature(p);
 
-  InternalData *mdata=dynamic_cast<InternalData *> (
-    get_data(update_transformation_values, point_quadrature));
-  Assert(mdata!=0, ExcInternalError());
+  std::auto_ptr<InternalData>
+    mdata (dynamic_cast<InternalData *> (
+             get_data(update_transformation_values, point_quadrature)));
 
                                   // compute the mapping support
                                   // points
   compute_mapping_support_points(cell, mdata->mapping_support_points);
 
-  const Point<dim> p_real=transform_unit_to_real_cell_internal(*mdata);
-  delete mdata;
-  return p_real;
+  return transform_unit_to_real_cell_internal(*mdata);
 }
 
 
+
 template <int dim>
 Point<dim>
-MappingQ1<dim>::transform_unit_to_real_cell_internal (
-  const InternalData &data) const
+MappingQ1<dim>::
+transform_unit_to_real_cell_internal (const InternalData &data) const
 {
   const unsigned int n_mapping_points=data.mapping_support_points.size();
   Assert(data.shape_values.size()==n_mapping_points, ExcInternalError());
@@ -930,17 +928,18 @@ MappingQ1<dim>::transform_unit_to_real_cell_internal (
                                   // compute the point in real space.
   Point<dim> p_real;
   for (unsigned int i=0; i<data.mapping_support_points.size(); ++i)
-    p_real+=data.mapping_support_points[i] * data.shape(0,i);
+    p_real += data.mapping_support_points[i] * data.shape(0,i);
 
   return p_real;
 }
 
 
+
 template <int dim>
 Point<dim>
-MappingQ1<dim>::transform_real_to_unit_cell (
-  const typename Triangulation<dim>::cell_iterator &cell,
-  const Point<dim>                                 &p) const
+MappingQ1<dim>::
+transform_real_to_unit_cell (const typename Triangulation<dim>::cell_iterator &cell,
+                             const Point<dim>                                 &p) const
 {
                                   // Let the start value of the
                                   // newton iteration be the center
@@ -956,20 +955,21 @@ MappingQ1<dim>::transform_real_to_unit_cell (
                                   // derivatives already computed at
                                   // point p_unit.
   const Quadrature<dim> point_quadrature(p_unit);
-  InternalData *mdata=dynamic_cast<InternalData *> (
-    MappingQ1<dim>::get_data(update_transformation_values
-                            | update_transformation_gradients,
-                            point_quadrature));
-  Assert(mdata!=0, ExcInternalError());
-
-  MappingQ1<dim>::compute_mapping_support_points(cell, mdata->mapping_support_points);
-  Assert(mdata->mapping_support_points.size()==GeometryInfo<dim>::vertices_per_cell,
+  std::auto_ptr<InternalData>
+    mdata(dynamic_cast<InternalData *> (
+            MappingQ1<dim>::get_data(update_transformation_values
+                                     | update_transformation_gradients,
+                                     point_quadrature)));
+
+  MappingQ1<dim>::compute_mapping_support_points (cell,
+                                                  mdata->mapping_support_points);
+  Assert(mdata->mapping_support_points.size() ==
+         GeometryInfo<dim>::vertices_per_cell,
         ExcInternalError());
 
                                   // perform the newton iteration.
   transform_real_to_unit_cell_internal(cell, p, *mdata, p_unit);
   
-  delete mdata;
   return p_unit;
 }
 
@@ -977,11 +977,12 @@ MappingQ1<dim>::transform_real_to_unit_cell (
 
 template <int dim>
 void
-MappingQ1<dim>::transform_real_to_unit_cell_internal (
-  const typename Triangulation<dim>::cell_iterator &cell,
-  const Point<dim>                                 &p,
-  InternalData                                     &mdata,
-  Point<dim>                                       &p_unit) const
+MappingQ1<dim>::
+transform_real_to_unit_cell_internal
+(const typename Triangulation<dim>::cell_iterator &cell,
+ const Point<dim>                                 &p,
+ InternalData                                     &mdata,
+ Point<dim>                                       &p_unit) const
 {
   const unsigned int n_shapes=mdata.shape_values.size();
   Assert(n_shapes!=0, ExcInternalError());
@@ -1036,7 +1037,7 @@ MappingQ1<dim>::transform_real_to_unit_cell_internal (
       compute_shapes(std::vector<Point<dim> > (1, p_unit), mdata);
       
                                       // f(x)
-      p_real=transform_unit_to_real_cell_internal(mdata);
+      p_real = transform_unit_to_real_cell_internal(mdata);
       f = p_real-p;
     }
 }
index 5d1e6527ae15e0b561b4c1bd53f3a51422d8fef5..40c83268a68e0457e2e1ed60a35499cd60a2d334 100644 (file)
@@ -66,13 +66,10 @@ MappingQ1Eulerian<dim>::compute_mapping_support_points(
              cell->index(),
              shiftmap_dof_handler);
 
-                                  // We require the cell to be
-                                  // active.  This is determined by
-                                  // the user when looping over all
-                                  // active cells in the problem
-                                  // code.
-  Assert (dof_cell->active() == true,
-          ExcInactiveCell());
+                                  // We require the cell to be active
+                                  // since we can only then get nodal
+                                  // values for the shifts
+  Assert (dof_cell->active() == true, ExcInactiveCell());
 
                                   // for Q1 elements, the number of
                                   // support points should equal the

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.