]> https://gitweb.dealii.org/ - dealii-svn.git/commitdiff
Convert unsigned int to types::global_dof_index in the tests.
authorturcksin <turcksin@0785d39b-7218-0410-832d-ea1e28bc413d>
Tue, 19 Mar 2013 23:35:21 +0000 (23:35 +0000)
committerturcksin <turcksin@0785d39b-7218-0410-832d-ea1e28bc413d>
Tue, 19 Mar 2013 23:35:21 +0000 (23:35 +0000)
git-svn-id: https://svn.dealii.org/branches/branch_bigger_global_dof_indices_4@28946 0785d39b-7218-0410-832d-ea1e28bc413d

80 files changed:
deal.II/include/deal.II/lac/eigen.h
tests/bits/count_dofs_per_block_01.cc
tests/bits/count_dofs_per_block_02.cc
tests/bits/count_dofs_per_component_hp_01.cc
tests/bits/data_out_common.h
tests/codim_one/interpolate_boundary_values_01.cc
tests/codim_one/interpolate_boundary_values_01_vector_valued.cc
tests/codim_one/interpolate_boundary_values_02.cc
tests/codim_one/interpolate_boundary_values_03.cc
tests/codim_one/interpolate_boundary_values_1d_closed_ring.cc
tests/codim_one/renumber_component_wise_01.cc
tests/deal.II/derivatives.cc
tests/deal.II/dof_handler_number_cache.cc
tests/deal.II/dof_handler_number_cache_02.cc
tests/deal.II/dof_renumbering.cc
tests/deal.II/dof_renumbering_02.cc
tests/deal.II/dof_renumbering_03.cc
tests/deal.II/dof_renumbering_04.cc
tests/deal.II/dof_renumbering_04a.cc
tests/deal.II/dof_renumbering_05.cc
tests/deal.II/dof_renumbering_06.cc
tests/deal.II/dof_renumbering_07.cc
tests/deal.II/dof_renumbering_zorder_01.cc
tests/deal.II/dof_renumbering_zorder_02.cc
tests/deal.II/extract_dofs_by_component_05.cc
tests/deal.II/extract_dofs_by_component_05_hp.cc
tests/deal.II/extract_dofs_by_component_06.cc
tests/deal.II/fe_values_view_21.cc
tests/deal.II/filtered_matrix.cc
tests/deal.II/grid_transform.cc
tests/deal.II/inhomogeneous_constraints_02.cc
tests/deal.II/inhomogeneous_constraints_03.cc
tests/deal.II/interpolate_boundary_values_02.cc
tests/fe/fe_q_dg0.cc
tests/hp/crash_16.cc
tests/hp/crash_19.cc
tests/hp/dof_handler_number_cache.cc
tests/hp/dof_renumbering_04.cc
tests/hp/dof_renumbering_05.cc
tests/hp/dof_renumbering_06.cc
tests/hp/fe_nothing_08.cc
tests/hp/fe_nothing_11.cc
tests/hp/matrices.cc
tests/hp/matrices_hp.cc
tests/hp/renumber_block_wise_01.cc
tests/hp/renumber_block_wise_01a.cc
tests/hp/renumber_block_wise_02.cc
tests/hp/renumber_component_wise.cc
tests/hp/step-12.cc
tests/lac/constraints_c1.cc
tests/lac/constraints_c1_02.cc
tests/lac/solver.cc
tests/lac/solver_relaxation_01.cc
tests/lac/solver_relaxation_03.cc
tests/lac/sparse_matrices.cc
tests/lac/sparsity_pattern.cc
tests/lac/sparsity_pattern_common.h
tests/matrix_free/integrate_functions.cc
tests/matrix_free/integrate_functions_multife.cc
tests/matrix_free/integrate_functions_multife2.cc
tests/matrix_free/matrix_vector_mg.cc
tests/matrix_free/matrix_vector_stokes.cc
tests/matrix_free/matrix_vector_stokes_noflux.cc
tests/matrix_free/step-37.cc
tests/mpi/count_dofs_per_block_01.cc
tests/mpi/count_dofs_per_block_02.cc
tests/mpi/count_dofs_per_component_01.cc
tests/mpi/distribute_sp_01.cc
tests/mpi/distribute_sp_02.cc
tests/mpi/map_dofs_to_support_points.cc
tests/mpi/mg_03.cc
tests/multigrid/transfer_compare_01.cc
tests/multigrid/transfer_system_04.cc
tests/multigrid/transfer_system_05.cc
tests/multigrid/transfer_system_adaptive_04.cc
tests/multigrid/transfer_system_adaptive_06.cc
tests/multigrid/transfer_system_adaptive_07.cc
tests/multigrid/transfer_system_adaptive_08.cc
tests/multigrid/transfer_system_adaptive_09.cc
tests/serialization/dof_handler_01.cc

