level_set_constraints.clear();
const IndexSet level_set_locally_relevant_dofs =
DoFTools::extract_locally_relevant_dofs(level_set_dof_handler);
- level_set_constraints.reinit(level_set_locally_relevant_dofs);
+ level_set_constraints.reinit(level_set_dof_handler.locally_owned_dofs(),
+ level_set_locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(level_set_dof_handler,
level_set_constraints);
level_set_constraints.close();
dealii::DoFTools::extract_locally_relevant_dofs(dof_handler);
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
dealii::DoFTools::make_hanging_node_constraints(dof_handler, constraints);
dealii::VectorTools::interpolate_boundary_values(
dof_handler, 0, dealii::Functions::ZeroFunction<dim>(), constraints);
locally_relevant_dofs = DoFTools::extract_locally_relevant_dofs(dof_handler);
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
VectorTools::interpolate_boundary_values(dof_handler,
0,
dealii::DoFTools::extract_locally_relevant_dofs(dof_handler);
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
dealii::DoFTools::make_hanging_node_constraints(dof_handler, constraints);
dealii::VectorTools::interpolate_boundary_values(
dof_handler, 0, dealii::Functions::ZeroFunction<dim>(), constraints);
const IndexSet locally_relevant_dofs =
DoFTools::extract_locally_relevant_dofs(dof_handler);
AffineConstraints<double> constraints;
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(dof_handler.locally_owned_dofs(), locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
VectorTools::interpolate_boundary_values(dof_handler,
0,
const IndexSet locally_relevant_dofs =
DoFTools::extract_locally_relevant_dofs(dof_handler);
AffineConstraints<double> constraints;
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(dof_handler.locally_owned_dofs(), locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
VectorTools::interpolate_boundary_values(dof_handler,
0,
const IndexSet locally_relevant_dofs =
DoFTools::extract_locally_relevant_dofs(dof_handler);
AffineConstraints<double> constraints;
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(dof_handler.locally_owned_dofs(), locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
VectorTools::interpolate_boundary_values(dof_handler,
0,
locally_relevant_dofs = DoFTools::extract_locally_relevant_dofs(dof_handler);
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
VectorTools::interpolate_boundary_values(dof_handler,
0,
const IndexSet is_hanging_node_constrained =
DoFTools::extract_hanging_node_dofs(dof_handler);
- AffineConstraints<double> constraints(locally_relevant_dofs);
+ AffineConstraints<double> constraints(dof_handler.locally_owned_dofs(),
+ locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
constraints.close();
DoFTools::extract_locally_relevant_dofs(dh);
AffineConstraints<double> cm;
- cm.reinit(locally_relevant_set);
+ cm.reinit(dh.locally_owned_dofs(), locally_relevant_set);
DoFTools::make_hanging_node_constraints(dh, cm);
cm.close();
DoFTools::extract_locally_relevant_dofs(dh);
AffineConstraints<double> cm;
- cm.reinit(locally_relevant_set);
+ cm.reinit(locally_owned_set, locally_relevant_set);
DoFTools::make_hanging_node_constraints(dh, cm);
cm.close();
locally_relevant_dofs = DoFTools::extract_locally_relevant_dofs(dof_handler);
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
SigmaFunction<dim> boundary_value_func;
DoFTools::extract_locally_relevant_dofs(dof_handler);
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
VectorTools::interpolate_boundary_values(dof_handler,
0,
DoFTools::extract_locally_relevant_dofs(dof_handler);
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
VectorTools::interpolate_boundary_values(dof_handler,
0,
stokes_relevant_set.print(deallog.get_file_stream());
- AffineConstraints<double> cm(stokes_relevant_set);
+ AffineConstraints<double> cm(stokes_index_set, stokes_relevant_set);
DoFTools::make_hanging_node_constraints(stokes_dof_handler, cm);
stokes_relevant_set.get_view(n_u, n_u + n_p));
stokes_relevant_set.print(deallog.get_file_stream());
- AffineConstraints<double> cm(stokes_relevant_set);
+ AffineConstraints<double> cm(stokes_index_set, stokes_relevant_set);
DoFTools::make_hanging_node_constraints(stokes_dof_handler, cm);
using number = typename LA::MPI::BlockSparseMatrix::value_type;
- AffineConstraints<number> constraints(locally_relevant_dofs);
+ AffineConstraints<number> constraints(locally_owned_dofs,
+ locally_relevant_dofs);
constraints.close();
BlockDynamicSparsityPattern bcsp(locally_relevant_partitioning);
locally_relevant_dofs.print(deallog);
- AffineConstraints<double> constraints(locally_relevant_dofs);
+ AffineConstraints<double> constraints(locally_owned_dofs,
+ locally_relevant_dofs);
constraints.close();
TrilinosWrappers::BlockSparsityPattern sp(locally_owned_partitioning,
system_rhs = 0;
constraints.clear();
- // constraints.reinit(locally_relevant_dofs);
+ // constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
VectorTools::interpolate_boundary_values(dof_handler,
0,
const IndexSet &owned_set = dof.locally_owned_dofs();
const IndexSet relevant_set = DoFTools::extract_locally_relevant_dofs(dof);
- AffineConstraints<double> constraints(relevant_set);
+ AffineConstraints<double> constraints(owned_set, relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
0,
{
dof_handler.distribute_dofs(fe);
+ const IndexSet &locally_owned_dofs = dof_handler.locally_owned_dofs();
+ const IndexSet locally_relevant_dofs =
+ DoFTools::extract_locally_relevant_dofs(dof_handler);
+
constraints.clear();
- constraints.reinit(dof_handler.locally_owned_dofs(),
- DoFTools::extract_locally_relevant_dofs(dof_handler));
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
VectorTools::interpolate_boundary_values(dof_handler,
0,
BoundaryValues<dim>(),
constraints);
constraints.close();
- const IndexSet &locally_owned_dofs = dof_handler.locally_owned_dofs();
- const IndexSet locally_relevant_dofs =
- DoFTools::extract_locally_relevant_dofs(dof_handler);
-
DynamicSparsityPattern dsp(locally_relevant_dofs);
DoFTools::make_sparsity_pattern(dof_handler, dsp, constraints, false);
SparsityTools::distribute_sparsity_pattern(dsp,
{
dof_handler.distribute_dofs(fe);
+ const IndexSet &locally_owned_dofs = dof_handler.locally_owned_dofs();
+ const IndexSet locally_relevant_dofs =
+ DoFTools::extract_locally_relevant_dofs(dof_handler);
+
constraints.clear();
- constraints.reinit(dof_handler.locally_owned_dofs(),
- DoFTools::extract_locally_relevant_dofs(dof_handler));
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
VectorTools::interpolate_boundary_values(dof_handler,
0,
BoundaryValues<dim>(),
constraints);
constraints.close();
- const IndexSet &locally_owned_dofs = dof_handler.locally_owned_dofs();
- const IndexSet locally_relevant_dofs =
- DoFTools::extract_locally_relevant_dofs(dof_handler);
-
DynamicSparsityPattern dsp(locally_relevant_dofs);
DoFTools::make_sparsity_pattern(dof_handler, dsp, constraints, false);
SparsityTools::distribute_sparsity_pattern(dsp,
dofs_per_block[0] + dofs_per_block[1]));
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
constraints.close();
// See
system_rhs.reinit(locally_owned_dofs, mpi_communicator);
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
VectorTools::interpolate_boundary_values(dof_handler,
0,
system_rhs.reinit(locally_owned_dofs, mpi_communicator);
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
VectorTools::interpolate_boundary_values(dof_handler,
0,
system_rhs.reinit(locally_owned_dofs, mpi_communicator);
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
VectorTools::interpolate_boundary_values(dof_handler,
0,
system_rhs.reinit(locally_owned_dofs, mpi_communicator);
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
VectorTools::interpolate_boundary_values(dof_handler,
0,
system_rhs.reinit(locally_owned_dofs, mpi_communicator);
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
VectorTools::interpolate_boundary_values(dof_handler,
0,
system_rhs.reinit(locally_owned_dofs, mpi_communicator);
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
VectorTools::interpolate_boundary_values(dof_handler,
0,
const IndexSet locally_relevant_dofs =
DoFTools::extract_locally_relevant_dofs(dof_handler);
AffineConstraints<double> constraints;
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(dof_handler.locally_owned_dofs(), locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
VectorTools::interpolate_boundary_values(dof_handler,
0,
// constraints:
AffineConstraints<double> constraints_euler;
- constraints_euler.reinit(locally_relevant_dofs_euler);
+ constraints_euler.reinit(locally_owned_dofs_euler,
+ locally_relevant_dofs_euler);
DoFTools::make_hanging_node_constraints(dof_handler_euler, constraints_euler);
constraints_euler.close();
AffineConstraints<double> constraints;
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
constraints_euler.close();
AffineConstraints<double> level_constraints;
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_level_dofs(dof_handler, level);
- level_constraints.reinit(relevant_dofs);
+ level_constraints.reinit(dof_handler.locally_owned_mg_dofs(level),
+ relevant_dofs);
level_constraints.add_lines(
mg_constrained_dofs.get_boundary_indices(level));
level_constraints.close();
// constraints:
AffineConstraints<double> constraints_euler;
- constraints_euler.reinit(locally_relevant_dofs_euler);
+ constraints_euler.reinit(locally_owned_dofs_euler,
+ locally_relevant_dofs_euler);
DoFTools::make_hanging_node_constraints(dof_handler_euler, constraints_euler);
constraints_euler.close();
AffineConstraints<double> constraints;
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
constraints_euler.close();
// constraints:
AffineConstraints<double> constraints_euler;
- constraints_euler.reinit(locally_relevant_dofs_euler);
+ constraints_euler.reinit(locally_owned_dofs_euler,
+ locally_relevant_dofs_euler);
DoFTools::make_hanging_node_constraints(dof_handler_euler, constraints_euler);
constraints_euler.close();
AffineConstraints<double> constraints;
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
constraints.close();
AffineConstraints<double> level_constraints;
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_level_dofs(dof_handler, level);
- level_constraints.reinit(relevant_dofs);
+ level_constraints.reinit(dof_handler.locally_owned_mg_dofs(level),
+ relevant_dofs);
level_constraints.add_lines(
mg_constrained_dofs.get_boundary_indices(level));
level_constraints.close();
AffineConstraints<double> level_constraints;
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_level_dofs(dof, level);
- level_constraints.reinit(relevant_dofs);
+ level_constraints.reinit(dof.locally_owned_mg_dofs(level), relevant_dofs);
level_constraints.add_lines(
mg_constrained_dofs.get_boundary_indices(level));
level_constraints.close();
const IndexSet locally_relevant_dofs =
DoFTools::extract_locally_relevant_dofs(dof_handler);
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(dof_handler.locally_owned_dofs(), locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
const IndexSet &owned_set = dof.locally_owned_dofs();
const IndexSet relevant_set = DoFTools::extract_locally_relevant_dofs(dof);
- AffineConstraints<double> constraints(relevant_set);
+ AffineConstraints<double> constraints(owned_set, relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
// constrain bottom part of the boundary (lower in y direction)
VectorTools::interpolate_boundary_values(dof,
const IndexSet &owned_set = dof.locally_owned_dofs();
const IndexSet relevant_set = DoFTools::extract_locally_relevant_dofs(dof);
- AffineConstraints<double> constraints(relevant_set);
+ AffineConstraints<double> constraints(owned_set, relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
// constrain bottom part of the boundary (lower in y direction)
VectorTools::interpolate_boundary_values(dof,
// constraints:
AffineConstraints<double> constraints;
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
constraints.close();
const IndexSet &owned_set = dof.locally_owned_dofs();
const IndexSet relevant_set = DoFTools::extract_locally_relevant_dofs(dof);
- AffineConstraints<double> constraints(relevant_set);
+ AffineConstraints<double> constraints(owned_set, relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
0,
const IndexSet &owned_set = dof.locally_owned_dofs();
const IndexSet relevant_set = DoFTools::extract_locally_relevant_dofs(dof);
- AffineConstraints<double> constraints(relevant_set);
+ AffineConstraints<double> constraints(owned_set, relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
0,
const IndexSet &owned_set = dof.locally_owned_dofs();
const IndexSet relevant_set = DoFTools::extract_locally_relevant_dofs(dof);
- AffineConstraints<double> constraints(relevant_set);
+ AffineConstraints<double> constraints(owned_set, relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
0,
const IndexSet &owned_set = dof.locally_owned_dofs();
const IndexSet relevant_set = DoFTools::extract_locally_relevant_dofs(dof);
- AffineConstraints<double> constraints(relevant_set);
+ AffineConstraints<double> constraints(owned_set, relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
0,
const IndexSet &owned_set = dof.locally_owned_dofs();
const IndexSet relevant_set = DoFTools::extract_locally_relevant_dofs(dof);
- AffineConstraints<double> constraints(relevant_set);
+ AffineConstraints<double> constraints(owned_set, relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
0,
const IndexSet &owned_set = dof.locally_owned_dofs();
const IndexSet relevant_set = DoFTools::extract_locally_relevant_dofs(dof);
- AffineConstraints<double> constraints(relevant_set);
+ AffineConstraints<double> constraints(owned_set, relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
0,
const IndexSet &owned_set = dof.locally_owned_dofs();
const IndexSet relevant_set = DoFTools::extract_locally_relevant_dofs(dof);
- AffineConstraints<double> constraints(relevant_set);
+ AffineConstraints<double> constraints(owned_set, relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
constraints.close();
const IndexSet &owned_set = dof.locally_owned_dofs();
const IndexSet relevant_set = DoFTools::extract_locally_relevant_dofs(dof);
- AffineConstraints<double> constraints_0(relevant_set),
- constraints_1(relevant_set);
+ AffineConstraints<double> constraints_0(owned_set, relevant_set),
+ constraints_1(owned_set, relevant_set);
VectorTools::interpolate_boundary_values(dof,
0,
Functions::ZeroFunction<dim>(),
IndexSet relevant_set;
DoFTools::extract_locally_relevant_dofs(dof, relevant_set);
- AffineConstraints<double> constraints(relevant_set);
+ AffineConstraints<double> constraints(owned_set, relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
0,
const IndexSet &owned_set = dof.locally_owned_dofs();
const IndexSet relevant_set = DoFTools::extract_locally_relevant_dofs(dof);
- AffineConstraints<double> constraints(relevant_set);
+ AffineConstraints<double> constraints(owned_set, relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
0,
const IndexSet &owned_set = dof.locally_owned_dofs();
const IndexSet relevant_set = DoFTools::extract_locally_relevant_dofs(dof);
- AffineConstraints<double> constraints(relevant_set);
+ AffineConstraints<double> constraints(owned_set, relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
0,
const IndexSet &owned_set = dof.locally_owned_dofs();
const IndexSet relevant_set = DoFTools::extract_locally_relevant_dofs(dof);
- AffineConstraints<double> constraints(relevant_set);
+ AffineConstraints<double> constraints(owned_set, relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
0,
const IndexSet &owned_set = dof.locally_owned_dofs();
const IndexSet relevant_set = DoFTools::extract_locally_relevant_dofs(dof);
- AffineConstraints<double> constraints(relevant_set);
+ AffineConstraints<double> constraints(owned_set, relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
0,
const IndexSet &owned_set = dof.locally_owned_dofs();
const IndexSet relevant_set = DoFTools::extract_locally_relevant_dofs(dof);
- AffineConstraints<double> constraints(relevant_set);
+ AffineConstraints<double> constraints(owned_set, relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
0,
const IndexSet &owned_set = dof.locally_owned_dofs();
const IndexSet relevant_set = DoFTools::extract_locally_relevant_dofs(dof);
- AffineConstraints<double> constraints(relevant_set);
+ AffineConstraints<double> constraints(owned_set, relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
0,
IndexSet relevant_set;
DoFTools::extract_locally_relevant_dofs(dof, relevant_set);
- AffineConstraints<double> constraints(relevant_set);
+ AffineConstraints<double> constraints(owned_set, relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
0,
IndexSet relevant_set;
DoFTools::extract_locally_relevant_dofs(dof, relevant_set);
- AffineConstraints<double> constraints(relevant_set);
+ AffineConstraints<double> constraints(owned_set, relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
0,
const IndexSet &owned_set = dof.locally_owned_dofs();
const IndexSet relevant_set = DoFTools::extract_locally_relevant_dofs(dof);
- AffineConstraints<double> constraints(relevant_set);
+ AffineConstraints<double> constraints(owned_set, relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
0,
const IndexSet &owned_set = dof.locally_owned_dofs();
const IndexSet relevant_set = DoFTools::extract_locally_relevant_dofs(dof);
- AffineConstraints<double> constraints(relevant_set);
+ AffineConstraints<double> constraints(owned_set, relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
0,
// fine-level constraints
AffineConstraints<double> constraints;
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(dof.locally_owned_dofs(), locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
dirichlet_boundary,
AffineConstraints<double> level_constraints;
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_level_dofs(dof, level);
- level_constraints.reinit(relevant_dofs);
+ level_constraints.reinit(dof.locally_owned_mg_dofs(level), relevant_dofs);
level_constraints.add_lines(
mg_constrained_dofs.get_boundary_indices(level));
level_constraints.close();
{
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_dofs(dof_handler);
- constraints.reinit(relevant_dofs);
+ constraints.reinit(dof_handler.locally_owned_dofs(), relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
VectorTools::interpolate_boundary_values(dof_handler,
dirichlet_boundary,
}
else
{
+ const IndexSet &locally_owned =
+ dof_handler.locally_owned_mg_dofs(level);
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_level_dofs(dof_handler, level);
- constraints.reinit(relevant_dofs);
+ constraints.reinit(locally_owned, relevant_dofs);
constraints.add_lines(mg_constrained_dofs.get_boundary_indices(level));
const std::vector<types::global_dof_index> interface_indices =
edge_constrained_indices.clear();
edge_constrained_indices.reserve(interface_indices.size());
edge_constrained_values.resize(interface_indices.size());
- const IndexSet &locally_owned =
- dof_handler.locally_owned_mg_dofs(level);
for (unsigned int i = 0; i < interface_indices.size(); ++i)
if (locally_owned.is_element(interface_indices[i]))
edge_constrained_indices.push_back(
AffineConstraints<double> hanging_node_constraints;
const IndexSet locally_relevant_dofs =
DoFTools::extract_locally_relevant_dofs(dof);
- hanging_node_constraints.reinit(locally_relevant_dofs);
+ hanging_node_constraints.reinit(dof.locally_owned_dofs(),
+ locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof, hanging_node_constraints);
hanging_node_constraints.close();
// fine-level constraints
AffineConstraints<double> constraints;
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(dof.locally_owned_dofs(), locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
dirichlet_boundary,
{
// this is to make it consistent with parallel_multigrid_adaptive.cc
AffineConstraints<double> hanging_node_constraints;
- hanging_node_constraints.reinit(locally_relevant_dofs);
+ hanging_node_constraints.reinit(dof.locally_owned_dofs(),
+ locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof, hanging_node_constraints);
hanging_node_constraints.close();
AffineConstraints<double> level_constraints;
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_level_dofs(dof, level);
- level_constraints.reinit(relevant_dofs);
+ level_constraints.reinit(dof.locally_owned_mg_dofs(level), relevant_dofs);
level_constraints.add_lines(
mg_constrained_dofs.get_boundary_indices(level));
level_constraints.close();
{
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_dofs(dof_handler);
- constraints.reinit(relevant_dofs);
+ constraints.reinit(dof_handler.locally_owned_dofs(), relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
VectorTools::interpolate_boundary_values(dof_handler,
dirichlet_boundary,
}
else
{
+ const IndexSet &locally_owned =
+ dof_handler.locally_owned_mg_dofs(level);
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_level_dofs(dof_handler, level);
- constraints.reinit(relevant_dofs);
+ constraints.reinit(locally_owned, relevant_dofs);
constraints.add_lines(mg_constrained_dofs.get_boundary_indices(level));
const std::vector<types::global_dof_index> interface_indices =
edge_constrained_indices.clear();
edge_constrained_indices.reserve(interface_indices.size());
edge_constrained_values.resize(interface_indices.size());
- const IndexSet &locally_owned =
- dof_handler.locally_owned_mg_dofs(level);
for (unsigned int i = 0; i < interface_indices.size(); ++i)
if (locally_owned.is_element(interface_indices[i]))
edge_constrained_indices.push_back(
AffineConstraints<double> hanging_node_constraints;
const IndexSet locally_relevant_dofs =
DoFTools::extract_locally_relevant_dofs(dof);
- hanging_node_constraints.reinit(locally_relevant_dofs);
+ hanging_node_constraints.reinit(dof.locally_owned_dofs(),
+ locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof, hanging_node_constraints);
hanging_node_constraints.close();
// fine-level constraints
AffineConstraints<double> constraints;
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(dof.locally_owned_dofs(), locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
dirichlet_boundary,
{
// this is to make it consistent with parallel_multigrid_adaptive.cc
AffineConstraints<double> hanging_node_constraints;
- hanging_node_constraints.reinit(locally_relevant_dofs);
+ hanging_node_constraints.reinit(dof.locally_owned_dofs(),
+ locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof, hanging_node_constraints);
hanging_node_constraints.close();
AffineConstraints<double> level_constraints;
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_level_dofs(dof, level);
- level_constraints.reinit(relevant_dofs);
+ level_constraints.reinit(dof.locally_owned_mg_dofs(level), relevant_dofs);
level_constraints.add_lines(
mg_constrained_dofs.get_boundary_indices(level));
level_constraints.close();
{
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_dofs(dof_handler);
- constraints.reinit(relevant_dofs);
+ constraints.reinit(dof_handler.locally_owned_dofs(), relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
VectorTools::interpolate_boundary_values(dof_handler,
dirichlet_boundary,
}
else
{
+ const IndexSet &locally_owned =
+ dof_handler.locally_owned_mg_dofs(level);
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_level_dofs(dof_handler, level);
- constraints.reinit(relevant_dofs);
+ constraints.reinit(locally_owned, relevant_dofs);
constraints.add_lines(mg_constrained_dofs.get_boundary_indices(level));
const std::vector<types::global_dof_index> interface_indices =
edge_constrained_indices.clear();
edge_constrained_indices.reserve(interface_indices.size());
edge_constrained_values.resize(interface_indices.size());
- const IndexSet &locally_owned =
- dof_handler.locally_owned_mg_dofs(level);
for (unsigned int i = 0; i < interface_indices.size(); ++i)
if (locally_owned.is_element(interface_indices[i]))
edge_constrained_indices.push_back(
AffineConstraints<double> hanging_node_constraints;
const IndexSet locally_relevant_dofs =
DoFTools::extract_locally_relevant_dofs(dof);
- hanging_node_constraints.reinit(locally_relevant_dofs);
+ hanging_node_constraints.reinit(dof.locally_owned_dofs(),
+ locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof, hanging_node_constraints);
hanging_node_constraints.close();
// fine-level constraints
AffineConstraints<double> constraints;
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(dof.locally_owned_dofs(), locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
dirichlet_boundary,
{
// this is to make it consistent with parallel_multigrid_adaptive.cc
AffineConstraints<double> hanging_node_constraints;
- hanging_node_constraints.reinit(locally_relevant_dofs);
+ hanging_node_constraints.reinit(dof.locally_owned_dofs(),
+ locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof, hanging_node_constraints);
hanging_node_constraints.close();
AffineConstraints<double> level_constraints;
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_level_dofs(dof, level);
- level_constraints.reinit(relevant_dofs);
+ level_constraints.reinit(dof.locally_owned_mg_dofs(level), relevant_dofs);
level_constraints.add_lines(
mg_constrained_dofs.get_boundary_indices(level));
level_constraints.close();
// fine-level constraints
AffineConstraints<double> constraints;
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(dof.locally_owned_dofs(), locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
dirichlet_boundary,
{
// this is to make it consistent with parallel_multigrid_adaptive.cc
AffineConstraints<double> hanging_node_constraints;
- hanging_node_constraints.reinit(locally_relevant_dofs);
+ hanging_node_constraints.reinit(dof.locally_owned_dofs(),
+ locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof, hanging_node_constraints);
hanging_node_constraints.close();
AffineConstraints<double> level_constraints;
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_level_dofs(dof, level);
- level_constraints.reinit(relevant_dofs);
+ level_constraints.reinit(dof.locally_owned_mg_dofs(level), relevant_dofs);
level_constraints.add_lines(
mg_constrained_dofs.get_boundary_indices(level));
level_constraints.close();
std::vector<const AffineConstraints<double> *> constraints_ptrs(dof.size());
for (unsigned int i = 0; i < dof.size(); ++i)
{
- constraints[i].reinit(locally_relevant_dofs[i]);
+ constraints[i].reinit(dof[i]->locally_owned_dofs(),
+ locally_relevant_dofs[i]);
DoFTools::make_hanging_node_constraints(*dof[i], constraints[i]);
VectorTools::interpolate_boundary_values(*dof[i],
dirichlet_boundary,
// this is to make it consistent with parallel_multigrid_adaptive.cc
AffineConstraints<double> hanging_node_constraints;
- hanging_node_constraints.reinit(locally_relevant_dofs[b]);
+ hanging_node_constraints.reinit(dof[b]->locally_owned_dofs(),
+ locally_relevant_dofs[b]);
DoFTools::make_hanging_node_constraints(*dof[b],
hanging_node_constraints);
hanging_node_constraints.close();
{
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_level_dofs(*dof[i], level);
- level_constraints[i].reinit(relevant_dofs);
+ level_constraints[i].reinit(dof[i]->locally_owned_mg_dofs(level),
+ relevant_dofs);
level_constraints[i].add_lines(
mg_constrained_dofs[i].get_boundary_indices(level));
level_constraints[i].close();
// fine-level constraints
AffineConstraints<double> constraints;
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(dof.locally_owned_dofs(), locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
dirichlet_boundary,
{
// this is to make it consistent with parallel_multigrid_adaptive.cc
AffineConstraints<double> hanging_node_constraints;
- hanging_node_constraints.reinit(locally_relevant_dofs);
+ hanging_node_constraints.reinit(dof.locally_owned_dofs(),
+ locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof, hanging_node_constraints);
hanging_node_constraints.close();
AffineConstraints<double> level_constraints;
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_level_dofs(dof, level);
- level_constraints.reinit(relevant_dofs);
+ level_constraints.reinit(dof.locally_owned_mg_dofs(level), relevant_dofs);
level_constraints.add_lines(
mg_constrained_dofs.get_boundary_indices(level));
level_constraints.close();
const IndexSet locally_relevant_dofs =
DoFTools::extract_locally_relevant_dofs(dof);
AffineConstraints<double> constraints;
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(dof.locally_owned_dofs(), locally_relevant_dofs);
VectorTools::interpolate_boundary_values(dof,
dirichlet_boundary,
constraints);
AffineConstraints<double> level_constraints;
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_level_dofs(dof, level);
- level_constraints.reinit(relevant_dofs);
+ level_constraints.reinit(dof.locally_owned_mg_dofs(level), relevant_dofs);
level_constraints.add_lines(
mg_constrained_dofs.get_boundary_indices(level));
level_constraints.close();
dof.distribute_dofs(fe);
AffineConstraints<double> constraints;
const IndexSet relevant_dofs = DoFTools::extract_locally_relevant_dofs(dof);
- constraints.reinit(relevant_dofs);
+ constraints.reinit(dof.locally_owned_dofs(), relevant_dofs);
VectorTools::interpolate_boundary_values(dof,
0,
Functions::ZeroFunction<dim>(),
DoFHandler<dim> dof(tria);
dof.distribute_dofs(fe);
- IndexSet owned_set = dof.locally_owned_dofs();
- IndexSet relevant_set;
- AffineConstraints<double> constraints(relevant_set);
typename MatrixFree<dim, number>::AdditionalData addit_data;
addit_data.tasks_parallel_scheme =
MatrixFree<dim, number>::AdditionalData::none;
+ IndexSet relevant_set;
+ AffineConstraints<double> constraints;
{
+ constraints.clear();
relevant_set = DoFTools::extract_locally_relevant_dofs(dof);
+ constraints.reinit(dof.locally_owned_dofs(), relevant_set);
constraints.close();
-
- DoFRenumbering::matrix_free_data_locality(dof, constraints, addit_data);
}
- constraints.clear();
- relevant_set = DoFTools::extract_locally_relevant_dofs(dof);
- constraints.close();
+ DoFRenumbering::matrix_free_data_locality(dof, constraints, addit_data);
+
+ {
+ constraints.clear();
+ relevant_set = DoFTools::extract_locally_relevant_dofs(dof);
+ constraints.reinit(dof.locally_owned_dofs(), relevant_set);
+ constraints.close();
+ }
const QGauss<1> quadrature(dof.get_fe().degree + 1);
MatrixFree<dim, number> mf_data;
DoFTools::extract_locally_relevant_dofs(dof_handler);
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(dof_handler.locally_owned_dofs(), locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
VectorTools::interpolate_boundary_values(dof_handler,
0,
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_level_dofs(dof_handler, level);
AffineConstraints<double> level_constraints;
- level_constraints.reinit(relevant_dofs);
+ level_constraints.reinit(dof_handler.locally_owned_mg_dofs(level),
+ relevant_dofs);
level_constraints.add_lines(
mg_constrained_dofs.get_boundary_indices(level));
level_constraints.close();
locally_relevant_dofs =
DoFTools::extract_locally_relevant_dofs(dof_handler);
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(dof_handler.locally_owned_dofs(), locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
constraints.close();
locally_relevant_dofs =
DoFTools::extract_locally_relevant_dofs(dof_handler);
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(dof_handler.locally_owned_dofs(), locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
constraints.close();
const IndexSet locally_relevant_dofs_u =
DoFTools::extract_locally_relevant_dofs(dof_handler_u);
- constraints_u.reinit(locally_relevant_dofs_u);
+ constraints_u.reinit(dof_handler_u.locally_owned_dofs(),
+ locally_relevant_dofs_u);
DoFTools::make_hanging_node_constraints(dof_handler_u, constraints_u);
VectorTools::interpolate_boundary_values(
const IndexSet locally_relevant_dofs_p =
DoFTools::extract_locally_relevant_dofs(dof_handler_p);
- constraints_p.reinit(locally_relevant_dofs_p);
+ constraints_p.reinit(dof_handler_p.locally_owned_dofs(),
+ locally_relevant_dofs_p);
DoFTools::make_hanging_node_constraints(dof_handler_p, constraints_p);
constraints_p.close();
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_level_dofs(dof_handler_u, level);
AffineConstraints<double> level_constraints;
- level_constraints.reinit(relevant_dofs);
+ level_constraints.reinit(dof_handler_u.locally_owned_mg_dofs(level),
+ relevant_dofs);
level_constraints.add_lines(
mg_constrained_dofs.get_boundary_indices(level));
level_constraints.close();
AffineConstraints<double> constraints_u_no_dirchlet;
const IndexSet locally_relevant_dofs_u =
DoFTools::extract_locally_relevant_dofs(dof_handler_u);
- constraints_u_no_dirchlet.reinit(locally_relevant_dofs_u);
+ constraints_u_no_dirchlet.reinit(dof_handler_u.locally_owned_dofs(),
+ locally_relevant_dofs_u);
DoFTools::make_hanging_node_constraints(dof_handler_u,
constraints_u_no_dirchlet);
constraints_u_no_dirchlet.close();
deallog << "locally relevant dofs :" << std::endl;
relevant_set.print(deallog.get_file_stream());
- AffineConstraints<double> constraints(relevant_set);
+ AffineConstraints<double> constraints(owned_set, relevant_set);
constraints.close();
MappingQ<dim> mapping(fe_degree);
const IndexSet &owned_set = dof.locally_owned_dofs();
const IndexSet relevant_set = DoFTools::extract_locally_relevant_dofs(dof);
- AffineConstraints<double> constraints(relevant_set);
+ AffineConstraints<double> constraints(owned_set, relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
0,
const IndexSet &owned_set = dof.locally_owned_dofs();
const IndexSet relevant_set = DoFTools::extract_locally_relevant_dofs(dof);
- AffineConstraints<double> constraints(relevant_set);
+ AffineConstraints<double> constraints(owned_set, relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
0,
const IndexSet &owned_set = dof.locally_owned_dofs();
const IndexSet relevant_set = DoFTools::extract_locally_relevant_dofs(dof);
- AffineConstraints<double> constraints(relevant_set);
+ AffineConstraints<double> constraints(owned_set, relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
0,
const IndexSet &owned_set = dof.locally_owned_dofs();
const IndexSet relevant_set = DoFTools::extract_locally_relevant_dofs(dof);
- AffineConstraints<double> constraints(relevant_set);
+ AffineConstraints<double> constraints(owned_set, relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
0,
const IndexSet &owned_set = dof.locally_owned_dofs();
const IndexSet relevant_set = DoFTools::extract_locally_relevant_dofs(dof);
- AffineConstraints<double> constraints(relevant_set);
+ AffineConstraints<double> constraints(owned_set, relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
0,
const IndexSet &owned_set = dof.locally_owned_dofs();
const IndexSet relevant_set = DoFTools::extract_locally_relevant_dofs(dof);
- AffineConstraints<double> constraints(relevant_set);
+ AffineConstraints<double> constraints(owned_set, relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
0,
deallog << "locally relevant dofs :" << std::endl;
owned_set.print(deallog.get_file_stream());
- AffineConstraints<double> constraints(relevant_set);
+ AffineConstraints<double> constraints(owned_set, relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
0,
solution.reinit(mg_dof_handler.locally_owned_dofs(), MPI_COMM_WORLD);
system_rhs.reinit(mg_dof_handler.locally_owned_dofs(), MPI_COMM_WORLD);
- constraints.reinit(locally_relevant_set);
+ constraints.reinit(mg_dof_handler.locally_owned_dofs(),
+ locally_relevant_set);
DoFTools::make_hanging_node_constraints(mg_dof_handler, constraints);
const std::set<types::boundary_id> dirichlet_boundary_ids = {0};
{
const IndexSet dofset =
DoFTools::extract_locally_relevant_level_dofs(mg_dof_handler, level);
- boundary_constraints[level].reinit(dofset);
+ boundary_constraints[level].reinit(
+ mg_dof_handler.locally_owned_mg_dofs(level), dofset);
boundary_constraints[level].add_lines(
mg_constrained_dofs.get_refinement_edge_indices(level));
boundary_constraints[level].add_lines(
force.reinit(locally_owned_dofs, mpi_communicator);
Assert(!force.has_ghost_elements(), ExcInternalError());
- AffineConstraints<PetscScalar> constraints(locally_relevant_dofs);
+ AffineConstraints<PetscScalar> constraints(locally_owned_dofs,
+ locally_relevant_dofs);
constraints.clear();
{
const IndexSet boundary_dofs =
TrilinosWrappers::MPI::Vector x_rel;
x_rel.reinit(relevant_set, MPI_COMM_WORLD);
- AffineConstraints<double> cm(relevant_set);
+ AffineConstraints<double> cm(owned_set, relevant_set);
DoFTools::make_hanging_node_constraints(dofh, cm);
ComponentMask velocity_mask(dim + 1, true);
AffineConstraints<double> constraints;
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
for (unsigned int id = 0; id < 1; ++id)
// Apply a constant function at the boundary
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
VectorTools::interpolate_boundary_values(
dof_handler, 0, Functions::ConstantFunction<dim>(1.0), constraints);
AffineConstraints<double> constraints;
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(dh.locally_owned_dofs(), locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dh, constraints);
AffineConstraints<double> constraints;
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(dh.locally_owned_dofs(), locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dh, constraints);
AffineConstraints<double> constraints;
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(dh.locally_owned_dofs(), locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dh, constraints);
DoFTools::extract_locally_relevant_dofs(dh);
AffineConstraints<double> constraints;
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(dh.locally_owned_dofs(), locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dh, constraints);
deallog << "OK" << std::endl;
DoFTools::extract_locally_relevant_dofs(dof_handler);
AffineConstraints<double> hanging_node_constraints;
- hanging_node_constraints.reinit(locally_relevant_dofs);
+ hanging_node_constraints.reinit(dof_handler.locally_owned_dofs(),
+ locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler,
hanging_node_constraints);
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
system_rhs = PetscScalar();
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
VectorTools::interpolate_boundary_values(dof_handler,
0,
system_rhs = PetscScalar();
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
VectorTools::interpolate_boundary_values(
dof_handler, 0, Functions::ZeroFunction<dim, PetscScalar>(), constraints);
system_rhs.reinit(locally_owned_dofs, mpi_communicator);
system_rhs = 0;
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
VectorTools::interpolate_boundary_values(dof_handler,
0,
// locally relevant dofs, so do the test again with that
{
const IndexSet relevant_set = DoFTools::extract_locally_relevant_dofs(dofh);
- AffineConstraints<double> boundary_values(relevant_set);
+ AffineConstraints<double> boundary_values(dofh.locally_owned_dofs(),
+ relevant_set);
DoFTools::make_zero_boundary_constraints(dofh, boundary_values);
if (Utilities::MPI::this_mpi_process(MPI_COMM_WORLD) == 0)
boundary_values.print(deallog.get_file_stream());
const IndexSet relevant_set = DoFTools::extract_locally_relevant_dofs(dofh);
AffineConstraints<double> constraints;
- constraints.reinit(relevant_set);
+ constraints.reinit(dofh.locally_owned_dofs(), relevant_set);
DoFTools::make_hanging_node_constraints(dofh, constraints);
std::set<types::boundary_id> no_normal_flux_boundaries;
no_normal_flux_boundaries.insert(1);
const IndexSet relevant_set = DoFTools::extract_locally_relevant_dofs(dofh);
AffineConstraints<double> constraints;
- constraints.reinit(relevant_set);
+ constraints.reinit(dofh.locally_owned_dofs(), relevant_set);
DoFTools::make_hanging_node_constraints(dofh, constraints);
std::set<types::boundary_id> no_normal_flux_boundaries;
no_normal_flux_boundaries.insert(1);
const IndexSet relevant_set = DoFTools::extract_locally_relevant_dofs(dofh);
AffineConstraints<double> constraints;
- constraints.reinit(relevant_set);
+ constraints.reinit(dofh.locally_owned_dofs(), relevant_set);
DoFTools::make_hanging_node_constraints(dofh, constraints);
const std::set<types::boundary_id> no_normal_flux_boundaries = {0};
const unsigned int degree = 1;
const IndexSet relevant_set = DoFTools::extract_locally_relevant_dofs(dofh);
AffineConstraints<double> constraints;
- constraints.reinit(relevant_set);
+ constraints.reinit(dofh.locally_owned_dofs(), relevant_set);
DoFTools::make_hanging_node_constraints(dofh, constraints);
std::set<types::boundary_id> no_normal_flux_boundaries;
no_normal_flux_boundaries.insert(1);
AffineConstraints<double> cm;
DoFTools::make_hanging_node_constraints(dofh, cm);
- AffineConstraints<double> cm2(dof_set);
+ AffineConstraints<double> cm2(dofh.locally_owned_dofs(), dof_set);
DoFTools::make_hanging_node_constraints(dofh, cm2);
{
AffineConstraints<double> cm;
DoFTools::make_hanging_node_constraints(dofh, cm);
- AffineConstraints<double> cm2(dof_set);
+ AffineConstraints<double> cm2(dofh.locally_owned_dofs(), dof_set);
DoFTools::make_hanging_node_constraints(dofh, cm2);
if (myid == 0)
TrilinosWrappers::MPI::Vector x_rel;
x_rel.reinit(relevant_set, MPI_COMM_WORLD);
- AffineConstraints<double> cm(relevant_set);
+ AffineConstraints<double> cm(owned_set, relevant_set);
DoFTools::make_hanging_node_constraints(dofh, cm);
ComponentMask velocity_mask(dim + 1, true);
x_rel.reinit(relevant_set, MPI_COMM_WORLD);
- AffineConstraints<double> cm(relevant_set);
+ AffineConstraints<double> cm(owned_set, relevant_set);
DoFTools::make_hanging_node_constraints(dofh, cm);
/* std::vector<bool> velocity_mask (dim+1, true);
// AffineConstraints<double>::distribute should not do
// anything
x1 = x_ref;
- AffineConstraints<double> cm(relevant_set);
+ AffineConstraints<double> cm(owned_set, relevant_set);
DoFTools::make_hanging_node_constraints(dofh, cm);
cm.close();
cm.distribute(x1);
AffineConstraints<double> cm;
DoFTools::make_hanging_node_constraints(dofh, cm);
- AffineConstraints<double> cm2(dof_set);
+ AffineConstraints<double> cm2(dofh.locally_owned_dofs(), dof_set);
DoFTools::make_hanging_node_constraints(dofh, cm2);
{
TrilinosWrappers::MPI::Vector x_rel;
x_rel.reinit(relevant_set, MPI_COMM_WORLD);
- AffineConstraints<double> cm(relevant_set);
+ AffineConstraints<double> cm(owned_set, relevant_set);
DoFTools::make_hanging_node_constraints(dofh, cm);
cm.close();
x_rel.reinit(relevant_set, MPI_COMM_WORLD);
- AffineConstraints<double> cm(relevant_set);
+ AffineConstraints<double> cm(owned_set, relevant_set);
DoFTools::make_hanging_node_constraints(dofh, cm);
/* std::vector<bool> velocity_mask (dim+1, true);
// build constraint matrix
const IndexSet locally_relevant =
DoFTools::extract_locally_relevant_dofs(dof);
- AffineConstraints<double> constraints(locally_relevant);
+ AffineConstraints<double> constraints(dof.locally_owned_dofs(),
+ locally_relevant);
DoFTools::make_hanging_node_constraints(dof, constraints);
constraints.close();
const IndexSet &owned_set = dof.locally_owned_dofs();
const IndexSet relevant_set = DoFTools::extract_locally_relevant_dofs(dof);
- AffineConstraints<double> constraints(relevant_set);
+ AffineConstraints<double> constraints(owned_set, relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
0,
const IndexSet &owned_set = dof.locally_owned_dofs();
const IndexSet relevant_set = DoFTools::extract_locally_relevant_dofs(dof);
- AffineConstraints<double> constraints(relevant_set);
+ AffineConstraints<double> constraints(owned_set, relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
0,
const IndexSet &owned_set = dof.locally_owned_dofs();
const IndexSet relevant_set = DoFTools::extract_locally_relevant_dofs(dof);
- AffineConstraints<double> constraints(relevant_set);
+ AffineConstraints<double> constraints(owned_set, relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
0,
const IndexSet &owned_set = dof.locally_owned_dofs();
const IndexSet relevant_set = DoFTools::extract_locally_relevant_dofs(dof);
- AffineConstraints<double> constraints(relevant_set);
+ AffineConstraints<double> constraints(owned_set, relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
0,
const IndexSet &owned_set = dof.locally_owned_dofs();
const IndexSet relevant_set = DoFTools::extract_locally_relevant_dofs(dof);
- AffineConstraints<double> constraints(relevant_set);
+ AffineConstraints<double> constraints(owned_set, relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
0,
const IndexSet &owned_set = dof.locally_owned_dofs();
const IndexSet relevant_set = DoFTools::extract_locally_relevant_dofs(dof);
- AffineConstraints<double> constraints(relevant_set);
+ AffineConstraints<double> constraints(owned_set, relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
0,
const IndexSet &owned_set = dof.locally_owned_dofs();
const IndexSet relevant_set = DoFTools::extract_locally_relevant_dofs(dof);
- AffineConstraints<double> constraints(relevant_set);
+ AffineConstraints<double> constraints(owned_set, relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
0,
const IndexSet &owned_set = dof.locally_owned_dofs();
const IndexSet relevant_set = DoFTools::extract_locally_relevant_dofs(dof);
- AffineConstraints<double> constraints(relevant_set);
+ AffineConstraints<double> constraints(owned_set, relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
0,
// Periodic Conditions
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
for (int i = 1; i < dim; ++i)
DoFTools::make_periodicity_constraints(dof_handler,
locally_relevant_dofs.get_view(n_u, n_u + n_p));
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
const FEValuesExtractors::Vector velocities(0);
const FEValuesExtractors::Scalar pressure(dim);
locally_relevant_dofs.get_view(n_u, n_u + n_p));
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
const FEValuesExtractors::Vector velocities(0);
const FEValuesExtractors::Scalar pressure(dim);
const IndexSet locally_relevant_dofs =
DoFTools::extract_locally_relevant_dofs(dof_handler);
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
{
std::vector<
GridTools::PeriodicFacePair<typename DoFHandler<dim>::cell_iterator>>
/// creating combined hanging node and periodic constraint matrix
AffineConstraints<double> constraints;
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(dof_handler.locally_owned_dofs(), locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
std::vector<
GridTools::PeriodicFacePair<typename DoFHandler<dim>::cell_iterator>>
/// creating combined hanging node and periodic constraint matrix
AffineConstraints<double> constraints;
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(dof_handler.locally_owned_dofs(), locally_relevant_dofs);
std::vector<
GridTools::PeriodicFacePair<typename DoFHandler<dim>::cell_iterator>>
/// creating combined hanging node and periodic constraint matrix
AffineConstraints<double> constraints;
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(dof_handler.locally_owned_dofs(), locally_relevant_dofs);
for (int d = 0; d < dim; ++d)
DoFTools::make_periodicity_constraints(
std::max<int>(100 * myid - 50, 0),
std::min(static_cast<types::global_dof_index>(100 * myid + 150),
vec.size()));
- AffineConstraints<PetscScalar> cm(locally_relevant_range);
+ AffineConstraints<PetscScalar> cm(vec.locally_owned_elements(),
+ locally_relevant_range);
// add constraints that constrain an element in the middle of the
// local range of each processor against an element outside, both in
std::max<int>(100 * myid - 50, 0),
std::min(static_cast<types::global_dof_index>(100 * myid + 150),
vec.size()));
- AffineConstraints<PetscScalar> cm(locally_relevant_range);
+ AffineConstraints<PetscScalar> cm(vec.locally_owned_elements(),
+ locally_relevant_range);
// add constraints that constrain an element in the middle of the
// local range of each processor against an element outside, both in
system_rhs.reinit(locally_owned_dofs, mpi_communicator);
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
VectorTools::interpolate_boundary_values(dof_handler,
0,
<< std::endl;
{
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(dof_handler.locally_owned_dofs(),
+ locally_relevant_dofs);
const FEValuesExtractors::Vector velocities(0);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
DoFTools::extract_locally_relevant_dofs(dof_handler);
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(dof_handler.locally_owned_dofs(), locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
VectorTools::interpolate_boundary_values(dof_handler,
0,
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_level_dofs(dof_handler, level);
AffineConstraints<double> level_constraints;
- level_constraints.reinit(relevant_dofs);
+ level_constraints.reinit(dof_handler.locally_owned_mg_dofs(level),
+ relevant_dofs);
level_constraints.add_lines(
mg_constrained_dofs.get_boundary_indices(level));
level_constraints.close();
non_homogeneous_constraints.clear();
{
AffineConstraints<double> hanging_nodes_laplace_constraints;
- hanging_nodes_laplace_constraints.reinit(locally_relevant_dofs);
- non_homogeneous_constraints.reinit(locally_relevant_dofs);
+ hanging_nodes_laplace_constraints.reinit(dof_handler.locally_owned_dofs(),
+ locally_relevant_dofs);
+ non_homogeneous_constraints.reinit(dof_handler.locally_owned_dofs(),
+ locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(
dof_handler, hanging_nodes_laplace_constraints);
system_rhs = PetscScalar();
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
VectorTools::interpolate_boundary_values(dof_handler,
0,
system_rhs = PetscScalar();
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
VectorTools::interpolate_boundary_values(dof_handler,
0,
system_rhs = PetscScalar();
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
VectorTools::interpolate_boundary_values(dof_handler,
0,
system_rhs = PetscScalar();
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
VectorTools::interpolate_boundary_values(dof_handler,
0,
std::max<int>(100 * myid - 50, 0),
std::min(static_cast<types::global_dof_index>(100 * myid + 150),
vec.size()));
- AffineConstraints<double> cm(locally_relevant_range);
+ AffineConstraints<double> cm(vec.locally_owned_elements(),
+ locally_relevant_range);
// add constraints that constrain an element in the middle of the
// local range of each processor against an element outside, both in
std::max<int>(100 * myid - 50, 0),
std::min(static_cast<types::global_dof_index>(100 * myid + 150),
vec.size()));
- AffineConstraints<double> cm(locally_relevant_range);
+ AffineConstraints<double> cm(vec.locally_owned_elements(),
+ locally_relevant_range);
// add constraints that constrain an element in the middle of the
// local range of each processor against an element outside, both in
DoFTools::extract_locally_relevant_dofs(dofh);
AffineConstraints<double> cm;
- cm.reinit(locally_relevant_set);
+ cm.reinit(dofh.locally_owned_dofs(), locally_relevant_set);
DoFTools::make_hanging_node_constraints(dofh, cm);
std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
system_rhs.reinit(locally_owned_dofs, mpi_communicator);
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
VectorTools::interpolate_boundary_values(dof_handler,
0,
// set up constraints
const IndexSet locally_relevant_dofs =
DoFTools::extract_locally_relevant_dofs(dof_handler);
- constraint.reinit(locally_relevant_dofs);
+ constraint.reinit(dof_handler.locally_owned_dofs(),
+ locally_relevant_dofs);
VectorTools::interpolate_boundary_values(
*mapping, dof_handler, 0, Functions::ZeroFunction<dim>(), constraint);
constraint.close();
// constraints:
AffineConstraints<double> constraints;
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
constraints.close();
DoFTools::extract_locally_relevant_dofs(dof_handler);
AffineConstraints<double> constraints;
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(dof_handler.locally_owned_dofs(), locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
std::vector<
// set up constraints
const IndexSet locally_relevant_dofs =
DoFTools::extract_locally_relevant_dofs(dof_handler);
- constraint.reinit(locally_relevant_dofs);
+ constraint.reinit(dof_handler.locally_owned_dofs(),
+ locally_relevant_dofs);
VectorTools::interpolate_boundary_values(
*mapping, dof_handler, 0, Functions::ZeroFunction<dim>(), constraint);
constraint.close();
// set up constraints
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_level_dofs(dof_handler, l);
- constraint.reinit(relevant_dofs);
+ constraint.reinit(dof_handler.locally_owned_mg_dofs(l), relevant_dofs);
constraint.add_lines(mg_constrained_dofs.get_boundary_indices(l));
constraint.close();
// set up constraints
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_level_dofs(dof_handler, l);
- constraint.reinit(relevant_dofs);
+ constraint.reinit(dof_handler.locally_owned_mg_dofs(l), relevant_dofs);
constraint.add_lines(mg_constrained_dofs.get_boundary_indices(l));
constraint.close();
// set up constraints
const IndexSet locally_relevant_dofs =
DoFTools::extract_locally_relevant_dofs(dof_handler);
- constraint.reinit(locally_relevant_dofs);
+ constraint.reinit(dof_handler.locally_owned_dofs(),
+ locally_relevant_dofs);
VectorTools::interpolate_boundary_values(
*mapping, dof_handler, 0, Functions::ZeroFunction<dim>(), constraint);
DoFTools::make_hanging_node_constraints(dof_handler, constraint);
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_level_dofs(dof_handler, 0 /*level*/);
- constraint.reinit(relevant_dofs);
+ constraint.reinit(dof_handler.locally_owned_mg_dofs(0), relevant_dofs);
constraint.add_lines(
mg_constrained_dofs.get_boundary_indices(0 /*level*/));
constraint.close();
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_level_dofs(dof_handler, level);
- constraint.reinit(relevant_dofs);
+ constraint.reinit(dof_handler.locally_owned_mg_dofs(level),
+ relevant_dofs);
constraint.add_lines(mg_constrained_dofs.get_boundary_indices(level));
constraint.close();
AffineConstraints<Number> fine_constraints;
const IndexSet locally_relevant_dofs =
DoFTools::extract_locally_relevant_dofs(fine_dof_handler);
- fine_constraints.reinit(locally_relevant_dofs);
+ fine_constraints.reinit(fine_dof_handler.locally_owned_dofs(),
+ locally_relevant_dofs);
VectorTools::interpolate_boundary_values(*mapping,
fine_dof_handler,
0,
// set up constraints
const IndexSet locally_relevant_dofs =
DoFTools::extract_locally_relevant_dofs(dof_handler);
- constraint.reinit(locally_relevant_dofs);
+ constraint.reinit(dof_handler.locally_owned_dofs(),
+ locally_relevant_dofs);
VectorTools::interpolate_boundary_values(
*mapping, dof_handler, 0, Functions::ZeroFunction<dim>(), constraint);
DoFTools::make_hanging_node_constraints(dof_handler, constraint);
// set up constraints
const IndexSet locally_relevant_dofs =
DoFTools::extract_locally_relevant_dofs(dof_handler);
- constraint.reinit(locally_relevant_dofs);
+ constraint.reinit(dof_handler.locally_owned_dofs(),
+ locally_relevant_dofs);
VectorTools::interpolate_boundary_values(
*mapping, dof_handler, 0, Functions::ZeroFunction<dim>(), constraint);
constraint.close();
// set up constraints
const IndexSet locally_relevant_dofs =
DoFTools::extract_locally_relevant_dofs(dof_handler);
- constraint.reinit(locally_relevant_dofs);
+ constraint.reinit(dof_handler.locally_owned_dofs(),
+ locally_relevant_dofs);
VectorTools::interpolate_boundary_values(
*_mapping, dof_handler, 0, Functions::ZeroFunction<dim>(), constraint);
constraint.close();
// set up constraints
const IndexSet locally_relevant_dofs =
DoFTools::extract_locally_relevant_dofs(dof_handler);
- constraint.reinit(locally_relevant_dofs);
+ constraint.reinit(dof_handler.locally_owned_dofs(),
+ locally_relevant_dofs);
VectorTools::interpolate_boundary_values(
mapping, dof_handler, 0, Functions::ZeroFunction<dim>(), constraint);
constraint.close();
// set up constraints
const IndexSet locally_relevant_dofs =
DoFTools::extract_locally_relevant_dofs(dof_handler);
- constraint.reinit(locally_relevant_dofs);
+ constraint.reinit(dof_handler.locally_owned_dofs(),
+ locally_relevant_dofs);
VectorTools::interpolate_boundary_values(
*mapping, dof_handler, 0, Functions::ZeroFunction<dim>(), constraint);
DoFTools::make_hanging_node_constraints(dof_handler, constraint);
dof_handler.distribute_dofs(*fe);
// set up constraints
- IndexSet locally_relevant_dofs;
- DoFTools::extract_locally_relevant_dofs(dof_handler,
- locally_relevant_dofs);
- constraint.reinit(locally_relevant_dofs);
+ const IndexSet locally_relevant_dofs =
+ DoFTools::extract_locally_relevant_dofs(dof_handler);
+ constraint.reinit(dof_handler.locally_owned_dofs(),
+ locally_relevant_dofs);
VectorTools::interpolate_boundary_values(*_mapping,
dof_handler,
0,
// fine-level constraints
AffineConstraints<double> constraints;
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(dof.locally_owned_dofs(), locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
dirichlet_boundary,
AffineConstraints<double> level_constraints;
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_level_dofs(dof, level);
- level_constraints.reinit(relevant_dofs);
+ level_constraints.reinit(dof.locally_owned_mg_dofs(level), relevant_dofs);
level_constraints.add_lines(
mg_constrained_dofs.get_boundary_indices(level));
level_constraints.close();
{
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_dofs(dof_handler);
- constraints.reinit(relevant_dofs);
+ constraints.reinit(dof_handler.locally_owned_dofs(), relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
VectorTools::interpolate_boundary_values(dof_handler,
dirichlet_boundary,
}
else
{
+ const IndexSet &locally_owned =
+ dof_handler.locally_owned_mg_dofs(level);
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_level_dofs(dof_handler, level);
- constraints.reinit(relevant_dofs);
+ constraints.reinit(locally_owned, relevant_dofs);
constraints.add_lines(mg_constrained_dofs.get_boundary_indices(level));
const std::vector<types::global_dof_index> interface_indices =
edge_constrained_indices.clear();
edge_constrained_indices.reserve(interface_indices.size());
edge_constrained_values.resize(interface_indices.size());
- const IndexSet &locally_owned =
- dof_handler.locally_owned_mg_dofs(level);
for (unsigned int i = 0; i < interface_indices.size(); ++i)
if (locally_owned.is_element(interface_indices[i]))
edge_constrained_indices.push_back(
AffineConstraints<double> hanging_node_constraints;
const IndexSet locally_relevant_dofs =
DoFTools::extract_locally_relevant_dofs(dof);
- hanging_node_constraints.reinit(locally_relevant_dofs);
+ hanging_node_constraints.reinit(dof.locally_owned_dofs(),
+ locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof, hanging_node_constraints);
hanging_node_constraints.close();
// fine-level constraints
AffineConstraints<double> constraints;
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(dof.locally_owned_dofs(), locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
dirichlet_boundary,
{
// this is to make it consistent with parallel_multigrid_adaptive.cc
AffineConstraints<double> hanging_node_constraints;
- hanging_node_constraints.reinit(locally_relevant_dofs);
+ hanging_node_constraints.reinit(dof.locally_owned_dofs(),
+ locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof, hanging_node_constraints);
hanging_node_constraints.close();
AffineConstraints<double> level_constraints;
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_level_dofs(dof, level);
- level_constraints.reinit(relevant_dofs);
+ level_constraints.reinit(dof.locally_owned_mg_dofs(level), relevant_dofs);
level_constraints.add_lines(
mg_constrained_dofs.get_boundary_indices(level));
level_constraints.close();
{
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_dofs(dof_handler);
- constraints.reinit(relevant_dofs);
+ constraints.reinit(dof_handler.locally_owned_dofs(), relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
VectorTools::interpolate_boundary_values(dof_handler,
dirichlet_boundary,
}
else
{
+ const IndexSet &locally_owned =
+ dof_handler.locally_owned_mg_dofs(level);
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_level_dofs(dof_handler, level);
- constraints.reinit(relevant_dofs);
+ constraints.reinit(locally_owned, relevant_dofs);
constraints.add_lines(mg_constrained_dofs.get_boundary_indices(level));
const std::vector<types::global_dof_index> interface_indices =
edge_constrained_indices.clear();
edge_constrained_indices.reserve(interface_indices.size());
edge_constrained_values.resize(interface_indices.size());
- const IndexSet &locally_owned =
- dof_handler.locally_owned_mg_dofs(level);
for (unsigned int i = 0; i < interface_indices.size(); ++i)
if (locally_owned.is_element(interface_indices[i]))
edge_constrained_indices.push_back(
AffineConstraints<double> hanging_node_constraints;
const IndexSet locally_relevant_dofs =
DoFTools::extract_locally_relevant_dofs(dof);
- hanging_node_constraints.reinit(locally_relevant_dofs);
+ hanging_node_constraints.reinit(dof.locally_owned_dofs(),
+ locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof, hanging_node_constraints);
hanging_node_constraints.close();
// fine-level constraints
AffineConstraints<double> constraints;
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(dof.locally_owned_dofs(), locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
dirichlet_boundary,
{
// this is to make it consistent with parallel_multigrid_adaptive.cc
AffineConstraints<double> hanging_node_constraints;
- hanging_node_constraints.reinit(locally_relevant_dofs);
+ hanging_node_constraints.reinit(dof.locally_owned_dofs(),
+ locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof, hanging_node_constraints);
hanging_node_constraints.close();
AffineConstraints<double> level_constraints;
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_level_dofs(dof, level);
- level_constraints.reinit(relevant_dofs);
+ level_constraints.reinit(dof.locally_owned_mg_dofs(level), relevant_dofs);
level_constraints.add_lines(
mg_constrained_dofs.get_boundary_indices(level));
level_constraints.close();
{
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_dofs(dof_handler);
- constraints.reinit(relevant_dofs);
+ constraints.reinit(dof_handler.locally_owned_dofs(), relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
VectorTools::interpolate_boundary_values(dof_handler,
dirichlet_boundary,
}
else
{
+ const IndexSet &locally_owned =
+ dof_handler.locally_owned_mg_dofs(level);
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_level_dofs(dof_handler, level);
- constraints.reinit(relevant_dofs);
+ constraints.reinit(locally_owned, relevant_dofs);
constraints.add_lines(mg_constrained_dofs.get_boundary_indices(level));
const std::vector<types::global_dof_index> interface_indices =
edge_constrained_indices.clear();
edge_constrained_indices.reserve(interface_indices.size());
edge_constrained_values.resize(interface_indices.size());
- const IndexSet &locally_owned =
- dof_handler.locally_owned_mg_dofs(level);
for (unsigned int i = 0; i < interface_indices.size(); ++i)
if (locally_owned.is_element(interface_indices[i]))
edge_constrained_indices.push_back(
AffineConstraints<double> hanging_node_constraints;
const IndexSet locally_relevant_dofs =
DoFTools::extract_locally_relevant_dofs(dof);
- hanging_node_constraints.reinit(locally_relevant_dofs);
+ hanging_node_constraints.reinit(dof.locally_owned_dofs(),
+ locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof, hanging_node_constraints);
hanging_node_constraints.close();
// fine-level constraints
AffineConstraints<double> constraints;
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(dof.locally_owned_dofs(), locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
dirichlet_boundary,
{
// this is to make it consistent with parallel_multigrid_adaptive.cc
AffineConstraints<double> hanging_node_constraints;
- hanging_node_constraints.reinit(locally_relevant_dofs);
+ hanging_node_constraints.reinit(dof.locally_owned_dofs(),
+ locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof, hanging_node_constraints);
hanging_node_constraints.close();
AffineConstraints<double> level_constraints;
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_level_dofs(dof, level);
- level_constraints.reinit(relevant_dofs);
+ level_constraints.reinit(dof.locally_owned_mg_dofs(level), relevant_dofs);
level_constraints.add_lines(
mg_constrained_dofs.get_boundary_indices(level));
level_constraints.close();
// fine-level constraints
AffineConstraints<double> constraints;
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(dof.locally_owned_dofs(), locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
dirichlet_boundary,
{
// this is to make it consistent with parallel_multigrid_adaptive.cc
AffineConstraints<double> hanging_node_constraints;
- hanging_node_constraints.reinit(locally_relevant_dofs);
+ hanging_node_constraints.reinit(dof.locally_owned_dofs(),
+ locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof, hanging_node_constraints);
hanging_node_constraints.close();
AffineConstraints<double> level_constraints;
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_level_dofs(dof, level);
- level_constraints.reinit(relevant_dofs);
+ level_constraints.reinit(dof.locally_owned_mg_dofs(level), relevant_dofs);
level_constraints.add_lines(
mg_constrained_dofs.get_boundary_indices(level));
level_constraints.close();
std::vector<const AffineConstraints<double> *> constraints_ptrs(dof.size());
for (unsigned int i = 0; i < dof.size(); ++i)
{
- constraints[i].reinit(locally_relevant_dofs[i]);
+ constraints[i].reinit(dof[i]->locally_owned_dofs(),
+ locally_relevant_dofs[i]);
DoFTools::make_hanging_node_constraints(*dof[i], constraints[i]);
VectorTools::interpolate_boundary_values(*dof[i],
dirichlet_boundary,
// this is to make it consistent with parallel_multigrid_adaptive.cc
AffineConstraints<double> hanging_node_constraints;
- hanging_node_constraints.reinit(locally_relevant_dofs[b]);
+ hanging_node_constraints.reinit(dof[b]->locally_owned_dofs(),
+ locally_relevant_dofs[b]);
DoFTools::make_hanging_node_constraints(*dof[b],
hanging_node_constraints);
hanging_node_constraints.close();
{
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_level_dofs(*dof[i], level);
- level_constraints[i].reinit(relevant_dofs);
+ level_constraints[i].reinit(dof[i]->locally_owned_mg_dofs(level),
+ relevant_dofs);
level_constraints[i].add_lines(
mg_constrained_dofs[i].get_boundary_indices(level));
level_constraints[i].close();
// fine-level constraints
AffineConstraints<double> constraints;
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(dof.locally_owned_dofs(), locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof, constraints);
VectorTools::interpolate_boundary_values(dof,
dirichlet_boundary,
{
// this is to make it consistent with parallel_multigrid_adaptive.cc
AffineConstraints<double> hanging_node_constraints;
- hanging_node_constraints.reinit(locally_relevant_dofs);
+ hanging_node_constraints.reinit(dof.locally_owned_dofs(),
+ locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof, hanging_node_constraints);
hanging_node_constraints.close();
AffineConstraints<double> level_constraints;
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_level_dofs(dof, level);
- level_constraints.reinit(relevant_dofs);
+ level_constraints.reinit(dof.locally_owned_mg_dofs(level), relevant_dofs);
level_constraints.add_lines(
mg_constrained_dofs.get_boundary_indices(level));
level_constraints.close();
const IndexSet locally_relevant_dofs =
DoFTools::extract_locally_relevant_dofs(dof);
AffineConstraints<double> constraints;
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(dof.locally_owned_dofs(), locally_relevant_dofs);
VectorTools::interpolate_boundary_values(dof,
dirichlet_boundary,
constraints);
AffineConstraints<double> level_constraints;
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_level_dofs(dof, level);
- level_constraints.reinit(relevant_dofs);
+ level_constraints.reinit(dof.locally_owned_mg_dofs(level), relevant_dofs);
level_constraints.add_lines(
mg_constrained_dofs.get_boundary_indices(level));
level_constraints.close();
DoFTools::extract_locally_relevant_dofs(dof_handler);
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(dof_handler.locally_owned_dofs(), locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
VectorTools::interpolate_boundary_values(dof_handler,
0,
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_level_dofs(dof_handler, level);
AffineConstraints<double> level_constraints;
- level_constraints.reinit(relevant_dofs);
+ level_constraints.reinit(dof_handler.locally_owned_mg_dofs(level),
+ relevant_dofs);
level_constraints.add_lines(
mg_constrained_dofs.get_boundary_indices(level));
level_constraints.close();
const IndexSet locally_relevant_dofs_u =
DoFTools::extract_locally_relevant_dofs(dof_handler_u);
- constraints_u.reinit(locally_relevant_dofs_u);
+ constraints_u.reinit(dof_handler_u.locally_owned_dofs(),
+ locally_relevant_dofs_u);
DoFTools::make_hanging_node_constraints(dof_handler_u, constraints_u);
VectorTools::interpolate_boundary_values(
const IndexSet locally_relevant_dofs_p =
DoFTools::extract_locally_relevant_dofs(dof_handler_p);
- constraints_p.reinit(locally_relevant_dofs_p);
+ constraints_p.reinit(dof_handler_p.locally_owned_dofs(),
+ locally_relevant_dofs_p);
DoFTools::make_hanging_node_constraints(dof_handler_p, constraints_p);
constraints_p.close();
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_level_dofs(dof_handler_u, level);
AffineConstraints<double> level_constraints;
- level_constraints.reinit(relevant_dofs);
+ level_constraints.reinit(dof_handler_u.locally_owned_mg_dofs(level),
+ relevant_dofs);
level_constraints.add_lines(
mg_constrained_dofs.get_boundary_indices(level));
level_constraints.close();
AffineConstraints<double> constraints_u_no_dirchlet;
const IndexSet locally_relevant_dofs_u =
DoFTools::extract_locally_relevant_dofs(dof_handler_u);
- constraints_u_no_dirchlet.reinit(locally_relevant_dofs_u);
+ constraints_u_no_dirchlet.reinit(dof_handler_u.locally_owned_dofs(),
+ locally_relevant_dofs_u);
DoFTools::make_hanging_node_constraints(dof_handler_u,
constraints_u_no_dirchlet);
constraints_u_no_dirchlet.close();
const IndexSet relevant =
DoFTools::extract_locally_relevant_level_dofs(dofh, level);
- mg_boundary_constraints[level].reinit(relevant);
+ mg_boundary_constraints[level].reinit(dofh.locally_owned_mg_dofs(level),
+ relevant);
mg_boundary_constraints[level].add_lines(boundary_indices[level]);
mg_constrained_dofs_1.add_boundary_indices(dofh,
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_level_dofs(mgdof, level);
AffineConstraints<double> level_constraints;
- level_constraints.reinit(relevant_dofs);
+ level_constraints.reinit(mgdof.locally_owned_mg_dofs(level),
+ relevant_dofs);
typename DoFHandler<dim>::level_face_iterator face0 =
mgdof.begin(level)->face(0);
solution.reinit(mg_dof_handler.locally_owned_dofs(), MPI_COMM_WORLD);
system_rhs.reinit(mg_dof_handler.locally_owned_dofs(), MPI_COMM_WORLD);
- constraints.reinit(locally_relevant_set);
+ constraints.reinit(mg_dof_handler.locally_owned_dofs(),
+ locally_relevant_set);
DoFTools::make_hanging_node_constraints(mg_dof_handler, constraints);
std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
{
const IndexSet dofset =
DoFTools::extract_locally_relevant_level_dofs(mg_dof_handler, level);
- boundary_constraints[level].reinit(dofset);
+ boundary_constraints[level].reinit(
+ mg_dof_handler.locally_owned_mg_dofs(level), dofset);
boundary_constraints[level].add_lines(
mg_constrained_dofs.get_refinement_edge_indices(level));
boundary_constraints[level].add_lines(
const IndexSet locally_relevant_set =
DoFTools::extract_locally_relevant_dofs(mg_dof_handler);
- constraints.reinit(locally_relevant_set);
+ constraints.reinit(mg_dof_handler.locally_owned_dofs(), locally_relevant_set);
DoFTools::make_hanging_node_constraints(mg_dof_handler, constraints);
const std::set<types::boundary_id> dirichlet_boundary_ids = {0};
DoFTools::extract_locally_relevant_dofs(dof_handler);
AffineConstraints<double> constraints;
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(dof_handler.locally_owned_dofs(), locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
std::vector<
solution.reinit(mg_dof_handler.locally_owned_dofs(), MPI_COMM_WORLD);
system_rhs.reinit(mg_dof_handler.locally_owned_dofs(), MPI_COMM_WORLD);
- constraints.reinit(locally_relevant_set);
+ constraints.reinit(mg_dof_handler.locally_owned_dofs(),
+ locally_relevant_set);
DoFTools::make_hanging_node_constraints(mg_dof_handler, constraints);
std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
{
const IndexSet dofset =
DoFTools::extract_locally_relevant_level_dofs(mg_dof_handler, level);
- boundary_constraints[level].reinit(dofset);
+ boundary_constraints[level].reinit(
+ mg_dof_handler.locally_owned_mg_dofs(level), dofset);
boundary_constraints[level].add_lines(
mg_constrained_dofs.get_refinement_edge_indices(level));
boundary_constraints[level].add_lines(
solution.reinit(mg_dof_handler.locally_owned_dofs(), MPI_COMM_WORLD);
system_rhs.reinit(mg_dof_handler.locally_owned_dofs(), MPI_COMM_WORLD);
- constraints.reinit(locally_relevant_set);
+ constraints.reinit(mg_dof_handler.locally_owned_dofs(),
+ locally_relevant_set);
DoFTools::make_hanging_node_constraints(mg_dof_handler, constraints);
std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
{
const IndexSet dofset =
DoFTools::extract_locally_relevant_level_dofs(mg_dof_handler, level);
- boundary_constraints[level].reinit(dofset);
+ boundary_constraints[level].reinit(
+ mg_dof_handler.locally_owned_mg_dofs(level), dofset);
for (const types::global_dof_index dof_index :
mg_constrained_dofs.get_refinement_edge_indices(level))
solution.reinit(mg_dof_handler.locally_owned_dofs(), MPI_COMM_WORLD);
system_rhs.reinit(mg_dof_handler.locally_owned_dofs(), MPI_COMM_WORLD);
- constraints.reinit(locally_relevant_set);
+ constraints.reinit(mg_dof_handler.locally_owned_dofs(),
+ locally_relevant_set);
DoFTools::make_hanging_node_constraints(mg_dof_handler, constraints);
std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
{
const IndexSet dofset =
DoFTools::extract_locally_relevant_level_dofs(mg_dof_handler, level);
- boundary_constraints[level].reinit(dofset);
+ boundary_constraints[level].reinit(
+ mg_dof_handler.locally_owned_mg_dofs(level), dofset);
for (const types::global_dof_index dof_index :
mg_constrained_dofs.get_refinement_edge_indices(level))
solution.reinit(mg_dof_handler.locally_owned_dofs(), MPI_COMM_WORLD);
system_rhs.reinit(mg_dof_handler.locally_owned_dofs(), MPI_COMM_WORLD);
- constraints.reinit(locally_relevant_set);
+ constraints.reinit(mg_dof_handler.locally_owned_dofs(),
+ locally_relevant_set);
DoFTools::make_hanging_node_constraints(mg_dof_handler, constraints);
std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
{
const IndexSet dofset =
DoFTools::extract_locally_relevant_level_dofs(mg_dof_handler, level);
- boundary_constraints[level].reinit(dofset);
+ boundary_constraints[level].reinit(
+ mg_dof_handler.locally_owned_mg_dofs(level), dofset);
for (const types::global_dof_index dof_index :
mg_constrained_dofs.get_refinement_edge_indices(level))
boundary_constraints[level].constrain_dof_to_zero(dof_index);
solution.reinit(mg_dof_handler.locally_owned_dofs(), MPI_COMM_WORLD);
system_rhs.reinit(mg_dof_handler.locally_owned_dofs(), MPI_COMM_WORLD);
- constraints.reinit(locally_relevant_set);
+ constraints.reinit(mg_dof_handler.locally_owned_dofs(),
+ locally_relevant_set);
DoFTools::make_hanging_node_constraints(mg_dof_handler, constraints);
std::map<types::boundary_id, const Function<dim> *> dirichlet_boundary;
{
const IndexSet dofset =
DoFTools::extract_locally_relevant_level_dofs(mg_dof_handler, level);
- boundary_constraints[level].reinit(dofset);
+ boundary_constraints[level].reinit(
+ mg_dof_handler.locally_owned_mg_dofs(level), dofset);
boundary_constraints[level].add_lines(
mg_constrained_dofs.get_refinement_edge_indices(level));
boundary_constraints[level].add_lines(
solution.reinit(mg_dof_handler.locally_owned_dofs(), MPI_COMM_WORLD);
system_rhs.reinit(mg_dof_handler.locally_owned_dofs(), MPI_COMM_WORLD);
- constraints.reinit(locally_relevant_set);
+ constraints.reinit(mg_dof_handler.locally_owned_dofs(),
+ locally_relevant_set);
DoFTools::make_hanging_node_constraints(mg_dof_handler, constraints);
const std::set<types::boundary_id> dirichlet_boundary_ids = {0};
{
const IndexSet dofset =
DoFTools::extract_locally_relevant_level_dofs(mg_dof_handler, level);
- boundary_constraints[level].reinit(dofset);
+ boundary_constraints[level].reinit(
+ mg_dof_handler.locally_owned_mg_dofs(level), dofset);
boundary_constraints[level].add_lines(
mg_constrained_dofs.get_refinement_edge_indices(level));
boundary_constraints[level].add_lines(
AffineConstraints<double> hanging_node_constraints;
const IndexSet locally_relevant_set =
DoFTools::extract_locally_relevant_dofs(dofh);
- hanging_node_constraints.reinit(locally_relevant_set);
+ hanging_node_constraints.reinit(dofh.locally_owned_dofs(),
+ locally_relevant_set);
DoFTools::make_hanging_node_constraints(dofh, hanging_node_constraints);
hanging_node_constraints.close();
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_level_dofs(mgdof, 0);
AffineConstraints<double> user_constraints;
- user_constraints.reinit(relevant_dofs);
+ user_constraints.reinit(mgdof.locally_owned_mg_dofs(0), relevant_dofs);
typename DoFHandler<dim>::level_face_iterator face0 = mgdof.begin(0)->face(0);
std::vector<types::global_dof_index> face_dofs(fe.dofs_per_face);
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_level_dofs(mgdof, 0);
AffineConstraints<double> user_constraints;
- user_constraints.reinit(relevant_dofs);
+ user_constraints.reinit(mgdof.locally_owned_mg_dofs(0), relevant_dofs);
typename DoFHandler<dim>::level_face_iterator face0 = mgdof.begin(0)->face(0);
std::vector<types::global_dof_index> face_dofs(fe.dofs_per_face);
fluid_relevant_dofs[1] = locally_relevant_dofs.get_view(n_u, n_u + n_p);
{
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(fluid_dh.locally_owned_dofs(), locally_relevant_dofs);
const FEValuesExtractors::Vector velocities(0);
DoFTools::make_hanging_node_constraints(fluid_dh, constraints);
const IndexSet locally_relevant_dofs_u =
DoFTools::extract_locally_relevant_dofs(dof_handler_u);
- constraints_u.reinit(locally_relevant_dofs_u);
+ constraints_u.reinit(dof_handler_u.locally_owned_dofs(),
+ locally_relevant_dofs_u);
DoFTools::make_hanging_node_constraints(dof_handler_u, constraints_u);
// VectorTools::interpolate_boundary_values(
const IndexSet locally_relevant_dofs_p =
DoFTools::extract_locally_relevant_dofs(dof_handler_p);
- constraints_p.reinit(locally_relevant_dofs_p);
+ constraints_p.reinit(dof_handler_p.locally_owned_dofs(),
+ locally_relevant_dofs_p);
DoFTools::make_hanging_node_constraints(dof_handler_p, constraints_p);
constraints_p.close();
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_level_dofs(dof_handler_u, level);
AffineConstraints<double> level_constraints;
- level_constraints.reinit(relevant_dofs);
+ level_constraints.reinit(dof_handler_u.locally_owned_mg_dofs(level),
+ relevant_dofs);
// level_constraints.add_lines(
// mg_constrained_dofs.get_boundary_indices(level));
AffineConstraints<double> constraints_u_no_dirchlet;
const IndexSet locally_relevant_dofs_u =
DoFTools::extract_locally_relevant_dofs(dof_handler_u);
- constraints_u_no_dirchlet.reinit(locally_relevant_dofs_u);
+ constraints_u_no_dirchlet.reinit(dof_handler_u.locally_owned_dofs(),
+ locally_relevant_dofs_u);
DoFTools::make_hanging_node_constraints(dof_handler_u,
constraints_u_no_dirchlet);
constraints_u_no_dirchlet.close();
{
nonzero_constraints.clear();
- nonzero_constraints.reinit(locally_relevant_dofs);
+ nonzero_constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler,
nonzero_constraints);
{
zero_constraints.clear();
- zero_constraints.reinit(locally_relevant_dofs);
+ zero_constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler,
zero_constraints);
VectorTools::interpolate_boundary_values(
DoFTools::extract_locally_relevant_dofs(dof_handler);
AffineConstraints<double> constraints;
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
constraints.close();
DoFTools::extract_locally_relevant_dofs(dof_handler);
AffineConstraints<double> constraints;
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(dof_handler.locally_owned_dofs(), locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
constraints.close();
locally_relevant_dofs[i] =
DoFTools::extract_locally_relevant_dofs(*dof_handlers[i]);
- constraints[i].reinit(locally_relevant_dofs[i]);
+ constraints[i].reinit(dof_handlers[i]->locally_owned_dofs(),
+ locally_relevant_dofs[i]);
DoFTools::make_hanging_node_constraints(*dof_handlers[i], constraints[i]);
constraints[i].close();
IndexSet relevant_dofs = DoFTools::extract_locally_relevant_dofs(dof_h);
AffineConstraints<float> &constraints = level_constraints[level];
- constraints.reinit(relevant_dofs);
+ constraints.reinit(dof_h.locally_owned_dofs(), relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_h, constraints);
constraints.close();
typename MatrixFree<dim, float>::AdditionalData additional_data;
// now create the final constraints object
relevant_dofs = DoFTools::extract_locally_relevant_dofs(dof_h);
constraints.clear();
- constraints.reinit(relevant_dofs);
+ constraints.reinit(dof_h.locally_owned_dofs(), relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_h, constraints);
constraints.close();
}
DoFTools::extract_locally_relevant_dofs(dof_handler);
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(dof_handler.locally_owned_dofs(), locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
VectorTools::interpolate_boundary_values(
mapping, dof_handler, 0, Functions::ZeroFunction<dim>(), constraints);
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_level_dofs(dof_handler, level);
AffineConstraints<double> level_constraints;
- level_constraints.reinit(relevant_dofs);
+ level_constraints.reinit(dof_handler.locally_owned_dofs(), relevant_dofs);
level_constraints.add_lines(
mg_constrained_dofs.get_boundary_indices(level));
level_constraints.close();
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_level_dofs(dof_handler, level);
AffineConstraints<double> level_constraints;
- level_constraints.reinit(relevant_dofs);
+ level_constraints.reinit(dof_handler.locally_owned_dofs(), relevant_dofs);
level_constraints.add_lines(
mg_constrained_dofs.get_boundary_indices(level));
level_constraints.close();
DoFTools::extract_locally_relevant_dofs(dof_handler);
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(dof_handler.locally_owned_dofs(), locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
VectorTools::interpolate_boundary_values(
mapping, dof_handler, 0, Functions::ZeroFunction<dim>(), constraints);
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_level_dofs(dof_handler, level);
AffineConstraints<double> level_constraints;
- level_constraints.reinit(relevant_dofs);
+ level_constraints.reinit(dof_handler.locally_owned_dofs(), relevant_dofs);
level_constraints.add_lines(
mg_constrained_dofs.get_boundary_indices(level));
level_constraints.close();
const IndexSet relevant_dofs =
DoFTools::extract_locally_relevant_level_dofs(dof_handler, level);
AffineConstraints<double> level_constraints;
- level_constraints.reinit(relevant_dofs);
+ level_constraints.reinit(dof_handler.locally_owned_dofs(), relevant_dofs);
level_constraints.add_lines(
mg_constrained_dofs.get_boundary_indices(level));
level_constraints.close();
// Specifically, we need two types of AffineConstraints.
// One to handle homogeneous boundary conditions for the update step.
zero_constraints.clear();
- zero_constraints.reinit(locally_relevant_dofs);
+ zero_constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, zero_constraints);
VectorTools::interpolate_boundary_values(dof_handler,
0,
// And another one to handle non-homogeneous boundary conditions
// when computing the residual function.
bc_constraints.clear();
- bc_constraints.reinit(locally_relevant_dofs);
+ bc_constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, bc_constraints);
VectorTools::interpolate_boundary_values(dof_handler,
0,
const types::global_dof_index n_local_dofs = locally_owned_dofs.n_elements();
AffineConstraints<double> constraints;
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
constraints.close();
// set vector:
vector.reinit(locally_owned_dofs, mpi_communicator);
AffineConstraints<PetscScalar> constraints;
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
constraints.close();
AffineConstraints<double> constraints;
- constraints.reinit(DoFTools::extract_locally_relevant_dofs(dof_handler));
+ constraints.reinit(dof_handler.locally_owned_dofs(),
+ DoFTools::extract_locally_relevant_dofs(dof_handler));
for (unsigned int d = 0; d < dim; ++d)
DoFTools::make_periodicity_constraints(
dof_handler, 2 * d, 2 * d + 1, d, constraints);
system_rhs.reinit(locally_owned_dofs, mpi_communicator);
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
VectorTools::interpolate_boundary_values(
mapping, dof_handler, 0, Functions::ZeroFunction<dim>(), constraints);
// to put this function call in, in case adaptive refinement gets
// introduced later.
{
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(dof_handler.locally_owned_dofs(),
+ locally_relevant_dofs);
const FEValuesExtractors::Vector velocities(0);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
dealii::DoFTools::extract_locally_relevant_dofs(dof_handler);
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
dealii::DoFTools::make_hanging_node_constraints(dof_handler, constraints);
dealii::VectorTools::interpolate_boundary_values(
dof_handler, 0, dealii::Functions::ZeroFunction<dim>(), constraints);
dealii::DoFTools::extract_locally_relevant_dofs(dof_handler);
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
dealii::DoFTools::make_hanging_node_constraints(dof_handler, constraints);
dealii::VectorTools::interpolate_boundary_values(
dof_handler, 0, dealii::Functions::ZeroFunction<dim>(), constraints);
dealii::DoFTools::extract_locally_relevant_dofs(dof_handler);
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
dealii::DoFTools::make_hanging_node_constraints(dof_handler, constraints);
dealii::VectorTools::interpolate_boundary_values(
dof_handler, 0, dealii::Functions::ZeroFunction<dim>(), constraints);
system_rhs.reinit(locally_owned_dofs, mpi_comm);
constraints.clear();
- constraints.reinit(locally_relevant_dofs);
+ constraints.reinit(locally_owned_dofs, locally_relevant_dofs);
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
VectorTools::interpolate_boundary_values(dof_handler,
0,