]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Only run tests on the first cell, to reduce output from the many megabytes we current...
authorWolfgang Bangerth <bangerth@math.tamu.edu>
Tue, 25 Mar 2008 16:17:03 +0000 (16:17 +0000)
committerWolfgang Bangerth <bangerth@math.tamu.edu>
Tue, 25 Mar 2008 16:17:03 +0000 (16:17 +0000)
git-svn-id: https://svn.dealii.org/trunk@15934 0785d39b-7218-0410-832d-ea1e28bc413d

tests/deal.II/fe_values_view_01.cc
tests/deal.II/fe_values_view_02.cc

index d27c97acdf55fa7853e0ea5d471de5ac25549222..e5c5a7dcdd89d8e5cf392f074066519767c5d54b 100644 (file)
@@ -46,42 +46,38 @@ void test (const Triangulation<dim>& tr,
   const QGauss<dim> quadrature(2);
   FEValues<dim> fe_values (fe, quadrature,
                           update_values | update_gradients | update_hessians);
-  for (typename DoFHandler<dim>::active_cell_iterator
-        cell = dof.begin_active(); cell != dof.end(); ++cell)
-    {
-      fe_values.reinit (cell);
+  fe_values.reinit (dof.begin_active());
   
-      for (unsigned int c=0; c<fe.n_components(); ++c)
-       {
-         FEValuesExtractors::Scalar single_component (c);
-
-         for (unsigned int i=0; i<fe_values.dofs_per_cell; ++i)
-           for (unsigned int q=0; q<fe_values.n_quadrature_points; ++q)
-             {
-               deallog << "i=" << i << ", q=" << q << std::endl;
-               deallog << "   "
-                       << fe_values[single_component].value (i,q) << ' '
-                       << fe_values[single_component].gradient (i,q) << std::endl;
-               for (unsigned int k=0; k<dim; ++k)
-                 for (unsigned int l=0; l<dim; ++l)
-                   deallog << fe_values[single_component].hessian (i,q)[k][l] << std::endl;
-
-               Assert (fe_values[single_component].value (i,q)
-                       ==
-                       fe_values.shape_value_component (i,q,c),
-                       ExcInternalError());
-
-               Assert (fe_values[single_component].gradient (i,q)
-                       ==
-                       fe_values.shape_grad_component (i,q,c),
-                       ExcInternalError());
-
-               Assert (fe_values[single_component].hessian (i,q)
-                       ==
-                       fe_values.shape_hessian_component (i,q,c),
-                       ExcInternalError());
-             }
-       }
+  for (unsigned int c=0; c<fe.n_components(); ++c)
+    {
+      FEValuesExtractors::Scalar single_component (c);
+
+      for (unsigned int i=0; i<fe_values.dofs_per_cell; ++i)
+       for (unsigned int q=0; q<fe_values.n_quadrature_points; ++q)
+         {
+           deallog << "i=" << i << ", q=" << q << std::endl;
+           deallog << "   "
+                   << fe_values[single_component].value (i,q) << ' '
+                   << fe_values[single_component].gradient (i,q) << std::endl;
+           for (unsigned int k=0; k<dim; ++k)
+             for (unsigned int l=0; l<dim; ++l)
+               deallog << fe_values[single_component].hessian (i,q)[k][l] << std::endl;
+
+           Assert (fe_values[single_component].value (i,q)
+                   ==
+                   fe_values.shape_value_component (i,q,c),
+                   ExcInternalError());
+
+           Assert (fe_values[single_component].gradient (i,q)
+                   ==
+                   fe_values.shape_grad_component (i,q,c),
+                   ExcInternalError());
+
+           Assert (fe_values[single_component].hessian (i,q)
+                   ==
+                   fe_values.shape_hessian_component (i,q,c),
+                   ExcInternalError());
+         }
     }
 }
 
index a7d48f646a839650e205a32c5d42238e1695786c..3c7c18ca96d6315d715ef7a300c05a2508b8f167 100644 (file)
@@ -46,65 +46,61 @@ void test (const Triangulation<dim>& tr,
   const QGauss<dim> quadrature(2);
   FEValues<dim> fe_values (fe, quadrature,
                           update_values | update_gradients | update_hessians);
-  for (typename DoFHandler<dim>::active_cell_iterator
-        cell = dof.begin_active(); cell != dof.end(); ++cell)
-    {
-      fe_values.reinit (cell);
+  fe_values.reinit (dof.begin_active());
   
-      for (unsigned int c=0; c<fe.n_components(); ++c)
-                                        // use a vector extractor if there
-                                        // are sufficiently many components
-                                        // left after the current component
-                                        // 'c'
-       if (c+dim <= fe.n_components())
-         {
-           FEValuesExtractors::Vector vec_components (c);
-
-           for (unsigned int i=0; i<fe_values.dofs_per_cell; ++i)
-             for (unsigned int q=0; q<fe_values.n_quadrature_points; ++q)
-               {
-                 deallog << "i=" << i << ", q=" << q << std::endl;
-                 deallog << "   "
-                         << fe_values[vec_components].value (i,q) << ' '
-                         << fe_values[vec_components].gradient (i,q) << ' '
-                         << fe_values[vec_components].divergence (i,q) << ' '
-                         << fe_values[vec_components].symmetric_gradient (i,q) << std::endl;
-                 for (unsigned int k=0; k<dim; ++k)
-                   for (unsigned int l=0; l<dim; ++l)
-                     deallog << fe_values[vec_components].hessian (i,q)[k][l]
-                             << std::endl;
+  for (unsigned int c=0; c<fe.n_components(); ++c)
+                                    // use a vector extractor if there
+                                    // are sufficiently many components
+                                    // left after the current component
+                                    // 'c'
+    if (c+dim <= fe.n_components())
+      {
+       FEValuesExtractors::Vector vec_components (c);
+
+       for (unsigned int i=0; i<fe_values.dofs_per_cell; ++i)
+         for (unsigned int q=0; q<fe_values.n_quadrature_points; ++q)
+           {
+             deallog << "i=" << i << ", q=" << q << std::endl;
+             deallog << "   "
+                     << fe_values[vec_components].value (i,q) << ' '
+                     << fe_values[vec_components].gradient (i,q) << ' '
+                     << fe_values[vec_components].divergence (i,q) << ' '
+                     << fe_values[vec_components].symmetric_gradient (i,q) << std::endl;
+             for (unsigned int k=0; k<dim; ++k)
+               for (unsigned int l=0; l<dim; ++l)
+                 deallog << fe_values[vec_components].hessian (i,q)[k][l]
+                         << std::endl;
                  
-                 for (unsigned int d=0; d<dim; ++d)
-                   {
-                     Assert (fe_values[vec_components].value (i,q)[d]
-                             ==
-                             fe_values.shape_value_component (i,q,c+d),
-                             ExcInternalError());
-
-                     Assert (fe_values[vec_components].gradient (i,q)[d]
-                             ==
-                             fe_values.shape_grad_component (i,q,c+d),
-                             ExcInternalError());
-
-                     Assert (fe_values[vec_components].symmetric_gradient (i,q)
-                             ==
-                             (fe_values[vec_components].gradient(i,q) +
-                              transpose(fe_values[vec_components].gradient(i,q)))/2,
-                             ExcInternalError());
-                     
-                     Assert (fe_values[vec_components].hessian (i,q)[d]
-                             ==
-                             fe_values.shape_hessian_component (i,q,c+d),
-                             ExcInternalError());
-                   }
+             for (unsigned int d=0; d<dim; ++d)
+               {
+                 Assert (fe_values[vec_components].value (i,q)[d]
+                         ==
+                         fe_values.shape_value_component (i,q,c+d),
+                         ExcInternalError());
+
+                 Assert (fe_values[vec_components].gradient (i,q)[d]
+                         ==
+                         fe_values.shape_grad_component (i,q,c+d),
+                         ExcInternalError());
 
-                 Assert (fe_values[vec_components].divergence (i,q)
+                 Assert (fe_values[vec_components].symmetric_gradient (i,q)
+                         ==
+                         (fe_values[vec_components].gradient(i,q) +
+                          transpose(fe_values[vec_components].gradient(i,q)))/2,
+                         ExcInternalError());
+                     
+                 Assert (fe_values[vec_components].hessian (i,q)[d]
                          ==
-                         trace (fe_values[vec_components].gradient (i,q)),
+                         fe_values.shape_hessian_component (i,q,c+d),
                          ExcInternalError());
                }
-         }
-    }
+
+             Assert (fe_values[vec_components].divergence (i,q)
+                     ==
+                     trace (fe_values[vec_components].gradient (i,q)),
+                     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.