index 1534bcaa92a74695648586bfc8a6b6ad4eeb2618..d0ccf1f91e3360361abd0dbb943ea3f5f365d12a 100644 (file)
@@ -144,6 +144,11 @@ template <class VECTOR = Vector<double> >
 class EigenInverse : private Solver<VECTOR>
 {
 public:
+  /**
+   * Declare type of container size.
+   */
+  typedef types::global_dof_index size_type;
+
   /**
    * Standardized data struct to
    * pipe additional data to the
index 64f510f82fee3ba01058524ff6587a210ba12a04..358308d8d699bf13071017cd5c70a06ac423dbb1 100644 (file)
@@ -75,13 +75,13 @@ check ()
 
                                   // no grouping
   {
-    std::vector<unsigned int> dpc(dim+1);
+    std::vector<types::global_dof_index> dpc(dim+1);
     DoFTools::count_dofs_per_component (dof_handler, dpc);
     print (dpc);
   }
 
   {
-    std::vector<unsigned int> dpc(dim+1);
+    std::vector<types::global_dof_index> dpc(dim+1);
     DoFTools::count_dofs_per_block (dof_handler, dpc);
     print (dpc);
   }
@@ -92,7 +92,7 @@ check ()
   {
     std::vector<unsigned int> group(dim+1, 0);
     group[dim] = 1;
-    std::vector<unsigned int> dpc(2);
+    std::vector<types::global_dof_index> dpc(2);
     DoFTools::count_dofs_per_component (dof_handler, dpc, false, group);
     Assert (dpc.size() == 2, ExcInternalError());
     print (dpc);
@@ -101,7 +101,7 @@ check ()
   {
     std::vector<unsigned int> group(dim+1, 0);
     group[dim] = 1;
-    std::vector<unsigned int> dpc(2);
+    std::vector<types::global_dof_index> dpc(2);
     DoFTools::count_dofs_per_block (dof_handler, dpc, group);
     Assert (dpc.size() == 2, ExcInternalError());
     print (dpc);
@@ -112,7 +112,7 @@ check ()
   {
     std::vector<unsigned int> group(dim+1, 2*dim);
     group[dim] = 0;
-    std::vector<unsigned int> dpc(2*dim+1);
+    std::vector<types::global_dof_index> dpc(2*dim+1);
     DoFTools::count_dofs_per_component (dof_handler, dpc, false, group);
     Assert (dpc.size() == 2*dim+1, ExcInternalError());
     print (dpc);
@@ -121,7 +121,7 @@ check ()
   {
     std::vector<unsigned int> group(dim+1, 2*dim);
     group[dim] = 0;
-    std::vector<unsigned int> dpc(2*dim+1);
+    std::vector<types::global_dof_index> dpc(2*dim+1);
     DoFTools::count_dofs_per_block (dof_handler, dpc, group);
     Assert (dpc.size() == 2*dim+1, ExcInternalError());
     print (dpc);
index affa5c9f3c931df89b2f5b6701d183b25b8ab3d8..fab2b1f1120093d692fb898a7d90bebae74fd810 100644 (file)
@@ -73,13 +73,13 @@ check ()
 
                                   // no grouping
   {
-    std::vector<unsigned int> dpc(dim+1);
+    std::vector<types::global_dof_index> dpc(dim+1);
     DoFTools::count_dofs_per_component (dof_handler, dpc);
     print (dpc);
   }
 
   {
-    std::vector<unsigned int> dpc(2);
+    std::vector<types::global_dof_index> dpc(2);
     DoFTools::count_dofs_per_block (dof_handler, dpc);
     print (dpc);
   }
@@ -90,7 +90,7 @@ check ()
   {
     std::vector<unsigned int> group(dim+1, 0);
     group[dim] = 1;
-    std::vector<unsigned int> dpc(2);
+    std::vector<types::global_dof_index> dpc(2);
     DoFTools::count_dofs_per_component (dof_handler, dpc, false, group);
     Assert (dpc.size() == 2, ExcInternalError());
     print (dpc);
@@ -99,7 +99,7 @@ check ()
   {
     std::vector<unsigned int> group(2, 0);
     group[1] = 1;
-    std::vector<unsigned int> dpc(2);
+    std::vector<types::global_dof_index> dpc(2);
     DoFTools::count_dofs_per_block (dof_handler, dpc, group);
     Assert (dpc.size() == 2, ExcInternalError());
     print (dpc);
@@ -110,7 +110,7 @@ check ()
   {
     std::vector<unsigned int> group(dim+1, 2*dim);
     group[dim] = 0;
-    std::vector<unsigned int> dpc(2*dim+1);
+    std::vector<types::global_dof_index> dpc(2*dim+1);
     DoFTools::count_dofs_per_component (dof_handler, dpc, false, group);
     Assert (dpc.size() == 2*dim+1, ExcInternalError());
     print (dpc);
@@ -119,7 +119,7 @@ check ()
   {
     std::vector<unsigned int> group(2, 2*dim);
     group[1] = 0;
-    std::vector<unsigned int> dpc(2*dim+1);
+    std::vector<types::global_dof_index> dpc(2*dim+1);
     DoFTools::count_dofs_per_block (dof_handler, dpc, group);
     Assert (dpc.size() == 2*dim+1, ExcInternalError());
     print (dpc);
index 96ad381c0352ddb17352decd48af51273814cc4b..2944cc5e5e705d6ad499158991867cb3ea5204ce 100644 (file)
@@ -53,8 +53,8 @@ void test ()
   dof_handler.distribute_dofs(fe_system);
 
   //count dofs per component and show them on the screen
-  std::vector<unsigned int> dofs_per_component(3,0);
-  std::vector<unsigned int> dofs_per_component_hp(3,0);
+  std::vector<types::global_dof_index> dofs_per_component(3,0);
+  std::vector<types::global_dof_index> dofs_per_component_hp(3,0);
   DoFTools::count_dofs_per_component(dof_handler, dofs_per_component);
   DoFTools::count_dofs_per_component(hp_dof_handler, dofs_per_component_hp);
 
index 800b573be50d7e41fc34babe179bc8abf3129e09..21344d8a9738bedf7997cd311abd8c02f2164f66 100644 (file)
@@ -53,7 +53,7 @@ void
 make_block_vector (const Vector<double> &in,
                    BlockVector<double>  &out)
 {
-  std::vector<unsigned int> block_sizes(2);
+  std::vector<types::global_dof_index> block_sizes(2);
   block_sizes[0] = in.size() / 2;
   block_sizes[1] = in.size() - block_sizes[0];
 
index 4229f17927d09e1a1e27dd016c1f0f792f229d23..d4904b9217494af03e49cf315342bf4d508111b3 100644 (file)
@@ -45,14 +45,14 @@ void test(std::string filename) {
 
     deallog << dof_handler.n_dofs() << " degrees of freedom" << std::endl;
 
-    std::map<unsigned int, double> bv;
+    std::map<types::global_dof_index, double> bv;
     VectorTools::interpolate_boundary_values (dof_handler,
                                              0,
                                              Functions::SquareFunction<spacedim>(),
                                              bv);
     deallog << bv.size() << " boundary degrees of freedom" << std::endl;
 
-    for (std::map<unsigned int, double>::const_iterator i = bv.begin();
+    for (std::map<types::global_dof_index, double>::const_iterator i = bv.begin();
         i != bv.end(); ++i)
       deallog << i->first << ' ' << i->second << std::endl;
 
index 7c3c5819665479988524d1dbb00b8cd6abedd9b1..ead9794ba12d8c9dfeb73893daed043820caa879 100644 (file)
@@ -61,14 +61,14 @@ void test(std::string filename) {
 
     deallog << dof_handler.n_dofs() << " degrees of freedom" << std::endl;
 
-    std::map<unsigned int, double> bv;
+    std::map<types::global_dof_index, double> bv;
     VectorTools::interpolate_boundary_values (dof_handler,
                                              0,
                                              X<spacedim>(),
                                              bv);
     deallog << bv.size() << " boundary degrees of freedom" << std::endl;
 
-    for (std::map<unsigned int, double>::const_iterator i = bv.begin();
+    for (std::map<types::global_dof_index, double>::const_iterator i = bv.begin();
         i != bv.end(); ++i)
       deallog << i->first << ' ' << i->second << std::endl;
 
index dc43396160bdf54f94683600afaf854f596e17c0..2ae6c3d28f3df981776bc3353912fc9d16437ea3 100644 (file)
@@ -48,14 +48,14 @@ void test() {
                                     // separatel
     for (unsigned int boundary_id=0; boundary_id<2; ++boundary_id)
       {
-       std::map<unsigned int, double> bv;
+       std::map<type::global_dof_index, double> bv;
        VectorTools::interpolate_boundary_values (dof_handler,
                                                  boundary_id,
                                                  Functions::SquareFunction<spacedim>(),
                                                  bv);
        deallog << bv.size() << " boundary degrees of freedom" << std::endl;
 
-       for (std::map<unsigned int, double>::const_iterator i = bv.begin();
+       for (std::map<types::global_dof_index, double>::const_iterator i = bv.begin();
             i != bv.end(); ++i)
          deallog << i->first << ' ' << i->second << std::endl;
 
index 225d791ccac7842ab136096cc2b714cba3fd527a..d1a95331ea2abc9ada73d29dd7d57ea24566c513 100644 (file)
@@ -55,7 +55,7 @@ void test() {
                                   // separately
   for (unsigned int boundary_id=0; boundary_id<2; ++boundary_id)
     {
-      std::map<unsigned int, double> bv;
+      std::map<types::global_dof_index, double> bv;
       VectorTools::interpolate_boundary_values (dof_handler,
                                                boundary_id,
                                                Functions::SquareFunction<spacedim>(),
index a90f16a23864eba7295ef06796ed7782f7aac37c..8bf60f5b1c9525479a8d2bc5b97b128083482700 100644 (file)
@@ -63,7 +63,7 @@ void test() {
                                     // separatel
     for (unsigned int boundary_id=0; boundary_id<2; ++boundary_id)
       {
-       std::map<unsigned int, double> bv;
+       std::map<types::global_dof_index, double> bv;
        VectorTools::interpolate_boundary_values (dof_handler,
                                                  boundary_id,
                                                  Functions::SquareFunction<spacedim>(),
index 51495e1e62b27bba1268afbf7e292331c8efcc15..c571c16725340db8d94c714ccb9de3df20b3e09c 100644 (file)
@@ -52,7 +52,7 @@ void test(std::string filename)
   for (typename DoFHandler<dim,spacedim>::active_cell_iterator
         cell = dof_handler.begin_active(); cell!=dof_handler.end(); ++cell)
     {
-      std::vector<unsigned int> x (cell->get_fe().dofs_per_cell);
+      std::vector<types::global_dof_index> x (cell->get_fe().dofs_per_cell);
       cell->get_dof_indices (x);
 
       deallog << cell << std::endl;
index 0d29793ef82c6bbf14f515ca7b7b506ba41a8b02..336fae9e152ef52e727184ab3dca08de406793e5 100644 (file)
@@ -74,7 +74,7 @@ check (const unsigned int level,
                    update_values
                    | update_q_points | update_JxW_values);
 
-  std::vector <unsigned int> global_dofs (element.dofs_per_cell);
+  std::vector <types::global_dof_index> global_dofs (element.dofs_per_cell);
   std::vector <double> function (quadrature.size());
 
   Vector<double> u (dof.n_dofs ());
index 1ffd746b59ec4d511ad6a5cfc8b4c59c4968f3c5..d5371c995191790a9dd8231d52c4f3f8b9e992cc 100644 (file)
@@ -92,7 +92,7 @@ void test()
       Assert (dof_handler.locally_owned_dofs() == all,
              ExcInternalError());
       Assert (dof_handler.n_locally_owned_dofs_per_processor() ==
-             std::vector<unsigned int> (1,N),
+             std::vector<types::global_dof_index> (1,N),
              ExcInternalError());
       Assert (dof_handler.locally_owned_dofs_per_processor() ==
              std::vector<IndexSet>(1,all),
index 34b68fd7e7ff197ca2368cd11821650c92163b54..73cc6512a3d81da469881f934b93d188e6c9c3d1 100644 (file)
@@ -90,7 +90,7 @@ void test()
       Assert (dof_handler.locally_owned_dofs() == all,
              ExcInternalError());
       Assert (dof_handler.n_locally_owned_dofs_per_processor() ==
-             std::vector<unsigned int> (1,N),
+             std::vector<types::global_dof_index> (1,N),
              ExcInternalError());
       Assert (dof_handler.locally_owned_dofs_per_processor() ==
              std::vector<IndexSet>(1,all),
index 4ff20a5017074d5ec32b4cd99e5a6da545d9e5fd..91b93e151d7606df9a392de6775cbb680ffad833 100644 (file)
@@ -40,7 +40,7 @@ template <int dim>
 void
 print_dofs (const DoFHandler<dim> &dof)
 {
-  std::vector<unsigned int> v (dof.get_fe().dofs_per_cell);
+  std::vector<types::global_dof_index> v (dof.get_fe().dofs_per_cell);
   for (typename DoFHandler<dim>::active_cell_iterator cell=dof.begin_active();
        cell != dof.end(); ++cell)
     {
index 17c337021f378890c06b7d6c64e72e96afb3d13b..eca4ea3ab94c7c4ed032cafa81dd4f8ca3b51683 100644 (file)
@@ -40,7 +40,7 @@ void
 print_dofs (const DoFHandler<dim> &dof)
 {
   const FiniteElement<dim>& fe = dof.get_fe();
-  std::vector<unsigned int> v (fe.dofs_per_cell);
+  std::vector<types::global_dof_index> v (fe.dofs_per_cell);
   std_cxx1x::shared_ptr<FEValues<dim> > fevalues;
 
   if (fe.has_support_points())
@@ -73,7 +73,7 @@ void
 print_dofs (const MGDoFHandler<dim> &dof, unsigned int level)
 {
   const FiniteElement<dim>& fe = dof.get_fe();
-  std::vector<unsigned int> v (fe.dofs_per_cell);
+  std::vector<types::global_dof_index> v (fe.dofs_per_cell);
   std_cxx1x::shared_ptr<FEValues<dim> > fevalues;
 
   if (fe.has_support_points())
index 936c85e9e2a29d6a69310a40a8828c100f9c4f29..18f6f585e1c2c8b9a40f7f4ad688c97c7b6a7b03 100644 (file)
@@ -40,7 +40,7 @@ void
 print_dofs (const DoFHandler<dim> &dof)
 {
   const FiniteElement<dim>& fe = dof.get_fe();
-  std::vector<unsigned int> v (fe.dofs_per_cell);
+  std::vector<types::global_dof_index> v (fe.dofs_per_cell);
   std_cxx1x::shared_ptr<FEValues<dim> > fevalues;
 
   if (fe.has_support_points())
index d72c082c1a0669be17dbe628c2b54d294b41c5bf..eafc0207aa53293f6b39f802836a5cb6f46d3218 100644 (file)
@@ -40,7 +40,7 @@ void
 print_dofs (const DoFHandler<dim> &dof)
 {
   const FiniteElement<dim>& fe = dof.get_fe();
-  std::vector<unsigned int> v (fe.dofs_per_cell);
+  std::vector<types::global_dof_index> v (fe.dofs_per_cell);
   std_cxx1x::shared_ptr<FEValues<dim> > fevalues;
 
   if (fe.has_support_points())
index f104118487ac8d92d0c2e2bd52c1a6c592fec6a2..3bb924e0ce40bccdd4768ef9365fcf2067c2b3b7 100644 (file)
@@ -40,7 +40,7 @@ template <int dim>
 void
 print_dofs (const DoFHandler<dim> &dof)
 {
-  std::vector<unsigned int> v (dof.get_fe().dofs_per_cell);
+  std::vector<types::global_dof_index> v (dof.get_fe().dofs_per_cell);
 
   for (typename DoFHandler<dim>::active_cell_iterator cell=dof.begin_active();
        cell != dof.end(); ++cell)
index 317df05728792adb44c0986cf6b405cf444a8042..02fc1c4e7893de51aa73285f9c121b8f140e771d 100644 (file)
@@ -40,7 +40,7 @@ void
 print_dofs (const DoFHandler<dim> &dof)
 {
   const FiniteElement<dim>& fe = dof.get_fe();
-  std::vector<unsigned int> v (fe.dofs_per_cell);
+  std::vector<types::global_dof_index> v (fe.dofs_per_cell);
   std_cxx1x::shared_ptr<FEValues<dim> > fevalues;
 
   if (fe.has_support_points())
index 6cffb2ecb2bbf73fcada6a3522e30d86e2676a40..1b13639588331ca062cb9ac3f57587bd3be79b6d 100644 (file)
@@ -40,7 +40,7 @@ void
 print_dofs (const DoFHandler<dim> &dof)
 {
   const FiniteElement<dim>& fe = dof.get_fe();
-  std::vector<unsigned int> v (fe.dofs_per_cell);
+  std::vector<types::global_dof_index> v (fe.dofs_per_cell);
   std_cxx1x::shared_ptr<FEValues<dim> > fevalues;
 
   if (fe.has_support_points())
index 5f020cf281661e572d034a4e6c43cd3c4a566630..08f53a83f93b4a27163e0e95e4a534bbf24d71c7 100644 (file)
@@ -39,7 +39,7 @@ void
 print_dofs (const DoFHandler<dim> &dof)
 {
   const FiniteElement<dim>& fe = dof.get_fe();
-  std::vector<unsigned int> v (fe.dofs_per_cell);
+  std::vector<types::global_dof_index> v (fe.dofs_per_cell);
   std_cxx1x::shared_ptr<FEValues<dim> > fevalues;
 
   if (fe.has_support_points())
index f5f6f0e0dbb3feb36462b5a9e293f516b7e88890..ffd0d90ec9c9defed790e20db5eea2d7da0127e6 100644 (file)
@@ -38,7 +38,7 @@ void
 print_dofs (const DoFHandler<dim> &dof, stream & out)
 {
   const FiniteElement<dim>& fe = dof.get_fe();
-  std::vector<unsigned int> v (fe.dofs_per_cell);
+  std::vector<types::global_dof_index> v (fe.dofs_per_cell);
   std_cxx1x::shared_ptr<FEValues<dim> > fevalues;
 
   if (fe.has_support_points())
index 35960c6e60551fa7f3db228bf53b79251f88816b..d2641d113c70563d68ab3aa5e1efc942956d8800 100644 (file)
@@ -41,7 +41,7 @@ print_dofs (const DoFHandler<dim> &dof, stream & out)
   out << std::setprecision (2);
   out << std::fixed;
   const FiniteElement<dim>& fe = dof.get_fe();
-  std::vector<unsigned int> v (fe.dofs_per_cell);
+  std::vector<types::global_dof_index> v (fe.dofs_per_cell);
   std_cxx1x::shared_ptr<FEValues<dim> > fevalues;
 
   if (fe.has_support_points())
index e0bf695b15db9cc5c38acc7460b58dc195165483..392fb5b5537649a9b22754db64d4cfa3544e9ff0 100644 (file)
@@ -53,7 +53,7 @@ check ()
   DoFHandler<dim> dof(tr);
   dof.distribute_dofs(element);
 
-  std::vector<unsigned int> count (element.n_components());
+  std::vector<types::global_dof_index> count (element.n_components());
   DoFTools::count_dofs_per_component (dof, count, false);
 
   for (unsigned int d=0; d<count.size(); ++d)
index 9899bb1c56278f777958976739bfd2e59a11a21d..8f47cd1eaf543f2737d120222daf686c816be46f 100644 (file)
@@ -57,7 +57,7 @@ check ()
   dof.begin_active()->set_active_fe_index(1);
   dof.distribute_dofs(element);
 
-  std::vector<unsigned int> count (element.n_components());
+  std::vector<types::global_dof_index> count (element.n_components());
   DoFTools::count_dofs_per_component (dof, count, false);
 
   for (unsigned int d=0; d<count.size(); ++d)
index d54213746c9ff96775dea0500ef76bee19da5a56..ce1aec61270ca15c937e030aec1ff67ac5bd178d 100644 (file)
@@ -53,7 +53,7 @@ check ()
   DoFHandler<dim> dof(tr);
   dof.distribute_dofs(element);
 
-  std::vector<unsigned int> count (element.n_components());
+  std::vector<types::global_dof_index> count (element.n_components());
   DoFTools::count_dofs_per_component (dof, count, true);
 
   for (unsigned int d=0; d<count.size(); ++d)
index bef9209bbe1c9cd689b61f60e948fc9a7b06720c..422c7863dfa7a0a99f5a0fc3c600941a63b0abb5 100644 (file)
@@ -104,7 +104,7 @@ void MixedElastoPlasticity<dim>::make_grid_and_dofs()
   DoFRenumbering::component_wise(dof_handler);
 
                                   // total number of dof per block component
-  std::vector<unsigned int> dofs_per_block(2);
+  std::vector<types::global_dof_index> dofs_per_block(2);
   DoFTools::count_dofs_per_block(dof_handler, dofs_per_block, block_component);
 
   const unsigned int n_stress_dof = dofs_per_block[0];
index 6f69072c6964a12f264466f510678163e7d17219..bce56ebe86da9a0702f723542438b8f12bfb9d79 100644 (file)
@@ -77,7 +77,7 @@ solve_filtered (std::map<unsigned int,double> &bv,
 
 template <int dim>
 void
-solve_eliminated (std::map<unsigned int,double> &bv,
+solve_eliminated (std::map<types::global_dof_index,double> &bv,
                  SparseMatrix<double>          &A,
                  Vector<double>                &u,
                  Vector<double>                &f)
@@ -121,7 +121,7 @@ check ()
                    update_values | update_gradients
                    | update_q_points | update_JxW_values);
 
-  std::vector <unsigned int> global_dofs (element.dofs_per_cell);
+  std::vector <types::global_dof_index> global_dofs (element.dofs_per_cell);
   std::vector <double> function (quadrature.size());
 
   Vector<double> f (dof.n_dofs ());
@@ -165,13 +165,13 @@ check ()
     }
 
                                   // interpolate boundary values
-  std::map<unsigned int,double> bv;
+  std::map<types::global_dof_index,double> bv;
   VectorTools::interpolate_boundary_values (mapping, dof, 0, cosine, bv, std::vector<bool>());
                                   // the cosine has too many zero
                                   // values on the boundary of the
                                   // domain, so reset the elements to
                                   // some other value
-  for (typename std::map<unsigned int,double>::iterator i=bv.begin();
+  for (typename std::map<types::global_dof_index,double>::iterator i=bv.begin();
        i!=bv.end(); ++i)
     i->second = std::sin(i->second+0.5)+1.0;
 
index 2891a3054c3870dac89acecf949f97c067a8ddc6..44b49f8b81cb564ae3b9053951b1d27f7e5bc293 100644 (file)
@@ -42,7 +42,7 @@ int main ()
                                   // build up a map of vertex indices
                                   // of boundary vertices to the new
                                   // boundary points
-  std::map<unsigned int,Point<dim> > new_points;
+  std::map<types::global_dof_index,Point<dim> > new_points;
   
                                   // new center and new radius
                                   // of the inner circle.
@@ -68,7 +68,7 @@ int main ()
                                                       // leave the
                                                       // point, where
                                                       // they are.
-                     new_points.insert(std::pair<unsigned int, Point<dim> > (
+                     new_points.insert(std::pair<types::global_dof_index, Point<dim> > (
                        face->vertex_index(vertex_no), v));
                    }
                  else if (std::fabs(std::sqrt(v.square())-inner_radius)<1e-12)
@@ -82,7 +82,7 @@ int main ()
                                                       // the radius
                                                       // of the
                                                       // circle.
-                     new_points.insert(std::pair<unsigned int, Point<dim> > (
+                     new_points.insert(std::pair<types::global_dof_index, Point<dim> > (
                        face->vertex_index(vertex_no), n_radius/inner_radius*v+n_center));
                      face->set_boundary_indicator(1);
                    }
index 43f7789151d0c7d0e65231ddb9678db3556f2323..e7bf753c5cfd802fc725a61a4e2a75b597c65e7b 100644 (file)
@@ -76,7 +76,7 @@ void test(bool use_inhomogeneity_for_rhs)
   SparseMatrix<double> mat(sp);
   Vector<double> rhs(5);
 
-  std::vector<unsigned int> local_dofs;
+  std::vector<types::global_dof_index> local_dofs;
   for (unsigned int i=0;i<5;++i)
     local_dofs.push_back(i);
 
index 75102a78963306a646125608a1a45fe933e10abd..61b8b720c5eef7ba431a2e16990d016e0624d215 100644 (file)
@@ -81,11 +81,11 @@ void test(bool use_inhomogeneity_for_rhs)
 
   // "assemble":
 
-  std::vector<unsigned int> local_dofs1;
+  std::vector<types::global_dof_index> local_dofs1;
   for (unsigned int i=0;i<5;++i)
     local_dofs1.push_back(i);
 
-  std::vector<unsigned int> local_dofs2;
+  std::vector<types::global_dof_index> local_dofs2;
   local_dofs2.push_back(1);
   for (unsigned int i=1;i<5;++i)
     local_dofs2.push_back(3+i);
index 985ab1c6da98a8bc570594e174c449472fdc967a..bde597b6332b6a02f2720af447a666628c807672 100644 (file)
@@ -64,7 +64,7 @@ void test ()
                                             Functions::SquareFunction<dim>(),
                                             boundary_values);
   deallog << boundary_values.size() << std::endl;
-  for (std::map<unsigned int,double>::const_iterator
+  for (std::map<types::global_dof_index,double>::const_iterator
         p = boundary_values.begin();
        p != boundary_values.end(); ++p)
     deallog << p->first << ' ' << p->second << std::endl;
index 17156aaeffe8141ea6c2e05d9029560c6480578d..bd8d233cbb3ec7e286f5b6065484476e95521d3f 100644 (file)
@@ -450,7 +450,7 @@ namespace Step22
 
     constraints.close ();
 
-    std::vector<unsigned int> dofs_per_block (2);
+    std::vector<types::global_dof_index> dofs_per_block (2);
     DoFTools::count_dofs_per_block (dof_handler, dofs_per_block,
                                     block_component);
     const unsigned int n_u = dofs_per_block[0],
index 956d094f5523da6fb03f41cf6f16a065473e23e7..5405f3f124b08d5c2ca7a1b2768943002a9b2dd9 100644 (file)
@@ -70,8 +70,8 @@ void test ()
                                   // loop over all lines and make sure that
                                   // all the DoF indices on these lines are
                                   // identical
-  std::vector<unsigned int> indices_1;
-  std::vector<unsigned int> indices_2;
+  std::vector<types::global_dof_index> indices_1;
+  std::vector<types::global_dof_index> indices_2;
 
   std::set<unsigned int> line_already_treated;
 
index d6add85e3df12f7b9c6fed2141942b3dc4633135..693a0f90e96538ea5e4bd433bfffff7a683017bb 100644 (file)
@@ -100,7 +100,7 @@ void test ()
                                              exact_solution,
                                              boundary_values);
 
-  for (std::map<unsigned int,double>::iterator i=boundary_values.begin();
+  for (std::map<types::global_dof_index,double>::iterator i=boundary_values.begin();
        i != boundary_values.end(); ++i)
     deallog << i->first << ' ' << i->second << std::endl;
 }
index 317ccba627da7ee6d1f5916371c98cd63e657fb0..5dedf2dca560b881b02584b6ed9c9c96ef017b1f 100644 (file)
@@ -102,7 +102,7 @@ void test()
       Assert (dof_handler.locally_owned_dofs() == all,
              ExcInternalError());
       Assert (dof_handler.n_locally_owned_dofs_per_processor() ==
-             std::vector<unsigned int> (1,N),
+             std::vector<types::global_dof_index> (1,N),
              ExcInternalError());
       Assert (dof_handler.locally_owned_dofs_per_processor() ==
              std::vector<IndexSet>(1,all),
index 43362a94148eebd51b01e3d07bb19943992894a8..be68d8a2624d6ccaef303fb0ff8ffdb16475b418 100644 (file)
@@ -39,7 +39,7 @@ template <int dim>
 void
 print_dofs (const hp::DoFHandler<dim> &dof)
 {
-  std::vector<unsigned int> v;
+  std::vector<types::global_dof_index> v;
   for (typename hp::DoFHandler<dim>::active_cell_iterator cell=dof.begin_active();
        cell != dof.end(); ++cell)
     {
index 0739f745c5b23661fe93b00ae3550b0fc51dae22..5cd9a9be3d56eef4409989a48e41f7938576b855 100644 (file)
@@ -39,7 +39,7 @@ template <int dim>
 void
 print_dofs (const hp::DoFHandler<dim> &dof)
 {
-  std::vector<unsigned int> v;
+  std::vector<types::global_dof_index> v;
   for (typename hp::DoFHandler<dim>::active_cell_iterator cell=dof.begin_active();
        cell != dof.end(); ++cell)
     {
index de23ff3cb1476e8732c5aa29265f6e70cd4e08a6..b4b9548c4bd1fa7dbc6dce4cf3bceb953245cfbd 100644 (file)
@@ -39,7 +39,7 @@ template <int dim>
 void
 print_dofs (const hp::DoFHandler<dim> &dof)
 {
-  std::vector<unsigned int> v;
+  std::vector<types::global_dof_index> v;
   for (typename hp::DoFHandler<dim>::active_cell_iterator cell=dof.begin_active();
        cell != dof.end(); ++cell)
     {
index 7e9b37e357449c70bddaf7cbc79eb75f1e134bd9..c8aa6e51c13076fa7a200eeb3063e2cb5508f8fa 100644 (file)
@@ -65,12 +65,12 @@ void test ()
   dof_handler.distribute_dofs (fe_collection);
   deallog << dof_handler.n_dofs() << " dofs" << std::endl;
 
-  std::map<unsigned int, double> bv;
+  std::map<types::global_dof_index, double> bv;
   VectorTools::interpolate_boundary_values (dof_handler,
                                            0,
                                            ZeroFunction<dim>(1),
                                            bv);
-  for (std::map<unsigned int, double>::iterator
+  for (std::map<types::global_dof_index, double>::iterator
         p = bv.begin(); p!=bv.end(); ++p)
     deallog << p->first << ' ' << p->second << std::endl;
 }
index 2e536e19e26486f6d2295c9f36b08d95509ce068..8aa4b34f50a5b9dac118f671856d83a15b081a95 100644 (file)
@@ -69,12 +69,12 @@ void test ()
   dof_handler.distribute_dofs (fe_collection);
   deallog << dof_handler.n_dofs() << " dofs" << std::endl;
 
-  std::map<unsigned int, double> bv;
+  std::map<types::global_dof_index, double> bv;
   VectorTools::interpolate_boundary_values (dof_handler,
                                            0,
                                            ZeroFunction<dim>(4),
                                            bv);
-  for (std::map<unsigned int, double>::iterator
+  for (std::map<types::global_dof_index, double>::iterator
         p = bv.begin(); p!=bv.end(); ++p)
     deallog << p->first << ' ' << p->second << std::endl;
 }
index 61f8c6f9a2e692b21df3dbe84d4fed2535321e93..5cc50064799166db25188f8e79b158deff0063ea 100644 (file)
@@ -72,7 +72,7 @@ check_boundary (const hp::DoFHandler<dim> &dof,
   hp::QCollection<dim-1> face_quadrature;
   face_quadrature.push_back (QGauss<dim-1>(6));
   
-  std::vector<unsigned int> dof_to_boundary_mapping;
+  std::vector<dof_index> dof_to_boundary_mapping;
   DoFTools::map_dof_to_boundary_indices (dof,
                                         dof_to_boundary_mapping);
 
index 0c05043902cbdc983fe8f18a84bb5883ca65ba83..121d9ef7a253625620427beec34cedf1002ce9fb 100644 (file)
@@ -71,7 +71,7 @@ check_boundary (const hp::DoFHandler<dim> &dof,
   for (unsigned int i=1; i<7-dim; ++i)
     face_quadrature.push_back (QGauss<dim-1>(3+i));
   
-  std::vector<unsigned int> dof_to_boundary_mapping;
+  std::vector<types::global_dof_index> dof_to_boundary_mapping;
   DoFTools::map_dof_to_boundary_indices (dof,
                                         dof_to_boundary_mapping);
 
index 4eb2a55aa04c7907ecee56c0906d3d09b5f6c43e..7404a49bc8c56815870143ad30229f991f96e728 100644 (file)
 
 
 template <int dim>
-std::vector<unsigned int>
+std::vector<types::global_dof_index>
 get_dofs (const hp::DoFHandler<dim> &dof)
 {
-  std::vector<unsigned int> local;
-  std::vector<unsigned int> global;
+  std::vector<types::global_dof_index> local;
+  std::vector<types::global_dof_index> global;
   for (typename hp::DoFHandler<dim>::active_cell_iterator cell=dof.begin_active();
        cell != dof.end(); ++cell)
     {
@@ -66,11 +66,11 @@ check_renumbering(hp::DoFHandler<dim>& dof)
                                   // do component-wise and save the
                                   // results
   DoFRenumbering::component_wise (dof);
-  const std::vector<unsigned int> vc = get_dofs (dof);
+  const std::vector<types::global_dof_index> vc = get_dofs (dof);
 
                                   // now do the same with blocks
   DoFRenumbering::block_wise (dof);
-  const std::vector<unsigned int> vb = get_dofs (dof);
+  const std::vector<types::global_dof_index> vb = get_dofs (dof);
 
   Assert (vc == vb, ExcInternalError());
 
index e3f4c54abe1d09096ee02607f0a26a7f0c35b2b1..75fd72215e628922ccf38208f1a9950d58a4db56 100644 (file)
@@ -42,8 +42,8 @@ template <int dim>
 std::vector<unsigned int>
 get_dofs (const hp::DoFHandler<dim> &dof)
 {
-  std::vector<unsigned int> local;
-  std::vector<unsigned int> global;
+  std::vector<types::global_dof_index> local;
+  std::vector<types::global_dof_index> global;
   for (typename hp::DoFHandler<dim>::active_cell_iterator cell=dof.begin_active();
        cell != dof.end(); ++cell)
     {
index 771d28d398b9f226a640713b55db2478a674daba..98d39195af83dbc95c135bcffb8361b144f7e100 100644 (file)
 
 
 template <int dim>
-std::vector<unsigned int>
+std::vector<types::global_dof_index>
 get_dofs (const hp::DoFHandler<dim> &dof)
 {
-  std::vector<unsigned int> local;
-  std::vector<unsigned int> global;
+  std::vector<types::global_dof_index> local;
+  std::vector<types::global_dof_index> global;
   for (typename hp::DoFHandler<dim>::active_cell_iterator cell=dof.begin_active();
        cell != dof.end(); ++cell)
     {
@@ -76,11 +76,11 @@ check_renumbering(hp::DoFHandler<dim>& dof)
                                   // do component-wise and save the
                                   // results
   DoFRenumbering::component_wise (dof, order);
-  const std::vector<unsigned int> vc = get_dofs (dof);
+  const std::vector<types::global_dof_index> vc = get_dofs (dof);
 
                                   // now do the same with blocks
   DoFRenumbering::block_wise (dof);
-  const std::vector<unsigned int> vb = get_dofs (dof);
+  const std::vector<types::global_dof_index> vb = get_dofs (dof);
 
   Assert (vc == vb, ExcInternalError());
 
index dba4384303ee6e7d7a7d82099746e4dda7046691..6acab0ab7c5ef80c56a6ceb04469ef0022223278 100644 (file)
@@ -41,7 +41,7 @@ template <int dim>
 void
 print_dofs (const hp::DoFHandler<dim> &dof)
 {
-  std::vector<unsigned int> v;
+  std::vector<types::global_dof_index> v;
   for (typename hp::DoFHandler<dim>::active_cell_iterator cell=dof.begin_active();
        cell != dof.end(); ++cell)
     {
index cf4d2fe04751174b307f4343e654b048da843774..87c27cb46d92694a081b37bd8f624ce8eeb30603 100644 (file)
@@ -405,8 +405,8 @@ template <int dim>
 void DGMethod<dim>::assemble_system1 () 
 {
   const unsigned int dofs_per_cell = dof_handler.get_fe()[0].dofs_per_cell;
-  std::vector<unsigned int> dofs (dofs_per_cell);
-  std::vector<unsigned int> dofs_neighbor (dofs_per_cell);
+  std::vector<types::global_dof_index> dofs (dofs_per_cell);
+  std::vector<types::global_dof_index> dofs_neighbor (dofs_per_cell);
 
   const UpdateFlags update_flags = update_values
                                    | update_gradients
index 338eb1eef527d89d5dc5caea8642169be082b857..ecdbf6c39a1f4c954fe09b33e60548c23982cc53 100644 (file)
@@ -62,8 +62,8 @@ setup_constraints(const DoFHandler<dim>& dof_handler)
        }      
     }
   
-  std::vector<unsigned int> cell_indices(fe.dofs_per_cell);
-  std::vector<unsigned int> neighbor_indices(fe.dofs_per_cell);
+  std::vector<types::global_dof_index> cell_indices(fe.dofs_per_cell);
+  std::vector<types::global_dof_index> neighbor_indices(fe.dofs_per_cell);
   
   for (typename DoFHandler<dim>::active_cell_iterator cell = dof_handler.begin_active();
        cell != dof_handler.end();++cell)
@@ -90,7 +90,7 @@ setup_constraints(const DoFHandler<dim>& dof_handler)
              
              const unsigned int d = GeometryInfo<dim>::unit_normal_direction[other_face];
              
-             std::vector<std::pair<unsigned int, double> > rhs;
+             std::vector<std::pair<types::global_dof_index, double> > rhs;
              const unsigned int constrained = fe.face_to_cell_index(
                (fvertex == 0) ? 2 : fe.dofs_per_face-1, face);
              double constrained_weight = 0.;
index a26fb1519aba1e78fbd293b678bcf73a8336fb30..c53f78c7f7cbf8743a7786275656f54bd1f71b02 100644 (file)
@@ -27,23 +27,23 @@ run()
 
   {
   constraints.add_line(7);
-  std::vector<std::pair<unsigned int, double> > rhs;
-  rhs.push_back(std::pair<unsigned int, double>(41,1.0));
-  rhs.push_back(std::pair<unsigned int, double>(42,1.0));
+  std::vector<std::pair<types::global_dof_index, double> > rhs;
+  rhs.push_back(std::pair<types::global_dof_index, double>(41,1.0));
+  rhs.push_back(std::pair<types::global_dof_index, double>(42,1.0));
   constraints.add_entries(7, rhs);
   }
 
   {
   constraints.add_line(41);
-  std::vector<std::pair<unsigned int, double> > rhs;
-  rhs.push_back(std::pair<unsigned int, double>(42,1.0));
+  std::vector<std::pair<types::global_dof_index, double> > rhs;
+  rhs.push_back(std::pair<types::global_dof_index, double>(42,1.0));
   constraints.add_entries(41, rhs);
   }
 
   {
   constraints.add_line(42);
-  std::vector<std::pair<unsigned int, double> > rhs;
-  rhs.push_back(std::pair<unsigned int, double>(41,1.0));
+  std::vector<std::pair<types::global_dof_index, double> > rhs;
+  rhs.push_back(std::pair<types::global_dof_index, double>(41,1.0));
   constraints.add_entries(42, rhs);
   }
 
index 07ad60d193646c8999bb9e75d67d3c1d339eec8b..1b5fa4cf788891fd9a3e9ce8912897b1fc46bae1 100644 (file)
@@ -106,8 +106,8 @@ int main()
       PreconditionSSOR<> prec_ssor;
       prec_ssor.initialize(A, 1.2);
 
-      std::vector<unsigned int> permutation(dim);
-      std::vector<unsigned int> inverse_permutation(dim);
+      std::vector<types::global_dof_index> permutation(dim);
+      std::vector<types::global_dof_index> inverse_permutation(dim);
 
                                       // Create a permutation: Blocks
                                       // backwards and every second
index b5a680f11c567fde846fe866db1d7006925b8ac6..90cfc458fbc44cf3ed988dc58d6912695bf9856a 100644 (file)
@@ -134,8 +134,8 @@ int main()
       PreconditionSOR<> prec_sor;
       prec_sor.initialize(A, 1.);
 
-      std::vector<unsigned int> permutation(dim);
-      std::vector<unsigned int> inverse_permutation(dim);
+      std::vector<types::global_dof_index> permutation(dim);
+      std::vector<types::global_dof_index> inverse_permutation(dim);
 
                                       // Create a permutation: Blocks
                                       // backwards and every second
index 7050b697d46eb2d65db8de85de350c8d3580eb2e..9d059c2afec2dcc048b34fdd7f1909316b79064d 100644 (file)
@@ -77,8 +77,8 @@ int main()
       testproblem.five_point(A, true);
 
                                       // The permutation vectors;
-      std::vector<unsigned int> perm(dim);
-      std::vector<unsigned int> iperm(dim);
+      std::vector<types::global_dof_index> perm(dim);
+      std::vector<types::global_dof_index> iperm(dim);
       
       for (unsigned int blocksize = 4; blocksize < 32; blocksize <<= 1)
        {
index b12541bc742cda0c785e31a7f0d0c1ebdc9fba1a..f3fd33f52cbb9b21c5bf6fb05efe35ea2d5c6ed5 100644 (file)
@@ -54,13 +54,13 @@ check_vmult_quadratic(std::vector<double>& residuals,
   SolverRichardson<> rich(control, mem, .01);
   SolverRichardson<> prich(control, mem, 1.);
 
-  const unsigned int block_size = (unsigned int) std::sqrt(A.n()+.3);
+  const types::global_dof_index block_size = (types::global_dof_index) std::sqrt(A.n()+.3);
   const unsigned int n_blocks = A.n()/block_size;
   
   typename PreconditionBlock<MATRIX, float>::AdditionalData
     data(block_size, 1.2);
-  std::vector<unsigned int> perm(A.n());
-  std::vector<unsigned int> iperm(A.n());
+  std::vector<types::global_dof_index> perm(A.n());
+  std::vector<types::global_dof_index> iperm(A.n());
   for (unsigned int i=0;i<n_blocks;++i)
     for (unsigned int j=0;j<block_size;++j)
       {
index c2562aa857a3b79e9f43304e16579d518c2b9915..c1805a3468427e019b27eb59a6a2bef1d47ca467 100644 (file)
@@ -94,9 +94,9 @@ main ()
                                   // now check for equivalence of sp3 and sp4
   for (unsigned int row=0; row<sp3.n_rows(); ++row)
     {
-      const unsigned int
+      const types::global_dof_index
         *sp3_p=sp3.get_column_numbers()+sp3.get_rowstart_indices()[row];
-      const unsigned int
+      const types::global_dof_index
         *sp4_p=sp4.get_column_numbers()+sp4.get_rowstart_indices()[row];
       for (; sp3_p != (sp3.get_column_numbers() +
                        sp3.get_rowstart_indices()[row+1]);
index f5905a644e3d3c1198aa5eec11ae5028bf24bdac..f731f56db26eba03a18455c3e56ef6ee48c1cc3b 100644 (file)
@@ -493,8 +493,8 @@ void matrix_position ()
     Assert (sparsity_pattern(sparsity_pattern.matrix_position(i).first,
                             sparsity_pattern.matrix_position(i).second) == i,
            ExcInternalError());
-  for (unsigned int row=0; row<sparsity_pattern.n_rows(); ++row)
-    for (unsigned int col=0; col<sparsity_pattern.n_cols(); ++col)
+  for (types::global_dof_index row=0; row<sparsity_pattern.n_rows(); ++row)
+    for (types::global_dof_index col=0; col<sparsity_pattern.n_cols(); ++col)
       if (sparsity_pattern(row,col) != SparsityPattern::invalid_entry)
        Assert (sparsity_pattern.matrix_position(sparsity_pattern(row,col)) ==
                std::make_pair(row,col),
index 82801e4b39b9d1f19e333690eaa4e587b0bab997..de2e8ebad854884e49deda7f818c24f64c0172d4 100644 (file)
@@ -83,7 +83,7 @@ operator () (const MatrixFree<dim,Number> &data,
   const unsigned int dofs_per_cell = fe_eval.dofs_per_cell;
   AlignedVector<VectorizedArray<Number> > values (n_q_points);
   AlignedVector<VectorizedArray<Number> > gradients (dim*n_q_points);
-  std::vector<unsigned int> dof_indices (dofs_per_cell);
+  std::vector<types::global_dof_index> dof_indices (dofs_per_cell);
   for(unsigned int cell=cell_range.first;cell<cell_range.second;++cell)
     {
       fe_eval.reinit(cell);
index 87d74d8da4fbb966a8ff934afca530b134a82393..806d08bf8f39d049f4b319b31599bff0c773383f 100644 (file)
@@ -94,8 +94,8 @@ operator () (const MatrixFree<dim,Number> &data,
   AlignedVector<VectorizedArray<Number> > gradients0 (dim*n_q_points0);
   AlignedVector<VectorizedArray<Number> > values1 (n_q_points1);
   AlignedVector<VectorizedArray<Number> > gradients1 (dim*n_q_points1);
-  std::vector<unsigned int> dof_indices0 (dofs_per_cell0);
-  std::vector<unsigned int> dof_indices1 (dofs_per_cell1);
+  std::vector<types::global_dof_index> dof_indices0 (dofs_per_cell0);
+  std::vector<types::global_dof_index> dof_indices1 (dofs_per_cell1);
   for(unsigned int cell=cell_range.first;cell<cell_range.second;++cell)
     {
       fe_eval0.reinit(cell);
index 543cf37764ee13a6769842903a2dbecb6b88c86f..2ef78e1b26dbab582193dca44f4b7fb86cb635c1 100644 (file)
@@ -97,8 +97,8 @@ operator () (const MatrixFree<dim,Number> &data,
   AlignedVector<VectorizedArray<Number> > gradients0 (dim*n_q_points0);
   AlignedVector<VectorizedArray<Number> > values1 (n_q_points1);
   AlignedVector<VectorizedArray<Number> > gradients1 (dim*n_q_points1);
-  std::vector<unsigned int> dof_indices0 (dofs_per_cell0);
-  std::vector<unsigned int> dof_indices1 (dofs_per_cell1);
+  std::vector<types::global_dof_index> dof_indices0 (dofs_per_cell0);
+  std::vector<types::global_dof_index> dof_indices1 (dofs_per_cell1);
   for(unsigned int cell=cell_range.first;cell<cell_range.second;++cell)
     {
       fe_eval0.reinit(cell);
index 93dff9ad8d7432274335ae88a45c96041b3398a3..407e99b04eaa296232d913e5c3c40f6436fad854 100644 (file)
@@ -75,11 +75,11 @@ void test ()
   typename FunctionMap<dim>::type dirichlet_boundary;
   ZeroFunction<dim>               homogeneous_dirichlet_bc (1);
   dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
-  std::vector<std::set<unsigned int> > boundary_indices(nlevels);
+  std::vector<std::set<types::global_dof_index> > boundary_indices(nlevels);
   MGTools::make_boundary_list (dof, dirichlet_boundary, boundary_indices);
   for (unsigned int level=0;level<nlevels;++level)
     {
-      std::set<unsigned int>::iterator bc_it = boundary_indices[level].begin();
+      std::set<types::global_dof_index>::iterator bc_it = boundary_indices[level].begin();
       for ( ; bc_it != boundary_indices[level].end(); ++bc_it)
         mg_constraints[level].add_line(*bc_it);
       mg_constraints[level].close();
index e201bc83b7fa4ed37daa07684d2ded09c49e336a..cdc067c731ab9390ebe565f1d6f0f0d6eaf4d3f8 100644 (file)
@@ -146,7 +146,7 @@ void test ()
 
   constraints.close ();
 
-  std::vector<unsigned int> dofs_per_block (dim+1);
+  std::vector<types::global_dof_index> dofs_per_block (dim+1);
   DoFTools::count_dofs_per_component (dof_handler, dofs_per_block);
 
   //std::cout << "   Number of active cells: "
index ae78558ab3e45462a100411b4684585a38ac0ec3..4013c21de39b1aa751f18e16ce0181b59f7b7748 100644 (file)
@@ -172,7 +172,7 @@ void test ()
                                            constraints_p);
   constraints_p.close ();
 
-  std::vector<unsigned int> dofs_per_block (2);
+  std::vector<types::global_dof_index> dofs_per_block (2);
   DoFTools::count_dofs_per_block (dof_handler, dofs_per_block,
                                   stokes_sub_blocks);
 
index 1c8a8298f7bd1698a6206526f28cb21e7c62559f..ba451965880d4f69b25b39ae0f8a938e81365a8f 100644 (file)
@@ -305,7 +305,7 @@ namespace Step37
   {
     data.cell_loop (&LaplaceOperator::local_apply, this, dst, src);
 
-    const std::vector<unsigned int> &
+    const std::vector<types::global_dof_index> &
     constrained_dofs = data.get_constrained_dofs();
     for (unsigned int i=0; i<constrained_dofs.size(); ++i)
       dst(constrained_dofs[i]) += src(constrained_dofs[i]);
@@ -431,7 +431,7 @@ namespace Step37
     typename FunctionMap<dim>::type dirichlet_boundary;
     ZeroFunction<dim>               homogeneous_dirichlet_bc (1);
     dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
-    std::vector<std::set<unsigned int> > boundary_indices(triangulation.n_levels());
+    std::vector<std::set<types::global_dof_index> > boundary_indices(triangulation.n_levels());
     MGTools::make_boundary_list (mg_dof_handler,
                                  dirichlet_boundary,
                                  boundary_indices);
index 1d72b80e908c6f00691c0ee4c0915d4beace1a8a..2f79c333ca08c8788cb45d5a71734d5319d1a2fc 100644 (file)
@@ -51,7 +51,7 @@ void test()
   DoFHandler<dim> dof_handler (triangulation);
   dof_handler.distribute_dofs (fe);
 
-  std::vector<unsigned int> dofs_per_block (fe.n_blocks());
+  std::vector<types::global_dof_inex> dofs_per_block (fe.n_blocks());
   DoFTools::count_dofs_per_block (dof_handler, dofs_per_block);
 
   if (Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
index af7269705f6e970e36aef528f5f1c14a081058d8..94a8dc87c4c70be573b79d0169a1247cbb6fc588 100644 (file)
@@ -84,7 +84,7 @@ void test()
       triangulation.execute_coarsening_and_refinement ();
       dof_handler.distribute_dofs (fe);
 
-      std::vector<unsigned int> dofs_per_block (fe.n_components());
+      std::vector<types::global_dof_index> dofs_per_block (fe.n_components());
       DoFTools::count_dofs_per_block (dof_handler, dofs_per_block);
 
       Assert (std::accumulate (dofs_per_block.begin(), dofs_per_block.end(), 0U)
index 62c67c6abf35ad17dceb5c3b8eb1211ae1b26352..aa8dd94668e66d6ac782a63a72fb7601f9c2df36 100644 (file)
@@ -51,7 +51,7 @@ void test()
   triangulation.refine_global (2);
   dof_handler.distribute_dofs (fe);
 
-  std::vector<unsigned int> dofs_per_component (fe.n_components());
+  std::vector<types::global_dof_index> dofs_per_component (fe.n_components());
   DoFTools::count_dofs_per_component (dof_handler, dofs_per_component);
 
   Assert (std::accumulate (dofs_per_component.begin(), dofs_per_component.end(), 0U)
index 4d7e4d74e45b412ebdd7d3fa91f9a896acf464e1..a282655b2e4f9d01afa4db095abb5cfdf0565b25 100644 (file)
@@ -38,7 +38,7 @@ void test_mpi()
 
   unsigned int num_local=10;
   unsigned int n=numprocs*num_local;
-  std::vector<unsigned int> rows_per_cpu;
+  std::vector<types::global_dof_index> rows_per_cpu;
   for (unsigned int i=0;i<numprocs;++i)
     rows_per_cpu.push_back(num_local);
 
index 7e5aeb2a23a6e96aee0356bafb057226ff3798c2..191546df0087f0e86a4309d74895c330354a3c01 100644 (file)
@@ -38,7 +38,7 @@ void test_mpi()
 
   unsigned int num_local=10;
   unsigned int n=numprocs*num_local;
-  std::vector<unsigned int> rows_per_cpu;
+  std::vector<types::global_dof_index> rows_per_cpu;
   for (unsigned int i=0;i<numprocs;++i)
     rows_per_cpu.push_back(num_local);
 
index 027f531d2c432bffe8523b31a5f096ca646f3bb8..7872b3dd84b9acc9060e08aa159965d026ba1eda 100644 (file)
@@ -38,7 +38,7 @@ void test()
   DoFHandler<dim> dofh(tr);
   dofh.distribute_dofs (fe);
 
-  std::map<unsigned int, Point<dim> > points;
+  std::map<types::global_dof_index, Point<dim> > points;
   DoFTools::map_dofs_to_support_points (MappingQ1<dim>(),
                                        dofh,
                                        points);
index 734d90fd6c77fd1ac2965eef0e2b2dfe805f5f6e..b2c03db88fd41f7d3982961913ae17cbc4ab53a8 100644 (file)
@@ -94,7 +94,7 @@ void test()
 
               for (;cell!=endc;++cell)
                 {
-              std::vector<unsigned int> dofs(fe.n_dofs_per_cell());
+              std::vector<types::global_dof_index> dofs(fe.n_dofs_per_cell());
               cell->get_mg_dof_indices(dofs);
 
               for (unsigned int i=0;i<dofs.size();++i)
index e70b350c8c46ce75b7b6281b0a9760ad40948e3e..b92e288f8cc667d4676023f1cda7ab4cd268512c 100644 (file)
@@ -59,7 +59,7 @@ reinit_vector_by_blocks (
     {
       std::vector<std::vector<types::global_dof_index> >
        new_dofs(mg_dof.get_tria().n_levels(),
-                std::vector<unsigned int>(selected.size()));
+                std::vector<types::global_dof_index>(selected.size()));
       std::swap(ndofs, new_dofs);
       MGTools::count_dofs_per_block (mg_dof, ndofs);
     }
index 85889511b381e1068974765c03a3f5402dd17158..61e2d55ad9e3edc0d4ca30d17eb6693e108d72f6 100644 (file)
@@ -109,7 +109,7 @@ void check (const FiniteElement<dim>& fe)
                          0, 0,
                          block_component, block_component);
 
-  std::vector<std::vector<unsigned int> > dofs_per_block(tr.n_levels(), std::vector<unsigned int>(2));
+  std::vector<std::vector<types::global_dof_index> > dofs_per_block(tr.n_levels(), std::vector<types::global_dof_index>(2));
   MGTools::count_dofs_per_block(mg_dof_handler, dofs_per_block, block_component);
   FullMatrix<double> prolong_0_1 (dofs_per_block[1][0],
                                   dofs_per_block[0][0]);
index c75b27ae11f4561d8a84ec2834a0f19050a57ed5..4f7b7a1467ffdcda69ce9b3858ca75615f372488 100644 (file)
@@ -65,9 +65,10 @@ void check (const FiniteElement<dim>& fe, const unsigned int selected_block)
                          selected_block, selected_block,
                          block_component, block_component);
 
-  std::vector<unsigned int> dofs_per_block(3);
+  std::vector<types::global_dof_index> dofs_per_block(3);
   DoFTools::count_dofs_per_block(mg_dof_handler, dofs_per_block, block_component);
-  std::vector<std::vector<unsigned int> > mg_dofs_per_block(tr.n_levels(), std::vector<unsigned int>(3));
+  std::vector<std::vector<types::global_dof_index> > mg_dofs_per_block(tr.n_levels(), 
+      std::vector<types::global_dof_index>(3));
   MGTools::count_dofs_per_block(mg_dof_handler, mg_dofs_per_block, block_component);
 
   deallog << "Global  dofs:";
index 596f8503f9d3dd8231e09bc4e5b726dceb30ecfd..0f79d94fdb713474c3d994eaf16ecf618d11d278 100644 (file)
@@ -143,7 +143,7 @@ void check (const FiniteElement<dim>& fe)
   for (unsigned int level=0; level<tr.n_levels(); ++level)
     DoFRenumbering::component_wise (mg_dof_handler, level);
 
-  std::vector<std::set<unsigned int> > boundary_indices(tr.n_levels());
+  std::vector<std::set<types::global_dof_index> > boundary_indices(tr.n_levels());
   typename FunctionMap<dim>::type      dirichlet_boundary;
   ZeroFunction<dim>                    dirichlet_bc(fe.n_components());
   dirichlet_boundary[3] =             &dirichlet_bc;
index 9a1cea4cfee9ead91d57a077dd754e24a9ac6dfc..4300343caa82d182edb9be14a0db070f56e36f56 100644 (file)
@@ -143,7 +143,7 @@ void check (const FiniteElement<dim>& fe)
   for (unsigned int level=0; level<tr.n_levels(); ++level)
     DoFRenumbering::component_wise (mg_dof_handler, level);
 
-  std::vector<std::set<unsigned int> > boundary_indices(tr.n_levels());
+  std::vector<std::set<types::global_dof_index> > boundary_indices(tr.n_levels());
   typename FunctionMap<dim>::type      dirichlet_boundary;
   ZeroFunction<dim>                    dirichlet_bc(fe.n_components());
   dirichlet_boundary[3] =             &dirichlet_bc;
index b218b7055bd3067745a2bb4fc81dfb9d9eee9523..9000bbfdd76111e08cc91bffaab34981bb789320 100644 (file)
@@ -154,8 +154,8 @@ void check (const FiniteElement<dim>& fe)
   transfer.build_matrices(mg_dof_handler, mg_dof_handler, 
       0, 0, block_selected, block_selected);
 
-  std::vector<std::vector<unsigned int> > 
-    dofs_per_block(tr.n_levels(), std::vector<unsigned int>(2));
+  std::vector<std::vector<types::global_dof_index> > 
+    dofs_per_block(tr.n_levels(), std::vector<types::global_dof_index>(2));
   MGTools::count_dofs_per_block(mg_dof_handler, 
       dofs_per_block, block_selected);
 
index 4075fde99456ed88b8f4c643edb0a70f2de97f9f..e6e307ce4aa06864df3c33e4075ff7ff5a984b01 100644 (file)
@@ -149,7 +149,7 @@ void check (const FiniteElement<dim>& fe)
     DoFRenumbering::component_wise (mg_dof_handler, 
         level, block_selected);
 
-  std::vector<std::set<unsigned int> > boundary_indices(tr.n_levels());
+  std::vector<std::set<types::global_dof_index> > boundary_indices(tr.n_levels());
   typename FunctionMap<dim>::type      dirichlet_boundary;
   ZeroFunction<dim>                    dirichlet_bc(fe.n_components());
   dirichlet_boundary[3] =             &dirichlet_bc;
@@ -161,8 +161,8 @@ void check (const FiniteElement<dim>& fe)
   transfer.build_matrices(mg_dof_handler, mg_dof_handler, 
       0, 0, block_selected, block_selected, boundary_indices);
 
-  std::vector<std::vector<unsigned int> > 
-    dofs_per_block(tr.n_levels(), std::vector<unsigned int>(2));
+  std::vector<std::vector<types::global_dof_index> > 
+    dofs_per_block(tr.n_levels(), std::vector<types::global_dof_index>(2));
   MGTools::count_dofs_per_block(mg_dof_handler, 
       dofs_per_block, block_selected);
 
index f36ed5730049175d22353aab6590055ad85705d9..0088a68ce96f2f9fa7a5e190a75d6cdc6a830770 100644 (file)
@@ -108,9 +108,10 @@ void check (const FiniteElement<dim>& fe, const unsigned int selected_block)
                          selected_block, selected_block,
                          block_component, block_component);
 
-  std::vector<unsigned int> dofs_per_block(3);
+  std::vector<types::global_dof_index> dofs_per_block(3);
   DoFTools::count_dofs_per_block(mg_dof_handler, dofs_per_block, block_component);
-  std::vector<std::vector<unsigned int> > mg_dofs_per_block(tr.n_levels(), std::vector<unsigned int>(3));
+  std::vector<std::vector<types::global_dof_index> > mg_dofs_per_block(tr.n_levels(), 
+      std::vector<types::global_dof_index>(3));
   MGTools::count_dofs_per_block(mg_dof_handler, mg_dofs_per_block, block_component);
 
   deallog << "Global  dofs:";
index a218b2f7b8bced26f5b935ab2da4effa9bd638e9..159f5aad00c46496fd01a6f515f36ee778b2d01d 100644 (file)
@@ -86,8 +86,8 @@ namespace dealii
                                         // compare dofs on this cell and then on the faces
        if (c1->has_children() == false)
          {
-           std::vector<unsigned int> local_dofs_1 (c1->get_fe().dofs_per_cell);
-           std::vector<unsigned int> local_dofs_2 (c2->get_fe().dofs_per_cell);
+           std::vector<types::local_dof_types> local_dofs_1 (c1->get_fe().dofs_per_cell);
+           std::vector<types::local_dof_types> local_dofs_2 (c2->get_fe().dofs_per_cell);
 
            c1->get_dof_indices (local_dofs_1);
            c2->get_dof_indices (local_dofs_2);
@@ -96,8 +96,8 @@ namespace dealii
 
            for (unsigned int f=0; f<GeometryInfo<dim>::faces_per_cell; ++f)
              {
-               std::vector<unsigned int> local_dofs_1 (c1->get_fe().dofs_per_face);
-               std::vector<unsigned int> local_dofs_2 (c2->get_fe().dofs_per_face);
+               std::vector<types::global_dof_index> local_dofs_1 (c1->get_fe().dofs_per_face);
+               std::vector<types::global_dof_index> local_dofs_2 (c2->get_fe().dofs_per_face);
 
                c1->face(f)->get_dof_indices (local_dofs_1);
                c2->face(f)->get_dof_indices (local_dofs_2);

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.