#include <deal.II/fe/component_mask.h>
#include <deal.II/lac/affine_constraints.h>
+#include <deal.II/lac/sparsity_pattern_base.h>
#include <map>
#include <ostream>
class InterGridMap;
template <int dim, int spacedim>
class Mapping;
-class SparsityPattern;
template <int dim, class T>
class Table;
template <typename Number>
*
* @ingroup constraints
*/
- template <int dim,
- int spacedim,
- typename SparsityPatternType,
- typename number = double>
+ template <int dim, int spacedim, typename number = double>
void
make_sparsity_pattern(
const DoFHandler<dim, spacedim> &dof_handler,
- SparsityPatternType & sparsity_pattern,
+ SparsityPatternBase & sparsity_pattern,
const AffineConstraints<number> &constraints = AffineConstraints<number>(),
const bool keep_constrained_dofs = true,
const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id);
*
* @ingroup constraints
*/
- template <int dim,
- int spacedim,
- typename SparsityPatternType,
- typename number = double>
+ template <int dim, int spacedim, typename number = double>
void
make_sparsity_pattern(
const DoFHandler<dim, spacedim> &dof_handler,
const Table<2, Coupling> & coupling,
- SparsityPatternType & sparsity_pattern,
+ SparsityPatternBase & sparsity_pattern,
const AffineConstraints<number> &constraints = AffineConstraints<number>(),
const bool keep_constrained_dofs = true,
const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id);
* whereas the ones that correspond to columns come from the second
* DoFHandler.
*/
- template <int dim, int spacedim, typename SparsityPatternType>
+ template <int dim, int spacedim>
void
make_sparsity_pattern(const DoFHandler<dim, spacedim> &dof_row,
const DoFHandler<dim, spacedim> &dof_col,
- SparsityPatternType & sparsity);
+ SparsityPatternBase & sparsity);
/**
* Compute which entries of a matrix built on the given @p dof_handler may
*
* @ingroup constraints
*/
- template <int dim, int spacedim, typename SparsityPatternType>
+ template <int dim, int spacedim>
void
make_flux_sparsity_pattern(const DoFHandler<dim, spacedim> &dof_handler,
- SparsityPatternType & sparsity_pattern);
+ SparsityPatternBase & sparsity_pattern);
/**
* This function does essentially the same as the other
*
* @ingroup constraints
*/
- template <int dim,
- int spacedim,
- typename SparsityPatternType,
- typename number>
+ template <int dim, int spacedim, typename number>
void
make_flux_sparsity_pattern(
const DoFHandler<dim, spacedim> &dof_handler,
- SparsityPatternType & sparsity_pattern,
+ SparsityPatternBase & sparsity_pattern,
const AffineConstraints<number> &constraints,
const bool keep_constrained_dofs = true,
const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id);
*
* @ingroup constraints
*/
- template <int dim, int spacedim, typename SparsityPatternType>
+ template <int dim, int spacedim>
void
make_flux_sparsity_pattern(
const DoFHandler<dim, spacedim> &dof,
- SparsityPatternType & sparsity,
+ SparsityPatternBase & sparsity,
const Table<2, Coupling> & cell_integrals_mask,
const Table<2, Coupling> & face_integrals_mask,
const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id);
* };
* @endcode
*/
- template <int dim,
- int spacedim,
- typename SparsityPatternType,
- typename number>
+ template <int dim, int spacedim, typename number>
void
make_flux_sparsity_pattern(
const DoFHandler<dim, spacedim> &dof,
- SparsityPatternType & sparsity,
+ SparsityPatternBase & sparsity,
const AffineConstraints<number> &constraints,
const bool keep_constrained_dofs,
const Table<2, Coupling> & couplings,
* the matrix does not consist of domain integrals, but only of integrals
* over the boundary of the domain.
*/
- template <int dim, int spacedim, typename SparsityPatternType>
+ template <int dim, int spacedim>
void
make_boundary_sparsity_pattern(
const DoFHandler<dim, spacedim> & dof,
const std::vector<types::global_dof_index> &dof_to_boundary_mapping,
- SparsityPatternType & sparsity_pattern);
+ SparsityPatternBase & sparsity_pattern);
/**
* This function is a variation of the previous
* map with the boundary indicators you want and set the function pointers to
* null pointers).
*/
- template <int dim,
- int spacedim,
- typename SparsityPatternType,
- typename number>
+ template <int dim, int spacedim, typename number>
void
make_boundary_sparsity_pattern(
const DoFHandler<dim, spacedim> &dof,
const std::map<types::boundary_id, const Function<spacedim, number> *>
& boundary_ids,
const std::vector<types::global_dof_index> &dof_to_boundary_mapping,
- SparsityPatternType & sparsity);
+ SparsityPatternBase & sparsity);
/**
* @}
namespace DoFTools
{
- template <int dim,
- int spacedim,
- typename SparsityPatternType,
- typename number>
+ template <int dim, int spacedim, typename number>
void
make_sparsity_pattern(const DoFHandler<dim, spacedim> &dof,
- SparsityPatternType & sparsity,
+ SparsityPatternBase & sparsity,
const AffineConstraints<number> &constraints,
const bool keep_constrained_dofs,
const types::subdomain_id subdomain_id)
- template <int dim,
- int spacedim,
- typename SparsityPatternType,
- typename number>
+ template <int dim, int spacedim, typename number>
void
make_sparsity_pattern(const DoFHandler<dim, spacedim> &dof,
const Table<2, Coupling> & couplings,
- SparsityPatternType & sparsity,
+ SparsityPatternBase & sparsity,
const AffineConstraints<number> &constraints,
const bool keep_constrained_dofs,
const types::subdomain_id subdomain_id)
- template <int dim, int spacedim, typename SparsityPatternType>
+ template <int dim, int spacedim>
void
make_sparsity_pattern(const DoFHandler<dim, spacedim> &dof_row,
const DoFHandler<dim, spacedim> &dof_col,
- SparsityPatternType & sparsity)
+ SparsityPatternBase & sparsity)
{
const types::global_dof_index n_dofs_row = dof_row.n_dofs();
const types::global_dof_index n_dofs_col = dof_col.n_dofs();
cell_row->get_dof_indices(local_dof_indices_row);
cell_col->get_dof_indices(local_dof_indices_col);
for (unsigned int i = 0; i < dofs_per_cell_row; ++i)
- sparsity.add_entries(local_dof_indices_row[i],
- local_dof_indices_col.begin(),
- local_dof_indices_col.end());
+ sparsity.add_row_entries(local_dof_indices_row[i],
+ make_array_view(local_dof_indices_col));
}
else if (cell_row->has_children())
{
cell_row_child->get_dof_indices(local_dof_indices_row);
cell_col->get_dof_indices(local_dof_indices_col);
for (unsigned int r = 0; r < dofs_per_cell_row; ++r)
- sparsity.add_entries(local_dof_indices_row[r],
- local_dof_indices_col.begin(),
- local_dof_indices_col.end());
+ sparsity.add_row_entries(local_dof_indices_row[r],
+ make_array_view(
+ local_dof_indices_col));
}
}
else
cell_row->get_dof_indices(local_dof_indices_row);
cell_col_child->get_dof_indices(local_dof_indices_col);
for (unsigned int r = 0; r < dofs_per_cell_row; ++r)
- sparsity.add_entries(local_dof_indices_row[r],
- local_dof_indices_col.begin(),
- local_dof_indices_col.end());
+ sparsity.add_row_entries(local_dof_indices_row[r],
+ make_array_view(
+ local_dof_indices_col));
}
}
}
- template <int dim, int spacedim, typename SparsityPatternType>
+ template <int dim, int spacedim>
void
make_boundary_sparsity_pattern(
const DoFHandler<dim, spacedim> & dof,
const std::vector<types::global_dof_index> &dof_to_boundary_mapping,
- SparsityPatternType & sparsity)
+ SparsityPatternBase & sparsity)
{
if (dim == 1)
{
boundary_ids;
boundary_ids[0] = nullptr;
boundary_ids[1] = nullptr;
- make_boundary_sparsity_pattern<dim, spacedim, SparsityPatternType>(
- dof, boundary_ids, dof_to_boundary_mapping, sparsity);
+ make_boundary_sparsity_pattern<dim, spacedim>(dof,
+ boundary_ids,
+ dof_to_boundary_mapping,
+ sparsity);
return;
}
std::vector<types::global_dof_index> dofs_on_this_face;
dofs_on_this_face.reserve(dof.get_fe_collection().max_dofs_per_face());
+ std::vector<types::global_dof_index> rows;
+ std::vector<types::global_dof_index> cols;
+
+ auto append_pair = [&](const types::global_dof_index i,
+ const types::global_dof_index j) {
+ rows.push_back(i);
+ cols.push_back(j);
+ };
+
// loop over all faces to check whether they are at a boundary. note
// that we need not take special care of single lines (using
// @p{cell->has_boundary_lines}), since we do not support boundaries of
// make sparsity pattern for this cell
for (unsigned int i = 0; i < dofs_per_face; ++i)
for (unsigned int j = 0; j < dofs_per_face; ++j)
- sparsity.add(dof_to_boundary_mapping[dofs_on_this_face[i]],
- dof_to_boundary_mapping[dofs_on_this_face[j]]);
+ append_pair(dof_to_boundary_mapping[dofs_on_this_face[i]],
+ dof_to_boundary_mapping[dofs_on_this_face[j]]);
+
+ sparsity.add_entries(make_array_view(rows), make_array_view(cols));
+ rows.clear();
+ cols.clear();
}
}
- template <int dim,
- int spacedim,
- typename SparsityPatternType,
- typename number>
+ template <int dim, int spacedim, typename number>
void
make_boundary_sparsity_pattern(
const DoFHandler<dim, spacedim> &dof,
const std::map<types::boundary_id, const Function<spacedim, number> *>
& boundary_ids,
const std::vector<types::global_dof_index> &dof_to_boundary_mapping,
- SparsityPatternType & sparsity)
+ SparsityPatternBase & sparsity)
{
if (dim == 1)
{
dof_to_boundary_mapping[cell->vertex_dof_index(direction, i)];
for (unsigned int i = 0; i < dofs_per_vertex; ++i)
- sparsity.add_entries(boundary_dof_boundary_indices[i],
- boundary_dof_boundary_indices.begin(),
- boundary_dof_boundary_indices.end());
+ sparsity.add_row_entries(boundary_dof_boundary_indices[i],
+ make_array_view(
+ boundary_dof_boundary_indices));
}
return;
}
std::vector<types::global_dof_index> dofs_on_this_face;
dofs_on_this_face.reserve(dof.get_fe_collection().max_dofs_per_face());
+
+ std::vector<types::global_dof_index> rows;
+ std::vector<types::global_dof_index> cols;
+
+ auto append_pair = [&](const types::global_dof_index i,
+ const types::global_dof_index j) {
+ rows.push_back(i);
+ cols.push_back(j);
+ };
+
for (const auto &cell : dof.active_cell_iterators())
for (const unsigned int f : cell->face_indices())
if (boundary_ids.find(cell->face(f)->boundary_id()) !=
// make sparsity pattern for this cell
for (unsigned int i = 0; i < dofs_per_face; ++i)
for (unsigned int j = 0; j < dofs_per_face; ++j)
- sparsity.add(dof_to_boundary_mapping[dofs_on_this_face[i]],
- dof_to_boundary_mapping[dofs_on_this_face[j]]);
+ append_pair(dof_to_boundary_mapping[dofs_on_this_face[i]],
+ dof_to_boundary_mapping[dofs_on_this_face[j]]);
+
+ sparsity.add_entries(make_array_view(rows), make_array_view(cols));
+ rows.clear();
+ cols.clear();
}
}
- template <int dim,
- int spacedim,
- typename SparsityPatternType,
- typename number>
+ template <int dim, int spacedim, typename number>
void
make_flux_sparsity_pattern(const DoFHandler<dim, spacedim> &dof,
- SparsityPatternType & sparsity,
+ SparsityPatternBase & sparsity,
const AffineConstraints<number> &constraints,
const bool keep_constrained_dofs,
const types::subdomain_id subdomain_id)
- template <int dim, int spacedim, typename SparsityPatternType>
+ template <int dim, int spacedim>
void
make_flux_sparsity_pattern(const DoFHandler<dim, spacedim> &dof,
- SparsityPatternType & sparsity)
+ SparsityPatternBase & sparsity)
{
AffineConstraints<double> dummy;
make_flux_sparsity_pattern(dof, sparsity, dummy);
{
// implementation of the same function in namespace DoFTools for
// non-hp-DoFHandlers
- template <int dim,
- int spacedim,
- typename SparsityPatternType,
- typename number>
+ template <int dim, int spacedim, typename number>
void
make_flux_sparsity_pattern(
const DoFHandler<dim, spacedim> &dof,
- SparsityPatternType & sparsity,
+ SparsityPatternBase & sparsity,
const AffineConstraints<number> &constraints,
const bool keep_constrained_dofs,
const Table<2, Coupling> & int_mask,
bool(const typename DoFHandler<dim, spacedim>::active_cell_iterator &,
const unsigned int)> &face_has_flux_coupling)
{
+ std::vector<types::global_dof_index> rows;
+ std::vector<types::global_dof_index> cols;
+
+ auto append_pair = [&](const types::global_dof_index i,
+ const types::global_dof_index j) {
+ rows.push_back(i);
+ cols.push_back(j);
+ };
+
if (dof.has_hp_capabilities() == false)
{
const FiniteElement<dim, spacedim> &fe = dof.get_fe();
if (flux_dof_mask(i, j) == always ||
(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]);
+ append_pair(dofs_on_this_cell[i],
+ dofs_on_this_cell[j]);
}
}
+ sparsity.add_entries(make_array_view(rows),
+ make_array_view(cols));
+ rows.clear();
+ cols.clear();
}
else
{
if (flux_dof_mask(i, j) == always)
{
- sparsity.add(
+ append_pair(
dofs_on_this_cell[i],
dofs_on_other_cell[j]);
- sparsity.add(
- dofs_on_other_cell[i],
- dofs_on_this_cell[j]);
- sparsity.add(
- dofs_on_this_cell[i],
- dofs_on_this_cell[j]);
- sparsity.add(
+ append_pair(dofs_on_other_cell[i],
+ dofs_on_this_cell[j]);
+ append_pair(dofs_on_this_cell[i],
+ dofs_on_this_cell[j]);
+ append_pair(
dofs_on_other_cell[i],
dofs_on_other_cell[j]);
}
nonzero)
{
if (i_non_zero_i && j_non_zero_e)
- sparsity.add(
+ append_pair(
dofs_on_this_cell[i],
dofs_on_other_cell[j]);
if (i_non_zero_e && j_non_zero_i)
- sparsity.add(
+ append_pair(
dofs_on_other_cell[i],
dofs_on_this_cell[j]);
if (i_non_zero_i && j_non_zero_i)
- sparsity.add(
+ append_pair(
dofs_on_this_cell[i],
dofs_on_this_cell[j]);
if (i_non_zero_e && j_non_zero_e)
- sparsity.add(
+ append_pair(
dofs_on_other_cell[i],
dofs_on_other_cell[j]);
}
if (flux_dof_mask(j, i) == always)
{
- sparsity.add(
+ append_pair(
dofs_on_this_cell[j],
dofs_on_other_cell[i]);
- sparsity.add(
- dofs_on_other_cell[j],
- dofs_on_this_cell[i]);
- sparsity.add(
- dofs_on_this_cell[j],
- dofs_on_this_cell[i]);
- sparsity.add(
+ append_pair(dofs_on_other_cell[j],
+ dofs_on_this_cell[i]);
+ append_pair(dofs_on_this_cell[j],
+ dofs_on_this_cell[i]);
+ append_pair(
dofs_on_other_cell[j],
dofs_on_other_cell[i]);
}
nonzero)
{
if (j_non_zero_i && i_non_zero_e)
- sparsity.add(
+ append_pair(
dofs_on_this_cell[j],
dofs_on_other_cell[i]);
if (j_non_zero_e && i_non_zero_i)
- sparsity.add(
+ append_pair(
dofs_on_other_cell[j],
dofs_on_this_cell[i]);
if (j_non_zero_i && i_non_zero_i)
- sparsity.add(
+ append_pair(
dofs_on_this_cell[j],
dofs_on_this_cell[i]);
if (j_non_zero_e && i_non_zero_e)
- sparsity.add(
+ append_pair(
dofs_on_other_cell[j],
dofs_on_other_cell[i]);
}
}
}
}
+ sparsity.add_entries(make_array_view(rows),
+ make_array_view(cols));
+ rows.clear();
+ cols.clear();
}
else
{
support_on_face(j, neighbor_face_n);
if (flux_dof_mask(i, j) == always)
{
- sparsity.add(dofs_on_this_cell[i],
- dofs_on_other_cell[j]);
- sparsity.add(dofs_on_other_cell[i],
- dofs_on_this_cell[j]);
- sparsity.add(dofs_on_this_cell[i],
- dofs_on_this_cell[j]);
- sparsity.add(dofs_on_other_cell[i],
- dofs_on_other_cell[j]);
+ append_pair(dofs_on_this_cell[i],
+ dofs_on_other_cell[j]);
+ append_pair(dofs_on_other_cell[i],
+ dofs_on_this_cell[j]);
+ append_pair(dofs_on_this_cell[i],
+ dofs_on_this_cell[j]);
+ append_pair(dofs_on_other_cell[i],
+ dofs_on_other_cell[j]);
}
if (flux_dof_mask(i, j) == nonzero)
{
if (i_non_zero_i && j_non_zero_e)
- sparsity.add(dofs_on_this_cell[i],
- dofs_on_other_cell[j]);
+ append_pair(dofs_on_this_cell[i],
+ dofs_on_other_cell[j]);
if (i_non_zero_e && j_non_zero_i)
- sparsity.add(dofs_on_other_cell[i],
- dofs_on_this_cell[j]);
+ append_pair(dofs_on_other_cell[i],
+ dofs_on_this_cell[j]);
if (i_non_zero_i && j_non_zero_i)
- sparsity.add(dofs_on_this_cell[i],
- dofs_on_this_cell[j]);
+ append_pair(dofs_on_this_cell[i],
+ dofs_on_this_cell[j]);
if (i_non_zero_e && j_non_zero_e)
- sparsity.add(dofs_on_other_cell[i],
- dofs_on_other_cell[j]);
+ append_pair(dofs_on_other_cell[i],
+ dofs_on_other_cell[j]);
}
if (flux_dof_mask(j, i) == always)
{
- sparsity.add(dofs_on_this_cell[j],
- dofs_on_other_cell[i]);
- sparsity.add(dofs_on_other_cell[j],
- dofs_on_this_cell[i]);
- sparsity.add(dofs_on_this_cell[j],
- dofs_on_this_cell[i]);
- sparsity.add(dofs_on_other_cell[j],
- dofs_on_other_cell[i]);
+ append_pair(dofs_on_this_cell[j],
+ dofs_on_other_cell[i]);
+ append_pair(dofs_on_other_cell[j],
+ dofs_on_this_cell[i]);
+ append_pair(dofs_on_this_cell[j],
+ dofs_on_this_cell[i]);
+ append_pair(dofs_on_other_cell[j],
+ dofs_on_other_cell[i]);
}
if (flux_dof_mask(j, i) == nonzero)
{
if (j_non_zero_i && i_non_zero_e)
- sparsity.add(dofs_on_this_cell[j],
- dofs_on_other_cell[i]);
+ append_pair(dofs_on_this_cell[j],
+ dofs_on_other_cell[i]);
if (j_non_zero_e && i_non_zero_i)
- sparsity.add(dofs_on_other_cell[j],
- dofs_on_this_cell[i]);
+ append_pair(dofs_on_other_cell[j],
+ dofs_on_this_cell[i]);
if (j_non_zero_i && i_non_zero_i)
- sparsity.add(dofs_on_this_cell[j],
- dofs_on_this_cell[i]);
+ append_pair(dofs_on_this_cell[j],
+ dofs_on_this_cell[i]);
if (j_non_zero_e && i_non_zero_e)
- sparsity.add(dofs_on_other_cell[j],
- dofs_on_other_cell[i]);
+ append_pair(dofs_on_other_cell[j],
+ dofs_on_other_cell[i]);
}
}
}
+ sparsity.add_entries(make_array_view(rows),
+ make_array_view(cols));
+ rows.clear();
+ cols.clear();
}
}
}
if ((flux_mask(ii, jj) == always) ||
(flux_mask(ii, jj) == nonzero))
{
- sparsity.add(
+ append_pair(
dofs_on_this_cell[i],
dofs_on_other_cell[j]);
}
if ((flux_mask(jj, ii) == always) ||
(flux_mask(jj, ii) == nonzero))
{
- sparsity.add(
- dofs_on_other_cell[j],
- dofs_on_this_cell[i]);
+ append_pair(dofs_on_other_cell[j],
+ dofs_on_this_cell[i]);
}
}
}
if ((flux_mask(ii, jj) == always) ||
(flux_mask(ii, jj) == nonzero))
{
- sparsity.add(dofs_on_this_cell[i],
- dofs_on_other_cell[j]);
+ append_pair(dofs_on_this_cell[i],
+ dofs_on_other_cell[j]);
}
if ((flux_mask(jj, ii) == always) ||
(flux_mask(jj, ii) == nonzero))
{
- sparsity.add(dofs_on_other_cell[j],
- dofs_on_this_cell[i]);
+ append_pair(dofs_on_other_cell[j],
+ dofs_on_this_cell[i]);
}
}
}
}
}
}
+ sparsity.add_entries(make_array_view(rows),
+ make_array_view(cols));
+ rows.clear();
+ cols.clear();
}
}
}
- template <int dim, int spacedim, typename SparsityPatternType>
+ template <int dim, int spacedim>
void
make_flux_sparsity_pattern(const DoFHandler<dim, spacedim> &dof,
- SparsityPatternType & sparsity,
+ SparsityPatternBase & sparsity,
const Table<2, Coupling> & int_mask,
const Table<2, Coupling> & flux_mask,
const types::subdomain_id subdomain_id)
- template <int dim,
- int spacedim,
- typename SparsityPatternType,
- typename number>
+ template <int dim, int spacedim, typename number>
void
make_flux_sparsity_pattern(
const DoFHandler<dim, spacedim> &dof,
- SparsityPatternType & sparsity,
+ SparsityPatternBase & sparsity,
const AffineConstraints<number> &constraints,
const bool keep_constrained_dofs,
const Table<2, Coupling> & int_mask,
//
// ---------------------------------------------------------------------
-for (scalar : REAL_AND_COMPLEX_SCALARS; SP : SPARSITY_PATTERNS;
- deal_II_dimension : DIMENSIONS)
+for (scalar : REAL_AND_COMPLEX_SCALARS; deal_II_dimension : DIMENSIONS)
{
template void DoFTools::make_boundary_sparsity_pattern<deal_II_dimension,
deal_II_dimension,
- SP,
scalar>(
const DoFHandler<deal_II_dimension> & dof,
const std::map<types::boundary_id,
const Function<deal_II_dimension, scalar> *> &boundary_ids,
const std::vector<types::global_dof_index> &dof_to_boundary_mapping,
- SP & sparsity);
+ SparsityPatternBase & sparsity);
#if deal_II_dimension < 3
template void
DoFTools::make_boundary_sparsity_pattern<deal_II_dimension,
deal_II_dimension + 1,
- SP,
scalar>(
const DoFHandler<deal_II_dimension, deal_II_dimension + 1> &dof,
const std::map<types::boundary_id,
const Function<deal_II_dimension + 1, scalar> *>
& boundary_ids,
const std::vector<types::global_dof_index> &dof_to_boundary_mapping,
- SP & sparsity);
+ SparsityPatternBase & sparsity);
#endif
template void
DoFTools::make_boundary_sparsity_pattern<deal_II_dimension,
deal_II_dimension + 2,
- SP,
scalar>(
const DoFHandler<deal_II_dimension, deal_II_dimension + 2> &dof,
const std::map<types::boundary_id,
const Function<deal_II_dimension + 2, scalar> *>
& boundary_ids,
const std::vector<types::global_dof_index> &dof_to_boundary_mapping,
- SP & sparsity);
+ SparsityPatternBase & sparsity);
#endif
}
-for (SP : SPARSITY_PATTERNS; deal_II_dimension : DIMENSIONS;
- S : REAL_AND_COMPLEX_SCALARS)
+for (deal_II_dimension : DIMENSIONS; S : REAL_AND_COMPLEX_SCALARS)
{
template void
- DoFTools::make_sparsity_pattern<deal_II_dimension, deal_II_dimension, SP>(
+ DoFTools::make_sparsity_pattern<deal_II_dimension, deal_II_dimension>(
const DoFHandler<deal_II_dimension, deal_II_dimension> &dof,
- SP & sparsity,
+ SparsityPatternBase & sparsity,
const AffineConstraints<S> &,
const bool,
const types::subdomain_id);
template void
- DoFTools::make_sparsity_pattern<deal_II_dimension, deal_II_dimension, SP>(
+ DoFTools::make_sparsity_pattern<deal_II_dimension, deal_II_dimension>(
const DoFHandler<deal_II_dimension, deal_II_dimension> &,
const Table<2, Coupling> &,
- SP &,
+ SparsityPatternBase &,
const AffineConstraints<S> &,
const bool,
const types::subdomain_id);
- template void DoFTools::
- make_flux_sparsity_pattern<deal_II_dimension, deal_II_dimension, SP>(
- const DoFHandler<deal_II_dimension> &dof,
- SP & sparsity,
- const AffineConstraints<S> &,
- const bool,
- const Table<2, Coupling> &,
- const Table<2, Coupling> &,
- const types::subdomain_id,
- const std::function<bool(
- const typename DoFHandler<deal_II_dimension>::active_cell_iterator &,
- const unsigned int)> &);
-
- template void DoFTools::
- make_flux_sparsity_pattern<deal_II_dimension, deal_II_dimension, SP>(
- const DoFHandler<deal_II_dimension> &dof,
- SP & sparsity,
- const AffineConstraints<S> &,
- const bool,
- const types::subdomain_id);
+ template void
+ DoFTools::make_flux_sparsity_pattern<deal_II_dimension, deal_II_dimension>(
+ const DoFHandler<deal_II_dimension> &dof,
+ SparsityPatternBase & sparsity,
+ const AffineConstraints<S> &,
+ const bool,
+ const Table<2, Coupling> &,
+ const Table<2, Coupling> &,
+ const types::subdomain_id,
+ const std::function<bool(
+ const typename DoFHandler<deal_II_dimension>::active_cell_iterator &,
+ const unsigned int)> &);
+
+ template void
+ DoFTools::make_flux_sparsity_pattern<deal_II_dimension, deal_II_dimension>(
+ const DoFHandler<deal_II_dimension> &dof,
+ SparsityPatternBase & sparsity,
+ const AffineConstraints<S> &,
+ const bool,
+ const types::subdomain_id);
#if deal_II_dimension < 3
- template void DoFTools::
- make_sparsity_pattern<deal_II_dimension, deal_II_dimension + 1, SP>(
- const DoFHandler<deal_II_dimension, deal_II_dimension + 1> &dof,
- SP & sparsity,
- const AffineConstraints<S> &,
- const bool,
- const types::subdomain_id);
-
- template void DoFTools::
- make_sparsity_pattern<deal_II_dimension, deal_II_dimension + 1, SP>(
- const DoFHandler<deal_II_dimension, deal_II_dimension + 1> &,
- const Table<2, Coupling> &,
- SP &,
- const AffineConstraints<S> &,
- const bool,
- const types::subdomain_id);
-
- template void DoFTools::
- make_flux_sparsity_pattern<deal_II_dimension, deal_II_dimension + 1, SP>(
- const DoFHandler<deal_II_dimension, deal_II_dimension + 1> &dof,
- SP & sparsity,
- const AffineConstraints<S> &,
- const bool,
- const Table<2, Coupling> &,
- const Table<2, Coupling> &,
- const types::subdomain_id,
- const std::function<bool(
- const typename DoFHandler<deal_II_dimension, deal_II_dimension + 1>::
- active_cell_iterator &,
- const unsigned int)> &);
-
- template void DoFTools::
- make_flux_sparsity_pattern<deal_II_dimension, deal_II_dimension + 1, SP>(
- const DoFHandler<deal_II_dimension, deal_II_dimension + 1> &dof,
- SP & sparsity,
- const AffineConstraints<S> &,
- const bool,
- const types::subdomain_id);
+ template void
+ DoFTools::make_sparsity_pattern<deal_II_dimension, deal_II_dimension + 1>(
+ const DoFHandler<deal_II_dimension, deal_II_dimension + 1> &dof,
+ SparsityPatternBase & sparsity,
+ const AffineConstraints<S> &,
+ const bool,
+ const types::subdomain_id);
+
+ template void
+ DoFTools::make_sparsity_pattern<deal_II_dimension, deal_II_dimension + 1>(
+ const DoFHandler<deal_II_dimension, deal_II_dimension + 1> &,
+ const Table<2, Coupling> &,
+ SparsityPatternBase &,
+ const AffineConstraints<S> &,
+ const bool,
+ const types::subdomain_id);
+
+ template void DoFTools::make_flux_sparsity_pattern<deal_II_dimension,
+ deal_II_dimension + 1>(
+ const DoFHandler<deal_II_dimension, deal_II_dimension + 1> &dof,
+ SparsityPatternBase & sparsity,
+ const AffineConstraints<S> &,
+ const bool,
+ const Table<2, Coupling> &,
+ const Table<2, Coupling> &,
+ const types::subdomain_id,
+ const std::function<bool(
+ const typename DoFHandler<deal_II_dimension, deal_II_dimension + 1>::
+ active_cell_iterator &,
+ const unsigned int)> &);
+
+ template void DoFTools::make_flux_sparsity_pattern<deal_II_dimension,
+ deal_II_dimension + 1>(
+ const DoFHandler<deal_II_dimension, deal_II_dimension + 1> &dof,
+ SparsityPatternBase & sparsity,
+ const AffineConstraints<S> &,
+ const bool,
+ const types::subdomain_id);
#endif
#if deal_II_dimension == 3
- template void DoFTools::make_sparsity_pattern<1, 3, SP>(
+ template void DoFTools::make_sparsity_pattern<1, 3>(
const DoFHandler<1, 3> &dof,
- SP & sparsity,
+ SparsityPatternBase & sparsity,
const AffineConstraints<S> &,
const bool,
const types::subdomain_id);
- template void DoFTools::make_sparsity_pattern<1, 3, SP>(
+ template void DoFTools::make_sparsity_pattern<1, 3>(
const DoFHandler<1, 3> &,
const Table<2, Coupling> &,
- SP &,
+ SparsityPatternBase &,
const AffineConstraints<S> &,
const bool,
const types::subdomain_id);
- template void DoFTools::make_flux_sparsity_pattern<1, 3, SP>(
+ template void DoFTools::make_flux_sparsity_pattern<1, 3>(
const DoFHandler<1, 3> &dof,
- SP & sparsity,
+ SparsityPatternBase & sparsity,
const AffineConstraints<S> &,
const bool,
const Table<2, Coupling> &,
bool(const typename DoFHandler<1, 3>::active_cell_iterator &,
const unsigned int)> &);
- template void DoFTools::make_flux_sparsity_pattern<1, 3, SP>(
+ template void DoFTools::make_flux_sparsity_pattern<1, 3>(
const DoFHandler<1, 3> &dof,
- SP & sparsity,
+ SparsityPatternBase & sparsity,
const AffineConstraints<S> &,
const bool,
const types::subdomain_id);
#endif
}
-for (SP : SPARSITY_PATTERNS; deal_II_dimension : DIMENSIONS)
+for (deal_II_dimension : DIMENSIONS)
{
template void
- DoFTools::make_sparsity_pattern<deal_II_dimension, deal_II_dimension, SP>(
+ DoFTools::make_sparsity_pattern<deal_II_dimension, deal_II_dimension>(
const DoFHandler<deal_II_dimension, deal_II_dimension> &dof_row,
const DoFHandler<deal_II_dimension, deal_II_dimension> &dof_col,
- SP & sparsity);
-
- template void DoFTools::
- make_boundary_sparsity_pattern<deal_II_dimension, deal_II_dimension, SP>(
- const DoFHandler<deal_II_dimension> &dof,
- const std::vector<types::global_dof_index> &,
- SP &);
-
- template void DoFTools::
- make_flux_sparsity_pattern<deal_II_dimension, deal_II_dimension, SP>(
- const DoFHandler<deal_II_dimension> &dof, SP &sparsity);
-
- template void DoFTools::
- make_flux_sparsity_pattern<deal_II_dimension, deal_II_dimension, SP>(
- const DoFHandler<deal_II_dimension> &dof,
- SP & sparsity,
- const Table<2, Coupling> &,
- const Table<2, Coupling> &,
- const types::subdomain_id);
+ SparsityPatternBase & sparsity);
+
+ template void DoFTools::make_boundary_sparsity_pattern<deal_II_dimension,
+ deal_II_dimension>(
+ const DoFHandler<deal_II_dimension> &dof,
+ const std::vector<types::global_dof_index> &,
+ SparsityPatternBase &);
+
+ template void
+ DoFTools::make_flux_sparsity_pattern<deal_II_dimension, deal_II_dimension>(
+ const DoFHandler<deal_II_dimension> &dof, SparsityPatternBase &sparsity);
+
+ template void
+ DoFTools::make_flux_sparsity_pattern<deal_II_dimension, deal_II_dimension>(
+ const DoFHandler<deal_II_dimension> &dof,
+ SparsityPatternBase & sparsity,
+ const Table<2, Coupling> &,
+ const Table<2, Coupling> &,
+ const types::subdomain_id);
#if deal_II_dimension < 3
- template void DoFTools::
- make_flux_sparsity_pattern<deal_II_dimension, deal_II_dimension + 1, SP>(
- const DoFHandler<deal_II_dimension, deal_II_dimension + 1> &dof,
- SP & sparsity);
-
- template void DoFTools::
- make_flux_sparsity_pattern<deal_II_dimension, deal_II_dimension + 1, SP>(
- const DoFHandler<deal_II_dimension, deal_II_dimension + 1> &dof,
- SP & sparsity,
- const Table<2, Coupling> &,
- const Table<2, Coupling> &,
- const types::subdomain_id);
-
- template void DoFTools::
- make_sparsity_pattern<deal_II_dimension, deal_II_dimension + 1, SP>(
- const DoFHandler<deal_II_dimension, deal_II_dimension + 1> &dof_row,
- const DoFHandler<deal_II_dimension, deal_II_dimension + 1> &dof_col,
- SP & sparsity);
-
- template void DoFTools::make_boundary_sparsity_pattern<
- deal_II_dimension,
- deal_II_dimension + 1,
- SP>(const DoFHandler<deal_II_dimension, deal_II_dimension + 1> &dof,
- const std::vector<types::global_dof_index> &,
- SP &);
+ template void DoFTools::make_flux_sparsity_pattern<deal_II_dimension,
+ deal_II_dimension + 1>(
+ const DoFHandler<deal_II_dimension, deal_II_dimension + 1> &dof,
+ SparsityPatternBase & sparsity);
+
+ template void DoFTools::make_flux_sparsity_pattern<deal_II_dimension,
+ deal_II_dimension + 1>(
+ const DoFHandler<deal_II_dimension, deal_II_dimension + 1> &dof,
+ SparsityPatternBase & sparsity,
+ const Table<2, Coupling> &,
+ const Table<2, Coupling> &,
+ const types::subdomain_id);
+
+ template void
+ DoFTools::make_sparsity_pattern<deal_II_dimension, deal_II_dimension + 1>(
+ const DoFHandler<deal_II_dimension, deal_II_dimension + 1> &dof_row,
+ const DoFHandler<deal_II_dimension, deal_II_dimension + 1> &dof_col,
+ SparsityPatternBase & sparsity);
+
+ template void
+ DoFTools::make_boundary_sparsity_pattern<deal_II_dimension,
+ deal_II_dimension + 1>(
+ const DoFHandler<deal_II_dimension, deal_II_dimension + 1> &dof,
+ const std::vector<types::global_dof_index> &,
+ SparsityPatternBase &);
#endif
#if deal_II_dimension == 3
- template void DoFTools::make_sparsity_pattern<1, 3, SP>(
+ template void DoFTools::make_sparsity_pattern<1, 3>(
const DoFHandler<1, 3> &dof_row,
const DoFHandler<1, 3> &dof_col,
- SP & sparsity);
+ SparsityPatternBase & sparsity);
- template void DoFTools::make_boundary_sparsity_pattern<1, 3, SP>(
+ template void DoFTools::make_boundary_sparsity_pattern<1, 3>(
const DoFHandler<1, 3> &dof,
const std::vector<types::global_dof_index> &,
- SP &);
+ SparsityPatternBase &);
- template void DoFTools::make_flux_sparsity_pattern<1, 3, SP>(
- const DoFHandler<1, 3> &dof, SP &sparsity);
+ template void DoFTools::make_flux_sparsity_pattern<1, 3>(
+ const DoFHandler<1, 3> &dof, SparsityPatternBase &sparsity);
- template void DoFTools::make_flux_sparsity_pattern<1, 3, SP>(
+ template void DoFTools::make_flux_sparsity_pattern<1, 3>(
const DoFHandler<1, 3> &dof,
- SP & sparsity,
+ SparsityPatternBase & sparsity,
const Table<2, Coupling> &,
const Table<2, Coupling> &,
const types::subdomain_id);
projects / dealii.git / commitdiff