From: Guido Kanschat Date: Wed, 9 Mar 2005 03:05:35 +0000 (+0000) Subject: FullMatrix arguments replaced by more obvious enum X-Git-Tag: v8.0.0~14476 X-Git-Url: https://gitweb.dealii.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=b975ce479a0c6dd36995e9fee3cb5513c12bfab5;p=dealii.git FullMatrix arguments replaced by more obvious enum git-svn-id: https://svn.dealii.org/trunk@10052 0785d39b-7218-0410-832d-ea1e28bc413d --- diff --git a/deal.II/deal.II/include/dofs/dof_tools.h b/deal.II/deal.II/include/dofs/dof_tools.h index fc1f71d337..49065cbc18 100644 --- a/deal.II/deal.II/include/dofs/dof_tools.h +++ b/deal.II/deal.II/include/dofs/dof_tools.h @@ -2,7 +2,7 @@ // $Id$ // Version: $Name$ // -// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004 by the deal.II authors +// Copyright (C) 1998 - 2005 by the deal.II authors // // This file is subject to QPL and may not be distributed // without copyright and license information. Please refer @@ -22,11 +22,12 @@ #include #include +template class Table; class SparsityPattern; template class Vector; -template class FullMatrix; template class Function; template class Point; +template class FiniteElement; template class DoFHandler; template class MGDoFHandler; class ConstraintMatrix; @@ -141,11 +142,30 @@ template class Mapping; * don't do it here) and not relevant in this context. * * - * @author Wolfgang Bangerth and others, 1998, 1999, 2000, 2001 + * @author Wolfgang Bangerth, Guido Kanschat and others, 1998 - 2005 */ class DoFTools { public: + /** + * The flags used in tables by certain + * make_*_pattern + * functions to determine whether + * two components of the solution + * couple in the interior of mesh + * cells or at the boundary. + */ + enum Coupling + { + /// The two components do not couple + none, + /// The two components do couple + always, +/// The two components couple only if their shape functions can be nonzero on this face + nonzero + }; + + /** * Locate non-zero entries of the * system matrix. @@ -471,8 +491,8 @@ class DoFTools static void make_flux_sparsity_pattern (const DoFHandler &dof, SparsityPattern &sparsity, - const FullMatrix& int_mask, - const FullMatrix& flux_mask); + const Table<2,Coupling>& int_mask, + const Table<2,Coupling>& flux_mask); /** * Make up the constraints which @@ -1386,6 +1406,18 @@ class DoFTools std::vector > &weights, const typename DoFHandler::active_cell_iterator &begin, const typename DoFHandler::active_cell_iterator &end); + + /** + * Compute coupling of dofs from + * coupling of components. + */ + template + static void compute_dof_couplings ( + Table<2,Coupling>& dof_couplings, + const Table<2,Coupling>& component_couplings, + const FiniteElement& fe); + + friend class MGTools; }; diff --git a/deal.II/deal.II/include/multigrid/mg_dof_tools.h b/deal.II/deal.II/include/multigrid/mg_dof_tools.h index 746b3ac80d..fdd172fe83 100644 --- a/deal.II/deal.II/include/multigrid/mg_dof_tools.h +++ b/deal.II/deal.II/include/multigrid/mg_dof_tools.h @@ -1,4 +1,4 @@ -//---------------------------- mg_dof_tools.h --------------------------- +//--------------------------------------------------------------------------- // $Id$ // Version: $Name$ // @@ -9,11 +9,12 @@ // to the file deal.II/doc/license.html for the text and // further information on this license. // -//---------------------------- mg_dof_tools.h --------------------------- +//--------------------------------------------------------------------------- #ifndef __deal2__mg_dof_tools_h #define __deal2__mg_dof_tools_h #include +#include #include #include @@ -36,9 +37,9 @@ template class FullMatrix; * for more information. * * All member functions are static, so there is no need to create an - * object of class @p MGTools. + * object of class MGTools. * - * @author Wolfgang Bangerth, Guido Kanschat, 1999-2003 + * @author Wolfgang Bangerth, Guido Kanschat, 1999 - 2005 */ class MGTools { @@ -113,8 +114,27 @@ class MGTools make_flux_sparsity_pattern (const MGDoFHandler &dof, SparsityPattern &sparsity, const unsigned int level, - const FullMatrix &int_mask, - const FullMatrix &flux_mask); + const Table<2,DoFTools::Coupling> &int_mask, + const Table<2,DoFTools::Coupling> &flux_mask); + + /** + * Create sparsity pattern for + * the fluxes at refinement + * edges. The matrix maps a + * function of the fine level + * space @p level to the coarser + * space. This is the version + * restricting the pattern to the + * elements actually needed. + * + * make_flux_sparsity_pattern() + */ + template + static void + make_flux_sparsity_pattern_edge (const MGDoFHandler &dof_handler, + SparsityPattern &sparsity, + const unsigned int level, + const Table<2,DoFTools::Coupling> &flux_mask); /** * Count the dofs component-wise diff --git a/deal.II/deal.II/source/dofs/dof_tools.cc b/deal.II/deal.II/source/dofs/dof_tools.cc index e626c0131f..4a3a297fdb 100644 --- a/deal.II/deal.II/source/dofs/dof_tools.cc +++ b/deal.II/deal.II/source/dofs/dof_tools.cc @@ -2,7 +2,7 @@ // $Id$ // Version: $Name$ // -// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004 by the deal.II authors +// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors // // This file is subject to QPL and may not be distributed // without copyright and license information. Please refer @@ -15,6 +15,7 @@ #include #include #include +#include #include #include #include @@ -472,10 +473,10 @@ DoFTools::make_flux_sparsity_pattern (const DoFHandler<1> &dof, template void -DoFTools::make_flux_sparsity_pattern (const DoFHandler &dof, - SparsityPattern &sparsity, - const FullMatrix &int_mask, - const FullMatrix &flux_mask) +DoFTools::make_flux_sparsity_pattern (const DoFHandler& dof, + SparsityPattern& sparsity, + const Table<2,Coupling>& int_mask, + const Table<2,Coupling>& flux_mask) { const unsigned int n_dofs = dof.n_dofs(); const FiniteElement& fe = dof.get_fe(); @@ -485,14 +486,14 @@ DoFTools::make_flux_sparsity_pattern (const DoFHandler &dof, ExcDimensionMismatch (sparsity.n_rows(), n_dofs)); Assert (sparsity.n_cols() == n_dofs, ExcDimensionMismatch (sparsity.n_cols(), n_dofs)); - Assert (int_mask.m() == n_comp, - ExcDimensionMismatch (int_mask.m(), n_comp)); - Assert (int_mask.n() == n_comp, - ExcDimensionMismatch (int_mask.n(), n_comp)); - Assert (flux_mask.m() == n_comp, - ExcDimensionMismatch (flux_mask.m(), n_comp)); - Assert (flux_mask.n() == n_comp, - ExcDimensionMismatch (flux_mask.n(), n_comp)); + Assert (int_mask.n_rows() == n_comp, + ExcDimensionMismatch (int_mask.n_rows(), n_comp)); + Assert (int_mask.n_cols() == n_comp, + ExcDimensionMismatch (int_mask.n_cols(), n_comp)); + Assert (flux_mask.n_rows() == n_comp, + ExcDimensionMismatch (flux_mask.n_rows(), n_comp)); + Assert (flux_mask.n_cols() == n_comp, + ExcDimensionMismatch (flux_mask.n_cols(), n_comp)); const unsigned int total_dofs = fe.dofs_per_cell; std::vector dofs_on_this_cell(total_dofs); @@ -501,56 +502,16 @@ DoFTools::make_flux_sparsity_pattern (const DoFHandler &dof, typename DoFHandler::active_cell_iterator cell = dof.begin_active(), endc = dof.end(); - - -//TODO[GK]: would someone explain what the letters 'f', 'a', and 'n' mean? -//Even better would, of course, be to change this to an enum - Table<2,char> int_dof_mask(total_dofs, total_dofs); - Table<2,char> flux_dof_mask(total_dofs, total_dofs); - + + Table<2,Coupling> int_dof_mask(total_dofs, total_dofs); + Table<2,Coupling> flux_dof_mask(total_dofs, total_dofs); + + compute_dof_couplings(int_dof_mask, int_mask, fe); + compute_dof_couplings(flux_dof_mask, flux_mask, fe); + for (unsigned int i=0; i - if (int_mask(ii,jj) != 0) - int_dof_mask(i,j) = 'f'; - if (flux_mask(ii,jj) == 1.) - flux_dof_mask(i,j) = 'a'; - if (flux_mask(ii,jj) == 2.) - flux_dof_mask(i,j) = 'f'; - } - for (unsigned int f=0; f::faces_per_cell;++f) - support_on_face(i,f) = fe.has_support_on_face(i,f); - } + for (unsigned int f=0; f::faces_per_cell;++f) + support_on_face(i,f) = fe.has_support_on_face(i,f); // Clear user flags because we will // need them. But first we save @@ -570,7 +531,7 @@ DoFTools::make_flux_sparsity_pattern (const DoFHandler &dof, // make sparsity pattern for this cell for (unsigned int i=0; i &dof, { const bool j_non_zero_i = support_on_face (j, face); - if (flux_dof_mask(i,j) == 'f') + if (flux_dof_mask(i,j) == always) sparsity.add (dofs_on_this_cell[i], dofs_on_this_cell[j]); - if (flux_dof_mask(i,j) == 'a') - if (i_non_zero_i && j_non_zero_i) - sparsity.add (dofs_on_this_cell[i], - dofs_on_this_cell[j]); + if (flux_dof_mask(i,j) == nonzero + && i_non_zero_i && j_non_zero_i) + sparsity.add (dofs_on_this_cell[i], + dofs_on_this_cell[j]); } } } @@ -611,10 +572,10 @@ DoFTools::make_flux_sparsity_pattern (const DoFHandler &dof, // by coarser cells if (neighbor->level() < cell->level()) continue; - + const unsigned int neighbor_face = cell->neighbor_of_neighbor(face); - + if (neighbor->has_children()) { for (unsigned int sub_nr = 0; @@ -634,11 +595,7 @@ DoFTools::make_flux_sparsity_pattern (const DoFHandler &dof, { const bool j_non_zero_i = support_on_face (j, face); const bool j_non_zero_e =support_on_face (j, neighbor_face); - - if (flux_dof_mask(i,j)==0) - flux_dof_mask(i,j) = 'n'; - - if (flux_dof_mask(i,j) == 'f') + if (flux_dof_mask(i,j) == always) { sparsity.add (dofs_on_this_cell[i], dofs_on_other_cell[j]); @@ -649,7 +606,7 @@ DoFTools::make_flux_sparsity_pattern (const DoFHandler &dof, sparsity.add (dofs_on_other_cell[i], dofs_on_other_cell[j]); } - if (flux_dof_mask(i,j) == 'a') + if (flux_dof_mask(i,j) == nonzero) { if (i_non_zero_i && j_non_zero_e) sparsity.add (dofs_on_this_cell[i], @@ -665,7 +622,7 @@ DoFTools::make_flux_sparsity_pattern (const DoFHandler &dof, dofs_on_other_cell[j]); } - if (flux_dof_mask(j,i) == 'f') + if (flux_dof_mask(j,i) == always) { sparsity.add (dofs_on_this_cell[j], dofs_on_other_cell[i]); @@ -676,7 +633,7 @@ DoFTools::make_flux_sparsity_pattern (const DoFHandler &dof, sparsity.add (dofs_on_other_cell[j], dofs_on_other_cell[i]); } - if (flux_dof_mask(j,i) == 'a') + if (flux_dof_mask(j,i) == nonzero) { if (j_non_zero_i && i_non_zero_e) sparsity.add (dofs_on_this_cell[j], @@ -707,10 +664,7 @@ DoFTools::make_flux_sparsity_pattern (const DoFHandler &dof, { const bool j_non_zero_i = support_on_face (j, face); const bool j_non_zero_e = support_on_face (j, neighbor_face); - if (flux_dof_mask(i,j)==0) - flux_dof_mask(i,j) = 'n'; - - if (flux_dof_mask(i,j) == 'f') + if (flux_dof_mask(i,j) == always) { sparsity.add (dofs_on_this_cell[i], dofs_on_other_cell[j]); @@ -721,7 +675,7 @@ DoFTools::make_flux_sparsity_pattern (const DoFHandler &dof, sparsity.add (dofs_on_other_cell[i], dofs_on_other_cell[j]); } - if (flux_dof_mask(i,j) == 'a') + if (flux_dof_mask(i,j) == nonzero) { if (i_non_zero_i && j_non_zero_e) sparsity.add (dofs_on_this_cell[i], @@ -737,7 +691,7 @@ DoFTools::make_flux_sparsity_pattern (const DoFHandler &dof, dofs_on_other_cell[j]); } - if (flux_dof_mask(j,i) == 'f') + if (flux_dof_mask(j,i) == always) { sparsity.add (dofs_on_this_cell[j], dofs_on_other_cell[i]); @@ -748,7 +702,7 @@ DoFTools::make_flux_sparsity_pattern (const DoFHandler &dof, sparsity.add (dofs_on_other_cell[j], dofs_on_other_cell[i]); } - if (flux_dof_mask(j,i) == 'a') + if (flux_dof_mask(j,i) == nonzero) { if (j_non_zero_i && i_non_zero_e) sparsity.add (dofs_on_this_cell[j], @@ -2817,6 +2771,62 @@ DoFTools::map_dofs_to_support_points (const Mapping &mapping, } +template +void +DoFTools::compute_dof_couplings( + Table<2,Coupling>& dof_couplings, + const Table<2,Coupling>& component_couplings, + const FiniteElement& fe) +{ + Assert(component_couplings.n_rows() == fe.n_components(), + ExcDimensionMismatch(component_couplings.n_rows(), + fe.n_components())); + Assert(component_couplings.n_cols() == fe.n_components(), + ExcDimensionMismatch(component_couplings.n_cols(), + fe.n_components())); + + const unsigned int n_dofs = fe.dofs_per_cell; + + Assert(dof_couplings.n_rows() == n_dofs, + ExcDimensionMismatch(dof_couplings.n_rows(), n_dofs)); + Assert(dof_couplings.n_cols() == n_dofs, + ExcDimensionMismatch(dof_couplings.n_cols(), n_dofs)); + + for (unsigned int i=0; i (const DoFHandler& dof, SparsityPattern &, - const FullMatrix&, - const FullMatrix&); + const Table<2,Coupling>&, + const Table<2,Coupling>&); template void DoFTools::make_flux_sparsity_pattern (const DoFHandler& dof, CompressedSparsityPattern &, - const FullMatrix&, - const FullMatrix&); + const Table<2,Coupling>&, + const Table<2,Coupling>&); template void DoFTools::make_flux_sparsity_pattern (const DoFHandler& dof, BlockSparsityPattern &, - const FullMatrix&, - const FullMatrix&); + const Table<2,Coupling>&, + const Table<2,Coupling>&); template void DoFTools::make_flux_sparsity_pattern (const DoFHandler& dof, CompressedBlockSparsityPattern &, - const FullMatrix&, - const FullMatrix&); + const Table<2,Coupling>&, + const Table<2,Coupling>&); #endif @@ -3138,3 +3148,10 @@ DoFTools::map_dofs_to_support_points (const Mapping &mapping, const DoFHandler &dof_handler, std::vector > &support_points); + +template +void +DoFTools::compute_dof_couplings( + Table<2,Coupling>& dof_couplings, + const Table<2,Coupling>& component_couplings, + const FiniteElement& fe); diff --git a/deal.II/deal.II/source/multigrid/mg_dof_tools.cc b/deal.II/deal.II/source/multigrid/mg_dof_tools.cc index 268613979e..6c0d3ee1f9 100644 --- a/deal.II/deal.II/source/multigrid/mg_dof_tools.cc +++ b/deal.II/deal.II/source/multigrid/mg_dof_tools.cc @@ -1,15 +1,15 @@ -//---------------------------- mg_dof_tools.cc --------------------------- +//--------------------------------------------------------------------------- // $Id$ // Version: $Name$ // -// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004 by the deal.II authors +// Copyright (C) 1998 - 2005 by the deal.II authors // // This file is subject to QPL and may not be distributed // without copyright and license information. Please refer // to the file deal.II/doc/license.html for the text and // further information on this license. // -//---------------------------- mg_dof_tools.cc --------------------------- +//--------------------------------------------------------------------------- #include @@ -181,54 +181,52 @@ MGTools::make_flux_sparsity_pattern_edge ( -//TODO[GK]: Replace FullMatrix by Table<2,char> + + + template void MGTools::make_flux_sparsity_pattern ( const MGDoFHandler &dof, SparsityPattern &sparsity, const unsigned int level, - const FullMatrix &int_mask, - const FullMatrix &flux_mask) + const Table<2,DoFTools::Coupling> &int_mask, + const Table<2,DoFTools::Coupling> &flux_mask) { + const FiniteElement& fe = dof.get_fe(); const unsigned int n_dofs = dof.n_dofs(level); - const unsigned int n_comp = dof.get_fe().n_components(); + const unsigned int n_comp = fe.n_components(); Assert (sparsity.n_rows() == n_dofs, ExcDimensionMismatch (sparsity.n_rows(), n_dofs)); Assert (sparsity.n_cols() == n_dofs, ExcDimensionMismatch (sparsity.n_cols(), n_dofs)); - Assert (int_mask.m() == n_comp, - ExcDimensionMismatch (int_mask.m(), n_comp)); - Assert (int_mask.n() == n_comp, - ExcDimensionMismatch (int_mask.n(), n_comp)); - Assert (flux_mask.m() == n_comp, - ExcDimensionMismatch (flux_mask.m(), n_comp)); - Assert (flux_mask.n() == n_comp, - ExcDimensionMismatch (flux_mask.n(), n_comp)); + Assert (int_mask.n_rows() == n_comp, + ExcDimensionMismatch (int_mask.n_rows(), n_comp)); + Assert (int_mask.n_cols() == n_comp, + ExcDimensionMismatch (int_mask.n_cols(), n_comp)); + Assert (flux_mask.n_rows() == n_comp, + ExcDimensionMismatch (flux_mask.n_rows(), n_comp)); + Assert (flux_mask.n_cols() == n_comp, + ExcDimensionMismatch (flux_mask.n_cols(), n_comp)); - const unsigned int total_dofs = dof.get_fe().dofs_per_cell; + const unsigned int total_dofs = fe.dofs_per_cell; std::vector dofs_on_this_cell(total_dofs); std::vector dofs_on_other_cell(total_dofs); + Table<2,bool> support_on_face(total_dofs, GeometryInfo::faces_per_cell); + typename MGDoFHandler::cell_iterator cell = dof.begin(level), endc = dof.end(level); + Table<2,DoFTools::Coupling> int_dof_mask(total_dofs, total_dofs); + Table<2,DoFTools::Coupling> flux_dof_mask(total_dofs, total_dofs); - std::vector > int_dof_mask(total_dofs, - std::vector(total_dofs, false)); - std::vector > flux_dof_mask(total_dofs, - std::vector(total_dofs, false)); + DoFTools::compute_dof_couplings(int_dof_mask, int_mask, fe); + DoFTools::compute_dof_couplings(flux_dof_mask, flux_mask, fe); + for (unsigned int i=0; i::faces_per_cell;++f) + support_on_face(i,f) = fe.has_support_on_face(i,f); // Clear user flags because we will // need them. But first we save @@ -248,7 +246,7 @@ MGTools::make_flux_sparsity_pattern ( // make sparsity pattern for this cell for (unsigned int i=0; iuser_flag_set ()) continue; - if (! cell->at_boundary (face) ) + if (cell->at_boundary (face) ) + { + for (unsigned int i=0; i::cell_iterator neighbor = cell->neighbor(face); - + if (neighbor->level() < cell->level()) continue; - + unsigned int neighbor_face = cell->neighbor_of_neighbor(face); - + neighbor->get_mg_dof_indices (dofs_on_other_cell); for (unsigned int i=0; iface(neighbor_face)->set_user_flag (); } } } - + // finally restore the user flags const_cast &>(dof.get_tria()).load_user_flags(user_flags); } +template +void +MGTools::make_flux_sparsity_pattern_edge ( + const MGDoFHandler &dof, + SparsityPattern &sparsity, + const unsigned int level, + const Table<2,DoFTools::Coupling> &flux_mask) +{ + const FiniteElement& fe = dof.get_fe(); + const unsigned int n_comp = fe.n_components(); + + Assert ((level>=1) && (level dofs_on_this_cell(dofs_per_cell); + std::vector dofs_on_other_cell(dofs_per_cell); + Table<2,bool> support_on_face(total_dofs, GeometryInfo::faces_per_cell); + + typename MGDoFHandler::cell_iterator cell = dof.begin(level), + endc = dof.end(level); + + Table<2,DoFTools::Coupling> flux_dof_mask(total_dofs, total_dofs); + + DoFTools::compute_dof_couplings(flux_dof_mask, flux_mask, fe); + + for (unsigned int i=0; i::faces_per_cell;++f) + support_on_face(i,f) = fe.has_support_on_face(i,f); + + for (; cell!=endc; ++cell) + { + cell->get_mg_dof_indices (dofs_on_this_cell); + // Loop over all interior neighbors + for (unsigned int face = 0; + face < GeometryInfo::faces_per_cell; + ++face) + { + // Neighbor is coarser + + if ( (! cell->at_boundary(face)) && + (static_cast(cell->neighbor_level(face)) != level) ) + { + typename MGDoFHandler::cell_iterator + neighbor = cell->neighbor(face); + neighbor->get_mg_dof_indices (dofs_on_other_cell); + + for (unsigned int i=0; i void MGTools::count_dofs_per_component ( @@ -567,29 +717,29 @@ template void MGTools::make_flux_sparsity_pattern (const MGDoFHandler &, SparsityPattern &, const unsigned int, - const FullMatrix&, - const FullMatrix&); + const Table<2,DoFTools::Coupling>&, + const Table<2,DoFTools::Coupling>&); template void MGTools::make_flux_sparsity_pattern (const MGDoFHandler &, CompressedSparsityPattern &, const unsigned int, - const FullMatrix&, - const FullMatrix&); + const Table<2,DoFTools::Coupling>&, + const Table<2,DoFTools::Coupling>&); template void MGTools::make_flux_sparsity_pattern (const MGDoFHandler &, BlockSparsityPattern &, const unsigned int, - const FullMatrix&, - const FullMatrix&); + const Table<2,DoFTools::Coupling>&, + const Table<2,DoFTools::Coupling>&); template void MGTools::make_flux_sparsity_pattern (const MGDoFHandler &, CompressedBlockSparsityPattern &, const unsigned int, - const FullMatrix&, - const FullMatrix&); + const Table<2,DoFTools::Coupling>&, + const Table<2,DoFTools::Coupling>&); #endif diff --git a/tests/bits/dof_tools_18a.cc b/tests/bits/dof_tools_18a.cc index 37a20e7259..d3cd963dc7 100644 --- a/tests/bits/dof_tools_18a.cc +++ b/tests/bits/dof_tools_18a.cc @@ -2,7 +2,7 @@ // $Id$ // Version: $Name$ // -// Copyright (C) 2003, 2004 by the deal.II authors +// Copyright (C) 2003, 2004, 2005 by the deal.II authors // // This file is subject to QPL and may not be distributed // without copyright and license information. Please refer @@ -29,13 +29,13 @@ std::string output_file_name = "dof_tools_18a.output"; // something) void make_masks (const unsigned int n, - FullMatrix &m1, - FullMatrix &m2) + Table<2,DoFTools::Coupling> &m1, + Table<2,DoFTools::Coupling> &m2) { m1.reinit (n,n); m2.reinit (n,n); for (unsigned int i=0; i void check_this (const DoFHandler &dof_handler) { - FullMatrix mask_int, mask_ext; + Table<2,DoFTools::Coupling> mask_int; + Table<2,DoFTools::Coupling> mask_ext; make_masks (dof_handler.get_fe().n_components(), mask_int, mask_ext); diff --git a/tests/bits/dof_tools_18b.cc b/tests/bits/dof_tools_18b.cc index 5d8709d283..6c30eb26fa 100644 --- a/tests/bits/dof_tools_18b.cc +++ b/tests/bits/dof_tools_18b.cc @@ -2,7 +2,7 @@ // $Id$ // Version: $Name$ // -// Copyright (C) 2003, 2004 by the deal.II authors +// Copyright (C) 2003, 2004, 2005 by the deal.II authors // // This file is subject to QPL and may not be distributed // without copyright and license information. Please refer @@ -28,13 +28,13 @@ std::string output_file_name = "dof_tools_18b.output"; // something) void make_masks (const unsigned int n, - FullMatrix &m1, - FullMatrix &m2) + Table<2, DoFTools::Coupling> &m1, + Table<2, DoFTools::Coupling> &m2) { m1.reinit (n,n); m2.reinit (n,n); for (unsigned int i=0; i void check_this (const DoFHandler &dof_handler) { - FullMatrix mask_int, mask_ext; + Table<2, DoFTools::Coupling> mask_int; + Table<2, DoFTools::Coupling> mask_ext; make_masks (dof_handler.get_fe().n_components(), mask_int, mask_ext); diff --git a/tests/bits/dof_tools_18c.cc b/tests/bits/dof_tools_18c.cc index e01a87a614..3686a17ea9 100644 --- a/tests/bits/dof_tools_18c.cc +++ b/tests/bits/dof_tools_18c.cc @@ -2,7 +2,7 @@ // $Id$ // Version: $Name$ // -// Copyright (C) 2003, 2004 by the deal.II authors +// Copyright (C) 2003, 2004, 2005 by the deal.II authors // // This file is subject to QPL and may not be distributed // without copyright and license information. Please refer @@ -28,13 +28,13 @@ std::string output_file_name = "dof_tools_18c.output"; // something) void make_masks (const unsigned int n, - FullMatrix &m1, - FullMatrix &m2) + Table<2, DoFTools::Coupling> &m1, + Table<2, DoFTools::Coupling> &m2) { m1.reinit (n,n); m2.reinit (n,n); for (unsigned int i=0; i &dof_handler) if (dof_handler.get_fe().is_primitive() != true) return; - FullMatrix mask_int, mask_ext; + Table<2, DoFTools::Coupling> mask_int; + Table<2, DoFTools::Coupling> mask_ext; make_masks (dof_handler.get_fe().n_components(), mask_int, mask_ext); diff --git a/tests/bits/dof_tools_18d.cc b/tests/bits/dof_tools_18d.cc index 9837505c36..2592a66873 100644 --- a/tests/bits/dof_tools_18d.cc +++ b/tests/bits/dof_tools_18d.cc @@ -2,7 +2,7 @@ // $Id$ // Version: $Name$ // -// Copyright (C) 2003, 2004 by the deal.II authors +// Copyright (C) 2003, 2004, 2005 by the deal.II authors // // This file is subject to QPL and may not be distributed // without copyright and license information. Please refer @@ -28,13 +28,13 @@ std::string output_file_name = "dof_tools_18d.output"; // something) void make_masks (const unsigned int n, - FullMatrix &m1, - FullMatrix &m2) + Table<2, DoFTools::Coupling> &m1, + Table<2, DoFTools::Coupling> &m2) { m1.reinit (n,n); m2.reinit (n,n); for (unsigned int i=0; i &dof_handler) if (dof_handler.get_fe().is_primitive() != true) return; - FullMatrix mask_int, mask_ext; + Table<2, DoFTools::Coupling> mask_int; + Table<2, DoFTools::Coupling> mask_ext; make_masks (dof_handler.get_fe().n_components(), mask_int, mask_ext);