From 3527f4908e297809d610bb0aef9e05541e3fabab Mon Sep 17 00:00:00 2001 From: Jean-Paul Pelteret Date: Tue, 7 Jul 2020 07:59:16 +0200 Subject: [PATCH] Use neutral terminology where possible --- doc/doxygen/headers/glossary.h | 4 +- doc/users/gdb.html | 2 +- examples/step-17/step-17.cc | 2 +- examples/step-18/step-18.cc | 7 +- examples/step-42/step-42.cc | 4 +- examples/step-50/step-50.cc | 4 +- examples/step-60/step-60.cc | 4 +- examples/step-67/step-67.cc | 4 +- include/deal.II/base/data_out_base.h | 31 +- include/deal.II/base/logstream.h | 4 +- source/base/data_out_base.cc | 8 +- source/base/logstream.cc | 4 +- source/distributed/grid_refinement.cc | 24 +- source/dofs/dof_handler_policy.cc | 203 +++++----- source/dofs/dof_tools_constraints.cc | 363 +++++++++--------- source/fe/fe_q_hierarchical.cc | 6 +- source/grid/grid_out.cc | 6 +- source/lac/ginkgo_solver.cc | 10 +- tests/data_out/data_out_13.cc | 4 +- tests/data_out/data_out_base_pvd.cc | 2 +- tests/data_out/data_out_base_pvtu.cc | 2 +- tests/distributed_grids/2d_refinement_10.cc | 4 +- tests/distributed_grids/3d_refinement_12.cc | 4 +- ...t_dofs_with_support_contained_within_02.cc | 6 +- ...t_dofs_with_support_contained_within_04.cc | 6 +- tests/fe/nedelec_crash_hp.cc | 2 +- .../copy_serial_tria_grouped_01.cc | 2 +- tests/hp/crash_12.cc | 2 +- tests/mpi/interpolate_to_different_mesh_01.cc | 6 +- tests/mpi/muelu_periodicity.cc | 6 +- tests/mpi/parallel_vtu_01.cc | 4 +- tests/mpi/periodicity_01.cc | 4 +- tests/mpi/periodicity_02.cc | 6 +- tests/mpi/periodicity_03.cc | 6 +- tests/mpi/step-37.cc | 6 +- tests/physics/step-18-rotation_matrix.cc | 15 +- tests/physics/step-18.cc | 15 +- tests/trilinos/solver_control_06.cc | 4 +- 38 files changed, 407 insertions(+), 389 deletions(-) diff --git a/doc/doxygen/headers/glossary.h b/doc/doxygen/headers/glossary.h index f3578cd524..49fc2dbf58 100644 --- a/doc/doxygen/headers/glossary.h +++ b/doc/doxygen/headers/glossary.h @@ -1128,7 +1128,7 @@ * that are owned by other processors. In other words, for each element * there is a clear owner among all of the processors and those elements * that the current processor stores but does not own (i.e., the - * "ghost elements") are simply mirror images of a master value somewhere + * "ghost elements") are simply mirror images of a primary value somewhere * else -- thus, the name "ghost". This is also the case for the * parallel::distributed::Vector class. * @@ -1144,7 +1144,7 @@ * the name "ghost element" may be misleading since in this view, * every element we have available locally may or may not be stored * somewhere else as well, but even if it is, the local element is not - * a mirror value of a master location as there is no owner of each + * a mirror value of a primary location as there is no owner of each * element. * * @note The @ref distributed documentation module provides a brief diff --git a/doc/users/gdb.html b/doc/users/gdb.html index 6315b13ff7..00f07893a2 100644 --- a/doc/users/gdb.html +++ b/doc/users/gdb.html @@ -59,7 +59,7 @@ cp contrib/utilities/dotgdbinit.py ~/.gdbinit word end) of the file contrib/utilities/dotgdbinit.py into the directory from the first step. Rename this file to deal.py so that we can - import it into the master GDB file in the next step. + import it into the principal GDB configuration file in the next step.
  • Add the following to your .gdbinit file, which also resides in your home directory:
    diff --git a/examples/step-17/step-17.cc b/examples/step-17/step-17.cc
    index e7f63bdb47..21a830ead9 100644
    --- a/examples/step-17/step-17.cc
    +++ b/examples/step-17/step-17.cc
    @@ -1001,7 +1001,7 @@ namespace Step17
     
     // The main() works the same way as most of the main
     // functions in the other example programs, i.e., it delegates work to
    -// the run function of a master object, and only wraps
    +// the run function of a managing object, and only wraps
     // everything into some code to catch exceptions:
     int main(int argc, char **argv)
     {
    diff --git a/examples/step-18/step-18.cc b/examples/step-18/step-18.cc
    index 21909d6d50..d167104419 100644
    --- a/examples/step-18/step-18.cc
    +++ b/examples/step-18/step-18.cc
    @@ -1257,9 +1257,8 @@ namespace Step18
         // The function also writes a record files (with suffix `.pvd`) for Paraview
         // that describes how all of these output files combine into the data for
         // this single time step:
    -    const std::string pvtu_master_filename =
    -      data_out.write_vtu_with_pvtu_record(
    -        "./", "solution", timestep_no, mpi_communicator, 4);
    +    const std::string pvtu_filename = data_out.write_vtu_with_pvtu_record(
    +      "./", "solution", timestep_no, mpi_communicator, 4);
     
         // The record files must be written only once and not by each processor,
         // so we do this on processor 0:
    @@ -1271,7 +1270,7 @@ namespace Step18
             // from the previous timesteps.
             static std::vector> times_and_names;
             times_and_names.push_back(
    -          std::pair(present_time, pvtu_master_filename));
    +          std::pair(present_time, pvtu_filename));
             std::ofstream pvd_output("solution.pvd");
             DataOutBase::write_pvd_record(pvd_output, times_and_names);
           }
    diff --git a/examples/step-42/step-42.cc b/examples/step-42/step-42.cc
    index 87ecfe7284..de08c54a6b 100644
    --- a/examples/step-42/step-42.cc
    +++ b/examples/step-42/step-42.cc
    @@ -2035,9 +2035,9 @@ namespace Step42
         // output files. We then do the same again for the competitor of
         // Paraview, the VisIt visualization program, by creating a matching
         // .visit file.
    -    const std::string master_name = data_out.write_vtu_with_pvtu_record(
    +    const std::string pvtu_filename = data_out.write_vtu_with_pvtu_record(
           output_dir, "solution", current_refinement_cycle, mpi_communicator, 2);
    -    pcout << master_name << std::endl;
    +    pcout << pvtu_filename << std::endl;
     
         TrilinosWrappers::MPI::Vector tmp(solution);
         tmp *= -1;
    diff --git a/examples/step-50/step-50.cc b/examples/step-50/step-50.cc
    index c42006da71..b09a823792 100644
    --- a/examples/step-50/step-50.cc
    +++ b/examples/step-50/step-50.cc
    @@ -1451,10 +1451,10 @@ void LaplaceProblem::output_results(const unsigned int cycle)
     
       data_out.build_patches();
     
    -  const std::string master = data_out.write_vtu_with_pvtu_record(
    +  const std::string pvtu_filename = data_out.write_vtu_with_pvtu_record(
         "", "solution", cycle, mpi_communicator, 2 /*n_digits*/, 1 /*n_groups*/);
     
    -  pcout << "   Wrote " << master << std::endl;
    +  pcout << "   Wrote " << pvtu_filename << std::endl;
     }
     
     
    diff --git a/examples/step-60/step-60.cc b/examples/step-60/step-60.cc
    index 8f02eb8df1..e93e0314fc 100644
    --- a/examples/step-60/step-60.cc
    +++ b/examples/step-60/step-60.cc
    @@ -70,8 +70,8 @@
     // class. The structure of deal.II, as many modern numerical libraries, is
     // organized following a Directed Acyclic Graph (DAG). A DAG is a directed graph
     // with topological ordering: each node structurally represents an object, and
    -// is connected to child nodes by one (or more) oriented edges, from the parent
    -// to the child. The most significant example of this structure is the
    +// is connected to non-root nodes by one (or more) oriented edges, from the
    +// parent to the child. The most significant example of this structure is the
     // Triangulation and its Triangulation::cell_iterator structure. From a
     // Triangulation (the main node), we can access each cell (children nodes of the
     // triangulation). From the cells themselves we can access over all vertices of
    diff --git a/examples/step-67/step-67.cc b/examples/step-67/step-67.cc
    index fa8ecf7006..39653594d5 100644
    --- a/examples/step-67/step-67.cc
    +++ b/examples/step-67/step-67.cc
    @@ -2092,8 +2092,8 @@ namespace Euler_DG
       // than the standard library's `std::ofstream` variants used in most other
       // tutorial programs. A particularly nice feature of the
       // `write_vtu_in_parallel()` function is the fact that it can combine output
    -  // from all MPI ranks into a single file, obviating a VTU master file (the
    -  // "pvtu" file).
    +  // from all MPI ranks into a single file, making it unnecessary to have a
    +  // central record of all such files (namely, the "pvtu" file).
       //
       // For parallel programs, it is often instructive to look at the partitioning
       // of cells among processors. To this end, one can pass a vector of numbers
    diff --git a/include/deal.II/base/data_out_base.h b/include/deal.II/base/data_out_base.h
    index d9a4c157d3..a2f704fdb1 100644
    --- a/include/deal.II/base/data_out_base.h
    +++ b/include/deal.II/base/data_out_base.h
    @@ -1950,11 +1950,11 @@ namespace DataOutBase
        * Some visualization programs, such as ParaView, can read several separate
        * VTU files to parallelize visualization. In that case, you need a
        * .pvtu file that describes which VTU files form a group. The
    -   * DataOutInterface::write_pvtu_record() function can generate such a master
    -   * record. Likewise, DataOutInterface::write_visit_record() does the same
    -   * for VisIt (although VisIt can also read pvtu records since
    -   * version 2.5.1). Finally, for time dependent problems, you may also want
    -   * to look at DataOutInterface::write_pvd_record()
    +   * DataOutInterface::write_pvtu_record() function can generate such a
    +   * centralized record. Likewise, DataOutInterface::write_visit_record() does
    +   * the same for VisIt (although VisIt can also read pvtu records
    +   * since version 2.5.1). Finally, for time dependent problems, you may also
    +   * want to look at DataOutInterface::write_pvd_record()
        *
        * The use of this function is explained in step-40.
        */
    @@ -2015,7 +2015,7 @@ namespace DataOutBase
        * parallelize visualization. In that case, you need a
        * .pvtu file that describes which VTU files (written, for
        * example, through the DataOutInterface::write_vtu() function) form a group.
    -   * The current function can generate such a master record.
    +   * The current function can generate such a centralized record.
        *
        * This function is typically not called by itself from user space, but
        * you may want to call it through DataOutInterface::write_pvtu_record()
    @@ -2023,7 +2023,7 @@ namespace DataOutBase
        * would have to provide to the current function by hand.
        *
        * In any case, whether this function is called directly or via
    -   * DataOutInterface::write_pvtu_record(), the master record file so
    +   * DataOutInterface::write_pvtu_record(), the central record file so
        * written contains a list of (scalar or vector) fields that describes which
        * fields can actually be found in the individual files that comprise the set
        * of parallel VTU files along with the names of these files. This function
    @@ -2147,7 +2147,7 @@ namespace DataOutBase
        * piece_names[2].emplace_back("subdomain_01.time_step_2.vtk");
        * piece_names[2].emplace_back("subdomain_02.time_step_2.vtk");
        *
    -   * std::ofstream visit_output ("master_file.visit");
    +   * std::ofstream visit_output ("solution.visit");
        *
        * DataOutBase::write_visit_record(visit_output, piece_names);
        * @endcode
    @@ -2183,7 +2183,7 @@ namespace DataOutBase
        * times_and_piece_names[2].second.emplace_back("subdomain_01.time_step_2.vtk");
        * times_and_piece_names[2].second.emplace_back("subdomain_02.time_step_2.vtk");
        *
    -   * std::ofstream visit_output ("master_file.visit");
    +   * std::ofstream visit_output ("solution.visit");
        *
        * DataOutBase::write_visit_record(visit_output, times_and_piece_names);
        * @endcode
    @@ -2621,9 +2621,9 @@ public:
        * Some visualization programs, such as ParaView, can read several separate
        * VTU files to parallelize visualization. In that case, you need a
        * .pvtu file that describes which VTU files form a group. The
    -   * DataOutInterface::write_pvtu_record() function can generate such a master
    -   * record. Likewise, DataOutInterface::write_visit_record() does the same
    -   * for older versions of VisIt (although VisIt can also read
    +   * DataOutInterface::write_pvtu_record() function can generate such a
    +   * centralized record. Likewise, DataOutInterface::write_visit_record() does
    +   * the same for older versions of VisIt (although VisIt can also read
        * pvtu records since version 2.5.1). Finally,
        * DataOutInterface::write_pvd_record() can be used to group together the
        * files that jointly make up a time dependent simulation.
    @@ -2648,9 +2648,9 @@ public:
        * parallelize visualization. In that case, you need a
        * .pvtu file that describes which VTU files (written, for
        * example, through the DataOutInterface::write_vtu() function) form a group.
    -   * The current function can generate such a master record.
    +   * The current function can generate such a centralized record.
        *
    -   * The master record file generated by this function
    +   * The central record file generated by this function
        * contains a list of (scalar or vector) fields that describes which
        * fields can actually be found in the individual files that comprise the set
        * of parallel VTU files along with the names of these files. This function
    @@ -2726,7 +2726,8 @@ public:
        * generate the .pvtu file, where processor zero is chosen to take over this
        * job.
        *
    -   * The return value is the filename of the master file for the pvtu record.
    +   * The return value is the filename of the centralized file for the pvtu
    +   * record.
        *
        * @note The code simply combines the strings @p directory and
        * @p filename_without_extension, i.e., the user has to make sure that
    diff --git a/include/deal.II/base/logstream.h b/include/deal.II/base/logstream.h
    index 1d0eb6665f..90d7cb0760 100644
    --- a/include/deal.II/base/logstream.h
    +++ b/include/deal.II/base/logstream.h
    @@ -322,10 +322,10 @@ private:
     
       /**
        * We record the thread id of the thread creating this object. We need
    -   * this information to "steal" the current prefix from this "master"
    +   * this information to "steal" the current prefix from this "parent"
        * thread on first use of deallog on a new thread.
        */
    -  std::thread::id master_thread;
    +  std::thread::id parent_thread;
     
       /**
        * Default stream, where the output is to go to. This stream defaults to
    diff --git a/source/base/data_out_base.cc b/source/base/data_out_base.cc
    index 731f45c7d7..8c52f6145e 100644
    --- a/source/base/data_out_base.cc
    +++ b/source/base/data_out_base.cc
    @@ -7044,7 +7044,7 @@ DataOutInterface::write_vtu_with_pvtu_record(
         }
     
       // write pvtu record
    -  const std::string filename_master =
    +  const std::string pvtu_filename =
         filename_without_extension + "_" +
         Utilities::int_to_string(counter, n_digits_for_counter) + ".pvtu";
     
    @@ -7061,11 +7061,11 @@ DataOutInterface::write_vtu_with_pvtu_record(
               filename_vector.emplace_back(filename);
             }
     
    -      std::ofstream master_output((directory + filename_master).c_str());
    -      this->write_pvtu_record(master_output, filename_vector);
    +      std::ofstream pvtu_output((directory + pvtu_filename).c_str());
    +      this->write_pvtu_record(pvtu_output, filename_vector);
         }
     
    -  return filename_master;
    +  return pvtu_filename;
     }
     
     
    diff --git a/source/base/logstream.cc b/source/base/logstream.cc
    index 12a9786c59..29c72e5edb 100644
    --- a/source/base/logstream.cc
    +++ b/source/base/logstream.cc
    @@ -73,7 +73,7 @@ LogStream::Prefix::~Prefix()
     
     
     LogStream::LogStream()
    -  : master_thread(std::this_thread::get_id())
    +  : parent_thread(std::this_thread::get_id())
       , std_out(&std::cout)
       , file(nullptr)
       , std_depth(0)
    @@ -389,7 +389,7 @@ LogStream::get_prefixes() const
       // from the initial thread that created logstream.
       if (!exists)
         {
    -      auto it = prefixes.data.find(master_thread);
    +      auto it = prefixes.data.find(parent_thread);
           if (it != prefixes.data.end())
             local_prefixes = it->second;
         }
    diff --git a/source/distributed/grid_refinement.cc b/source/distributed/grid_refinement.cc
    index 2332c92d9d..9c438ee9fd 100644
    --- a/source/distributed/grid_refinement.cc
    +++ b/source/distributed/grid_refinement.cc
    @@ -241,15 +241,15 @@ namespace internal
                                                global_min_and_max.second};
                 adjust_interesting_range(interesting_range);
     
    -            const unsigned int master_mpi_rank = 0;
    -            unsigned int       iteration       = 0;
    +            const unsigned int root_mpi_rank = 0;
    +            unsigned int       iteration     = 0;
     
                 do
                   {
                     int ierr = MPI_Bcast(interesting_range,
                                          2,
                                          MPI_DOUBLE,
    -                                     master_mpi_rank,
    +                                     root_mpi_rank,
                                          mpi_communicator);
                     AssertThrowMPI(ierr);
     
    @@ -277,10 +277,10 @@ namespace internal
                     // now adjust the range. if we have too many cells, we take the
                     // upper half of the previous range, otherwise the lower half.
                     // if we have hit the right number, then set the range to the
    -                // exact value. slave nodes also update their own
    +                // exact value. non-root nodes also update their own
                     // interesting_range, however their results are not significant
                     // since the values will be overwritten by MPI_Bcast from the
    -                // master node in next loop.
    +                // root node in next loop.
                     if (total_count > n_target_cells)
                       interesting_range[0] = test_threshold;
                     else if (total_count < n_target_cells)
    @@ -324,15 +324,15 @@ namespace internal
                                                global_min_and_max.second};
                 adjust_interesting_range(interesting_range);
     
    -            const unsigned int master_mpi_rank = 0;
    -            unsigned int       iteration       = 0;
    +            const unsigned int root_mpi_rank = 0;
    +            unsigned int       iteration     = 0;
     
                 do
                   {
                     int ierr = MPI_Bcast(interesting_range,
                                          2,
                                          MPI_DOUBLE,
    -                                     master_mpi_rank,
    +                                     root_mpi_rank,
                                          mpi_communicator);
                     AssertThrowMPI(ierr);
     
    @@ -350,7 +350,7 @@ namespace internal
                         ierr = MPI_Bcast(&final_threshold,
                                          1,
                                          MPI_DOUBLE,
    -                                     master_mpi_rank,
    +                                     root_mpi_rank,
                                          mpi_communicator);
                         AssertThrowMPI(ierr);
     
    @@ -376,17 +376,17 @@ namespace internal
                                       1,
                                       MPI_DOUBLE,
                                       MPI_SUM,
    -                                  master_mpi_rank,
    +                                  root_mpi_rank,
                                       mpi_communicator);
                     AssertThrowMPI(ierr);
     
                     // now adjust the range. if we have too many cells, we take the
                     // upper half of the previous range, otherwise the lower half.
                     // if we have hit the right number, then set the range to the
    -                // exact value. slave nodes also update their own
    +                // exact value. non-root nodes also update their own
                     // interesting_range, however their results are not significant
                     // since the values will be overwritten by MPI_Bcast from the
    -                // master node in next loop.
    +                // root node in next loop.
                     if (total_error > target_error)
                       interesting_range[0] = test_threshold;
                     else if (total_error < target_error)
    diff --git a/source/dofs/dof_handler_policy.cc b/source/dofs/dof_handler_policy.cc
    index a1c2a6c279..0df5e7a642 100644
    --- a/source/dofs/dof_handler_policy.cc
    +++ b/source/dofs/dof_handler_policy.cc
    @@ -297,7 +297,7 @@ namespace internal
                                                       [other_fe_index];
                               for (const auto &identity : identities)
                                 {
    -                              const types::global_dof_index master_dof_index =
    +                              const types::global_dof_index primary_dof_index =
                                     dealii::internal::DoFAccessorImplementation::
                                       Implementation::get_dof_index(
                                         dof_handler,
    @@ -306,15 +306,16 @@ namespace internal
                                         most_dominating_fe_index,
                                         identity.first,
                                         std::integral_constant());
    -                              const types::global_dof_index slave_dof_index =
    -                                dealii::internal::DoFAccessorImplementation::
    -                                  Implementation::get_dof_index(
    -                                    dof_handler,
    -                                    0,
    -                                    vertex_index,
    -                                    other_fe_index,
    -                                    identity.second,
    -                                    std::integral_constant());
    +                              const types::global_dof_index
    +                                dependent_dof_index =
    +                                  dealii::internal::DoFAccessorImplementation::
    +                                    Implementation::get_dof_index(
    +                                      dof_handler,
    +                                      0,
    +                                      vertex_index,
    +                                      other_fe_index,
    +                                      identity.second,
    +                                      std::integral_constant());
     
                                   // on subdomain boundaries, we will
                                   // encounter invalid DoFs on ghost cells,
    @@ -329,7 +330,8 @@ namespace internal
                                   // to overwrite a valid DoF. we will skip
                                   // constraining invalid DoFs for now, and
                                   // consider them later in Phase 5.
    -                              if (slave_dof_index != numbers::invalid_dof_index)
    +                              if (dependent_dof_index !=
    +                                  numbers::invalid_dof_index)
                                     {
                                       // if the DoF indices of both elements
                                       // are already distributed, i.e., both
    @@ -338,17 +340,17 @@ namespace internal
                                       // should either not have a dof_identity
                                       // yet, or it must come out here to be
                                       // exactly as we had computed before
    -                                  if (master_dof_index !=
    +                                  if (primary_dof_index !=
                                           numbers::invalid_dof_index)
    -                                    Assert((dof_identities.find(
    -                                              master_dof_index) ==
    -                                            dof_identities.end()) ||
    -                                             (dof_identities[slave_dof_index] ==
    -                                              master_dof_index),
    -                                           ExcInternalError());
    -
    -                                  dof_identities[slave_dof_index] =
    -                                    master_dof_index;
    +                                    Assert(
    +                                      (dof_identities.find(primary_dof_index) ==
    +                                       dof_identities.end()) ||
    +                                        (dof_identities[dependent_dof_index] ==
    +                                         primary_dof_index),
    +                                      ExcInternalError());
    +
    +                                  dof_identities[dependent_dof_index] =
    +                                    primary_dof_index;
                                     }
                                 }
                             }
    @@ -527,10 +529,10 @@ namespace internal
                                              ++j)
                                           {
                                             const types::global_dof_index
    -                                          master_dof_index = line->dof_index(
    +                                          primary_dof_index = line->dof_index(
                                                 j, dominating_fe_index);
                                             const types::global_dof_index
    -                                          slave_dof_index =
    +                                          dependent_dof_index =
                                                 line->dof_index(j, other_fe_index);
     
                                             // on subdomain boundaries, we will
    @@ -547,18 +549,18 @@ namespace internal
                                             // will skip constraining invalid DoFs
                                             // for now, and consider them later in
                                             // Phase 5.
    -                                        if (slave_dof_index !=
    +                                        if (dependent_dof_index !=
                                                 numbers::invalid_dof_index)
                                               {
    -                                            if (master_dof_index !=
    +                                            if (primary_dof_index !=
                                                     numbers::invalid_dof_index)
                                                   {
    -                                                // if master dof was already
    +                                                // if primary dof was already
                                                     // constrained, constrain to
                                                     // that one, otherwise constrain
    -                                                // slave to master
    +                                                // dependent to primary
                                                     if (dof_identities.find(
    -                                                      master_dof_index) !=
    +                                                      primary_dof_index) !=
                                                         dof_identities.end())
                                                       {
                                                         // if the DoF indices of
    @@ -575,14 +577,14 @@ namespace internal
                                                         Assert(
                                                           dof_identities.find(
                                                             dof_identities
    -                                                          [master_dof_index]) ==
    +                                                          [primary_dof_index]) ==
                                                             dof_identities.end(),
                                                           ExcInternalError());
     
                                                         dof_identities
    -                                                      [slave_dof_index] =
    +                                                      [dependent_dof_index] =
                                                             dof_identities
    -                                                          [master_dof_index];
    +                                                          [primary_dof_index];
                                                       }
                                                     else
                                                       {
    @@ -591,25 +593,25 @@ namespace internal
                                                         // assertion
                                                         Assert(
                                                           (dof_identities.find(
    -                                                         master_dof_index) ==
    +                                                         primary_dof_index) ==
                                                            dof_identities.end()) ||
                                                             (dof_identities
    -                                                           [slave_dof_index] ==
    -                                                         master_dof_index),
    +                                                           [dependent_dof_index] ==
    +                                                         primary_dof_index),
                                                           ExcInternalError());
     
                                                         dof_identities
    -                                                      [slave_dof_index] =
    -                                                        master_dof_index;
    +                                                      [dependent_dof_index] =
    +                                                        primary_dof_index;
                                                       }
                                                   }
                                                 else
                                                   {
    -                                                // set slave_dof to
    -                                                // master_dof_index, which is
    +                                                // set dependent_dof to
    +                                                // primary_dof_index, which is
                                                     // invalid
                                                     dof_identities
    -                                                  [slave_dof_index] =
    +                                                  [dependent_dof_index] =
                                                         numbers::invalid_dof_index;
                                                   }
                                               }
    @@ -667,11 +669,11 @@ namespace internal
                                     for (const auto &identity : identities)
                                       {
                                         const types::global_dof_index
    -                                      master_dof_index = line->dof_index(
    +                                      primary_dof_index = line->dof_index(
                                             identity.first,
                                             most_dominating_fe_index);
                                         const types::global_dof_index
    -                                      slave_dof_index =
    +                                      dependent_dof_index =
                                             line->dof_index(identity.second,
                                                             other_fe_index);
     
    @@ -688,7 +690,7 @@ namespace internal
                                         // to overwrite a valid DoF. we will skip
                                         // constraining invalid DoFs for now, and
                                         // consider them later in Phase 5.
    -                                    if (slave_dof_index !=
    +                                    if (dependent_dof_index !=
                                             numbers::invalid_dof_index)
                                           {
                                             // if the DoF indices of both elements
    @@ -698,18 +700,18 @@ namespace internal
                                             // should either not have a dof_identity
                                             // yet, or it must come out here to be
                                             // exactly as we had computed before
    -                                        if (master_dof_index !=
    +                                        if (primary_dof_index !=
                                                 numbers::invalid_dof_index)
                                               Assert((dof_identities.find(
    -                                                    master_dof_index) ==
    +                                                    primary_dof_index) ==
                                                       dof_identities.end()) ||
                                                        (dof_identities
    -                                                      [slave_dof_index] ==
    -                                                    master_dof_index),
    +                                                      [dependent_dof_index] ==
    +                                                    primary_dof_index),
                                                      ExcInternalError());
     
    -                                        dof_identities[slave_dof_index] =
    -                                          master_dof_index;
    +                                        dof_identities[dependent_dof_index] =
    +                                          primary_dof_index;
                                           }
                                       }
                                   }
    @@ -831,19 +833,21 @@ namespace internal
                                                       [other_fe_index];
                                 for (const auto &identity : identities)
                                   {
    -                                const types::global_dof_index master_dof_index =
    -                                  quad->dof_index(identity.first,
    -                                                  most_dominating_fe_index);
    -                                const types::global_dof_index slave_dof_index =
    -                                  quad->dof_index(identity.second,
    -                                                  other_fe_index);
    +                                const types::global_dof_index
    +                                  primary_dof_index =
    +                                    quad->dof_index(identity.first,
    +                                                    most_dominating_fe_index);
    +                                const types::global_dof_index
    +                                  dependent_dof_index =
    +                                    quad->dof_index(identity.second,
    +                                                    other_fe_index);
     
                                     // we only store an identity if we are about to
                                     // overwrite a valid degree of freedom. we will
                                     // skip invalid degrees of freedom (that are
                                     // associated with ghost cells) for now, and
                                     // consider them later in phase 5.
    -                                if (slave_dof_index !=
    +                                if (dependent_dof_index !=
                                         numbers::invalid_dof_index)
                                       {
                                         // if the DoF indices of both elements are
    @@ -853,18 +857,18 @@ namespace internal
                                         // not have a dof_identity yet, or it must
                                         // come out here to be exactly as we had
                                         // computed before
    -                                    if (master_dof_index !=
    +                                    if (primary_dof_index !=
                                             numbers::invalid_dof_index)
    -                                      Assert(
    -                                        (dof_identities.find(
    -                                           master_dof_index) ==
    -                                         dof_identities.end()) ||
    -                                          (dof_identities[slave_dof_index] ==
    -                                           master_dof_index),
    -                                        ExcInternalError());
    -
    -                                    dof_identities[slave_dof_index] =
    -                                      master_dof_index;
    +                                      Assert((dof_identities.find(
    +                                                primary_dof_index) ==
    +                                              dof_identities.end()) ||
    +                                               (dof_identities
    +                                                  [dependent_dof_index] ==
    +                                                primary_dof_index),
    +                                             ExcInternalError());
    +
    +                                    dof_identities[dependent_dof_index] =
    +                                      primary_dof_index;
                                       }
                                   }
                               }
    @@ -1149,7 +1153,7 @@ namespace internal
                                                       [other_fe_index];
                               for (const auto &identity : identities)
                                 {
    -                              const types::global_dof_index master_dof_index =
    +                              const types::global_dof_index primary_dof_index =
                                     dealii::internal::DoFAccessorImplementation::
                                       Implementation::get_dof_index(
                                         dof_handler,
    @@ -1158,15 +1162,16 @@ namespace internal
                                         most_dominating_fe_index,
                                         identity.first,
                                         std::integral_constant());
    -                              const types::global_dof_index slave_dof_index =
    -                                dealii::internal::DoFAccessorImplementation::
    -                                  Implementation::get_dof_index(
    -                                    dof_handler,
    -                                    0,
    -                                    vertex_index,
    -                                    other_fe_index,
    -                                    identity.second,
    -                                    std::integral_constant());
    +                              const types::global_dof_index
    +                                dependent_dof_index =
    +                                  dealii::internal::DoFAccessorImplementation::
    +                                    Implementation::get_dof_index(
    +                                      dof_handler,
    +                                      0,
    +                                      vertex_index,
    +                                      other_fe_index,
    +                                      identity.second,
    +                                      std::integral_constant());
     
                                   // check if we are on an interface between
                                   // a locally owned and a ghost cell on which
    @@ -1180,9 +1185,9 @@ namespace internal
                                   // we only have to set the indices of
                                   // degrees of freedom that have been
                                   // previously flagged invalid.
    -                              if ((slave_dof_index ==
    +                              if ((dependent_dof_index ==
                                        numbers::invalid_dof_index) &&
    -                                  (master_dof_index !=
    +                                  (primary_dof_index !=
                                        numbers::invalid_dof_index))
                                     dealii::internal::DoFAccessorImplementation::
                                       Implementation::set_dof_index(
    @@ -1192,7 +1197,7 @@ namespace internal
                                         other_fe_index,
                                         identity.second,
                                         std::integral_constant(),
    -                                    master_dof_index);
    +                                    primary_dof_index);
                                 }
                             }
                       }
    @@ -1356,10 +1361,10 @@ namespace internal
                                              ++j)
                                           {
                                             const types::global_dof_index
    -                                          master_dof_index = line->dof_index(
    +                                          primary_dof_index = line->dof_index(
                                                 j, dominating_fe_index);
                                             const types::global_dof_index
    -                                          slave_dof_index =
    +                                          dependent_dof_index =
                                                 line->dof_index(j, other_fe_index);
     
                                             // check if we are on an interface
    @@ -1375,12 +1380,12 @@ namespace internal
                                             // have to set the indices of degrees
                                             // of freedom that have been previously
                                             // flagged invalid.
    -                                        if ((slave_dof_index ==
    +                                        if ((dependent_dof_index ==
                                                  numbers::invalid_dof_index) &&
    -                                            (master_dof_index !=
    +                                            (primary_dof_index !=
                                                  numbers::invalid_dof_index))
                                               line->set_dof_index(j,
    -                                                              master_dof_index,
    +                                                              primary_dof_index,
                                                                   fe_index_2);
                                           }
                                       }
    @@ -1436,11 +1441,11 @@ namespace internal
                                     for (const auto &identity : identities)
                                       {
                                         const types::global_dof_index
    -                                      master_dof_index = line->dof_index(
    +                                      primary_dof_index = line->dof_index(
                                             identity.first,
                                             most_dominating_fe_index);
                                         const types::global_dof_index
    -                                      slave_dof_index =
    +                                      dependent_dof_index =
                                             line->dof_index(identity.second,
                                                             other_fe_index);
     
    @@ -1456,12 +1461,12 @@ namespace internal
                                         // we only have to set the indices of
                                         // degrees of freedom that have been
                                         // previously flagged invalid.
    -                                    if ((slave_dof_index ==
    +                                    if ((dependent_dof_index ==
                                              numbers::invalid_dof_index) &&
    -                                        (master_dof_index !=
    +                                        (primary_dof_index !=
                                              numbers::invalid_dof_index))
                                           line->set_dof_index(identity.second,
    -                                                          master_dof_index,
    +                                                          primary_dof_index,
                                                               other_fe_index);
                                       }
                                   }
    @@ -1583,12 +1588,14 @@ namespace internal
                                                       [other_fe_index];
                                 for (const auto &identity : identities)
                                   {
    -                                const types::global_dof_index master_dof_index =
    -                                  quad->dof_index(identity.first,
    -                                                  most_dominating_fe_index);
    -                                const types::global_dof_index slave_dof_index =
    -                                  quad->dof_index(identity.second,
    -                                                  other_fe_index);
    +                                const types::global_dof_index
    +                                  primary_dof_index =
    +                                    quad->dof_index(identity.first,
    +                                                    most_dominating_fe_index);
    +                                const types::global_dof_index
    +                                  dependent_dof_index =
    +                                    quad->dof_index(identity.second,
    +                                                    other_fe_index);
     
                                     // check if we are on an interface between
                                     // a locally owned and a ghost cell on which
    @@ -1601,12 +1608,12 @@ namespace internal
                                     // exchange in Phase 5). thus, we only have to
                                     // set the indices of degrees of freedom that
                                     // have been previously flagged invalid.
    -                                if ((slave_dof_index ==
    +                                if ((dependent_dof_index ==
                                          numbers::invalid_dof_index) &&
    -                                    (master_dof_index !=
    +                                    (primary_dof_index !=
                                          numbers::invalid_dof_index))
                                       quad->set_dof_index(identity.second,
    -                                                      master_dof_index,
    +                                                      primary_dof_index,
                                                           other_fe_index);
                                   }
                               }
    diff --git a/source/dofs/dof_tools_constraints.cc b/source/dofs/dof_tools_constraints.cc
    index 56a98a28b2..26a4fc88db 100644
    --- a/source/dofs/dof_tools_constraints.cc
    +++ b/source/dofs/dof_tools_constraints.cc
    @@ -57,16 +57,16 @@ namespace DoFTools
         namespace
         {
           inline bool
    -      check_master_dof_list(
    +      check_primary_dof_list(
             const FullMatrix &                  face_interpolation_matrix,
    -        const std::vector &master_dof_list)
    +        const std::vector &primary_dof_list)
           {
    -        const unsigned int N = master_dof_list.size();
    +        const unsigned int N = primary_dof_list.size();
     
             FullMatrix tmp(N, N);
             for (unsigned int i = 0; i < N; ++i)
               for (unsigned int j = 0; j < N; ++j)
    -            tmp(i, j) = face_interpolation_matrix(master_dof_list[i], j);
    +            tmp(i, j) = face_interpolation_matrix(primary_dof_list[i], j);
     
             // then use the algorithm from FullMatrix::gauss_jordan on this matrix
             // to find out whether it is singular. the algorithm there does pivoting
    @@ -103,7 +103,7 @@ namespace DoFTools
                       }
                   }
                 // check whether the pivot is too small. if that is the case, then
    -            // the matrix is singular and we shouldn't use this set of master
    +            // the matrix is singular and we shouldn't use this set of primary
                 // dofs
                 if (max < 1.e-12 * typical_diagonal_element)
                   return false;
    @@ -139,7 +139,7 @@ namespace DoFTools
                 tmp(j, j) = hr;
               }
     
    -        // everything went fine, so we can accept this set of master dofs (at
    +        // everything went fine, so we can accept this set of primary dofs (at
             // least as far as they have already been collected)
             return true;
           }
    @@ -151,10 +151,10 @@ namespace DoFTools
            * described by fe2 (for example for the complex case described
            * in the @ref hp_paper "hp paper"), we have to select fe2.dofs_per_face
            * out of the fe1.dofs_per_face face DoFs as the
    -       * master DoFs, and the rest become slave dofs. This function selects
    -       * which ones will be masters, and which ones will be slaves.
    +       * primary dofs, and the rest become dependent dofs. This function selects
    +       * which ones will be primary, and which ones will be dependents.
            *
    -       * The function assumes that master_dofs already has size
    +       * The function assumes that primary_dofs already has size
            * fe1.dofs_per_face. After the function, exactly fe2.dofs_per_face
            * entries will be true.
            *
    @@ -169,14 +169,14 @@ namespace DoFTools
            */
           template 
           void
    -      select_master_dofs_for_face_restriction(
    +      select_primary_dofs_for_face_restriction(
             const FiniteElement &fe1,
             const FiniteElement &fe2,
             const FullMatrix &          face_interpolation_matrix,
    -        std::vector &                 master_dof_mask)
    +        std::vector &                 primary_dof_mask)
           {
             Assert(fe1.dofs_per_face >= fe2.dofs_per_face, ExcInternalError());
    -        AssertDimension(master_dof_mask.size(), fe1.dofs_per_face);
    +        AssertDimension(primary_dof_mask.size(), fe1.dofs_per_face);
     
             Assert(fe2.dofs_per_vertex <= fe1.dofs_per_vertex, ExcInternalError());
             Assert(fe2.dofs_per_line <= fe1.dofs_per_line, ExcInternalError());
    @@ -184,13 +184,13 @@ namespace DoFTools
                    ExcInternalError());
     
             // the idea here is to designate as many DoFs in fe1 per object (vertex,
    -        // line, quad) as master as there are such dofs in fe2 (indices are int,
    -        // because we want to avoid the 'unsigned int < 0 is always false
    +        // line, quad) as primary as there are such dofs in fe2 (indices are
    +        // int, because we want to avoid the 'unsigned int < 0 is always false
             // warning for the cases at the bottom in 1d and 2d)
             //
             // as mentioned in the paper, it is not always easy to find a set of
    -        // master dofs that produces an invertible matrix. to this end, we check
    -        // in each step whether the matrix is still invertible and simply
    +        // primary dofs that produces an invertible matrix. to this end, we
    +        // check in each step whether the matrix is still invertible and simply
             // discard this dof if the matrix is not invertible anymore.
             //
             // the cases where we did have trouble in the past were with adding more
    @@ -198,12 +198,12 @@ namespace DoFTools
             // the hp/crash_12 test that tests that we can do exactly this, and
             // failed before we had code to compensate for this case). the other
             // case are system elements: if we have say a Q1Q2 vs a Q2Q3 element,
    -        // then we can't just take all master dofs on a line from a single base
    +        // then we can't just take all primary dofs on a line from a single base
             // element, since the shape functions of that base element are
             // independent of that of the other one. this latter case shows up when
             // running hp/hp_constraints_q_system_06
     
    -        std::vector master_dof_list;
    +        std::vector primary_dof_list;
             unsigned int                         index = 0;
             for (int v = 0;
                  v < static_cast(GeometryInfo::vertices_per_face);
    @@ -213,21 +213,21 @@ namespace DoFTools
                 unsigned int i          = 0;
                 while (dofs_added < fe2.dofs_per_vertex)
                   {
    -                // make sure that we were able to find a set of master dofs and
    +                // make sure that we were able to find a set of primary dofs and
                     // that the code down below didn't just reject all our efforts
                     Assert(i < fe1.dofs_per_vertex, ExcInternalError());
     
                     // tentatively push this vertex dof
    -                master_dof_list.push_back(index + i);
    +                primary_dof_list.push_back(index + i);
     
                     // then see what happens. if it succeeds, fine
    -                if (check_master_dof_list(face_interpolation_matrix,
    -                                          master_dof_list) == true)
    +                if (check_primary_dof_list(face_interpolation_matrix,
    +                                           primary_dof_list) == true)
                       ++dofs_added;
                     else
                       // well, it didn't. simply pop that dof from the list again
                       // and try with the next dof
    -                  master_dof_list.pop_back();
    +                  primary_dof_list.pop_back();
     
                     // forward counter by one
                     ++i;
    @@ -246,12 +246,12 @@ namespace DoFTools
                   {
                     Assert(i < fe1.dofs_per_line, ExcInternalError());
     
    -                master_dof_list.push_back(index + i);
    -                if (check_master_dof_list(face_interpolation_matrix,
    -                                          master_dof_list) == true)
    +                primary_dof_list.push_back(index + i);
    +                if (check_primary_dof_list(face_interpolation_matrix,
    +                                           primary_dof_list) == true)
                       ++dofs_added;
                     else
    -                  master_dof_list.pop_back();
    +                  primary_dof_list.pop_back();
     
                     ++i;
                   }
    @@ -269,12 +269,12 @@ namespace DoFTools
                   {
                     Assert(i < fe1.dofs_per_quad, ExcInternalError());
     
    -                master_dof_list.push_back(index + i);
    -                if (check_master_dof_list(face_interpolation_matrix,
    -                                          master_dof_list) == true)
    +                primary_dof_list.push_back(index + i);
    +                if (check_primary_dof_list(face_interpolation_matrix,
    +                                           primary_dof_list) == true)
                       ++dofs_added;
                     else
    -                  master_dof_list.pop_back();
    +                  primary_dof_list.pop_back();
     
                     ++i;
                   }
    @@ -282,36 +282,36 @@ namespace DoFTools
               }
     
             AssertDimension(index, fe1.dofs_per_face);
    -        AssertDimension(master_dof_list.size(), fe2.dofs_per_face);
    +        AssertDimension(primary_dof_list.size(), fe2.dofs_per_face);
     
             // finally copy the list into the mask
    -        std::fill(master_dof_mask.begin(), master_dof_mask.end(), false);
    -        for (const auto dof : master_dof_list)
    -          master_dof_mask[dof] = true;
    +        std::fill(primary_dof_mask.begin(), primary_dof_mask.end(), false);
    +        for (const auto dof : primary_dof_list)
    +          primary_dof_mask[dof] = true;
           }
     
     
     
           /**
            * Make sure that the mask exists that determines which dofs will be the
    -       * masters on refined faces where an fe1 and a fe2 meet.
    +       * primary on refined faces where an fe1 and a fe2 meet.
            */
           template 
           void
    -      ensure_existence_of_master_dof_mask(
    +      ensure_existence_of_primary_dof_mask(
             const FiniteElement &fe1,
             const FiniteElement &fe2,
             const FullMatrix &          face_interpolation_matrix,
    -        std::unique_ptr> &master_dof_mask)
    +        std::unique_ptr> &primary_dof_mask)
           {
    -        if (master_dof_mask == nullptr)
    +        if (primary_dof_mask == nullptr)
               {
    -            master_dof_mask =
    +            primary_dof_mask =
                   std::make_unique>(fe1.dofs_per_face);
    -            select_master_dofs_for_face_restriction(fe1,
    -                                                    fe2,
    -                                                    face_interpolation_matrix,
    -                                                    *master_dof_mask);
    +            select_primary_dofs_for_face_restriction(fe1,
    +                                                     fe2,
    +                                                     face_interpolation_matrix,
    +                                                     *primary_dof_mask);
               }
           }
     
    @@ -362,19 +362,19 @@ namespace DoFTools
     
           /**
            * Given the face interpolation matrix between two elements, split it into
    -       * its master and slave parts and invert the master part as
    +       * its primary and dependent parts and invert the primary part as
            * explained in the @ref hp_paper "hp paper".
            */
           void
           ensure_existence_of_split_face_matrix(
             const FullMatrix &face_interpolation_matrix,
    -        const std::vector & master_dof_mask,
    +        const std::vector & primary_dof_mask,
             std::unique_ptr, FullMatrix>>
               &split_matrix)
           {
    -        AssertDimension(master_dof_mask.size(), face_interpolation_matrix.m());
    -        Assert(std::count(master_dof_mask.begin(),
    -                          master_dof_mask.end(),
    +        AssertDimension(primary_dof_mask.size(), face_interpolation_matrix.m());
    +        Assert(std::count(primary_dof_mask.begin(),
    +                          primary_dof_mask.end(),
                               true) ==
                      static_cast(face_interpolation_matrix.n()),
                    ExcInternalError());
    @@ -384,35 +384,37 @@ namespace DoFTools
                 split_matrix = std::make_unique<
                   std::pair, FullMatrix>>();
     
    -            const unsigned int n_master_dofs = face_interpolation_matrix.n();
    -            const unsigned int n_dofs        = face_interpolation_matrix.m();
    +            const unsigned int n_primary_dofs = face_interpolation_matrix.n();
    +            const unsigned int n_dofs         = face_interpolation_matrix.m();
     
    -            Assert(n_master_dofs <= n_dofs, ExcInternalError());
    +            Assert(n_primary_dofs <= n_dofs, ExcInternalError());
     
    -            // copy and invert the master component, copy the slave component
    -            split_matrix->first.reinit(n_master_dofs, n_master_dofs);
    -            split_matrix->second.reinit(n_dofs - n_master_dofs, n_master_dofs);
    +            // copy and invert the primary component, copy the dependent
    +            // component
    +            split_matrix->first.reinit(n_primary_dofs, n_primary_dofs);
    +            split_matrix->second.reinit(n_dofs - n_primary_dofs,
    +                                        n_primary_dofs);
     
    -            unsigned int nth_master_dof = 0, nth_slave_dof = 0;
    +            unsigned int nth_primary_dof = 0, nth_dependent_dof = 0;
     
                 for (unsigned int i = 0; i < n_dofs; ++i)
    -              if (master_dof_mask[i] == true)
    +              if (primary_dof_mask[i] == true)
                     {
    -                  for (unsigned int j = 0; j < n_master_dofs; ++j)
    -                    split_matrix->first(nth_master_dof, j) =
    +                  for (unsigned int j = 0; j < n_primary_dofs; ++j)
    +                    split_matrix->first(nth_primary_dof, j) =
                           face_interpolation_matrix(i, j);
    -                  ++nth_master_dof;
    +                  ++nth_primary_dof;
                     }
                   else
                     {
    -                  for (unsigned int j = 0; j < n_master_dofs; ++j)
    -                    split_matrix->second(nth_slave_dof, j) =
    +                  for (unsigned int j = 0; j < n_primary_dofs; ++j)
    +                    split_matrix->second(nth_dependent_dof, j) =
                           face_interpolation_matrix(i, j);
    -                  ++nth_slave_dof;
    +                  ++nth_dependent_dof;
                     }
     
    -            AssertDimension(nth_master_dof, n_master_dofs);
    -            AssertDimension(nth_slave_dof, n_dofs - n_master_dofs);
    +            AssertDimension(nth_primary_dof, n_primary_dofs);
    +            AssertDimension(nth_dependent_dof, n_dofs - n_primary_dofs);
     
                 // TODO[WB]: We should make sure very small entries are removed
                 // after inversion
    @@ -451,40 +453,41 @@ namespace DoFTools
           template 
           void
           filter_constraints(
    -        const std::vector &master_dofs,
    -        const std::vector &slave_dofs,
    +        const std::vector &primary_dofs,
    +        const std::vector &dependent_dofs,
             const FullMatrix &                 face_constraints,
             AffineConstraints &                constraints)
           {
    -        Assert(face_constraints.n() == master_dofs.size(),
    -               ExcDimensionMismatch(master_dofs.size(), face_constraints.n()));
    -        Assert(face_constraints.m() == slave_dofs.size(),
    -               ExcDimensionMismatch(slave_dofs.size(), face_constraints.m()));
    +        Assert(face_constraints.n() == primary_dofs.size(),
    +               ExcDimensionMismatch(primary_dofs.size(), face_constraints.n()));
    +        Assert(face_constraints.m() == dependent_dofs.size(),
    +               ExcDimensionMismatch(dependent_dofs.size(),
    +                                    face_constraints.m()));
     
    -        const unsigned int n_master_dofs = master_dofs.size();
    -        const unsigned int n_slave_dofs  = slave_dofs.size();
    +        const unsigned int n_primary_dofs   = primary_dofs.size();
    +        const unsigned int n_dependent_dofs = dependent_dofs.size();
     
             // check for a couple conditions that happened in parallel distributed
             // mode
    -        for (unsigned int row = 0; row != n_slave_dofs; ++row)
    -          Assert(slave_dofs[row] != numbers::invalid_dof_index,
    +        for (unsigned int row = 0; row != n_dependent_dofs; ++row)
    +          Assert(dependent_dofs[row] != numbers::invalid_dof_index,
                      ExcInternalError());
    -        for (unsigned int col = 0; col != n_master_dofs; ++col)
    -          Assert(master_dofs[col] != numbers::invalid_dof_index,
    +        for (unsigned int col = 0; col != n_primary_dofs; ++col)
    +          Assert(primary_dofs[col] != numbers::invalid_dof_index,
                      ExcInternalError());
     
     
    -        for (unsigned int row = 0; row != n_slave_dofs; ++row)
    -          if (constraints.is_constrained(slave_dofs[row]) == false)
    +        for (unsigned int row = 0; row != n_dependent_dofs; ++row)
    +          if (constraints.is_constrained(dependent_dofs[row]) == false)
                 {
                   bool constraint_already_satisfied = false;
     
                   // Check if we have an identity constraint, which is already
                   // satisfied by unification of the corresponding global dof
                   // indices
    -              for (unsigned int i = 0; i < n_master_dofs; ++i)
    +              for (unsigned int i = 0; i < n_primary_dofs; ++i)
                     if (face_constraints(row, i) == 1.0)
    -                  if (master_dofs[i] == slave_dofs[row])
    +                  if (primary_dofs[i] == dependent_dofs[row])
                         {
                           constraint_already_satisfied = true;
                           break;
    @@ -495,7 +498,7 @@ namespace DoFTools
                       // add up the absolute values of all constraints in this line
                       // to get a measure of their absolute size
                       number1 abs_sum = 0;
    -                  for (unsigned int i = 0; i < n_master_dofs; ++i)
    +                  for (unsigned int i = 0; i < n_primary_dofs; ++i)
                         abs_sum += std::abs(face_constraints(row, i));
     
                       // then enter those constraints that are larger than
    @@ -504,15 +507,15 @@ namespace DoFTools
                       // those constraints in here will only lead to problems
                       // because it makes sparsity patterns fuller than necessary
                       // without producing any significant effect
    -                  constraints.add_line(slave_dofs[row]);
    -                  for (unsigned int i = 0; i < n_master_dofs; ++i)
    +                  constraints.add_line(dependent_dofs[row]);
    +                  for (unsigned int i = 0; i < n_primary_dofs; ++i)
                         if ((face_constraints(row, i) != 0) &&
                             (std::fabs(face_constraints(row, i)) >=
                              1e-14 * abs_sum))
    -                      constraints.add_entry(slave_dofs[row],
    -                                            master_dofs[i],
    +                      constraints.add_entry(dependent_dofs[row],
    +                                            primary_dofs[i],
                                                 face_constraints(row, i));
    -                  constraints.set_inhomogeneity(slave_dofs[row], 0.);
    +                  constraints.set_inhomogeneity(dependent_dofs[row], 0.);
                     }
                 }
           }
    @@ -981,10 +984,10 @@ namespace DoFTools
           // resized down below to avoid permanent re-allocation of memory
           FullMatrix constraint_matrix;
     
    -      // similarly have arrays that will hold master and slave dof numbers, as
    -      // well as a scratch array needed for the complicated case below
    -      std::vector master_dofs;
    -      std::vector slave_dofs;
    +      // similarly have arrays that will hold primary and dependent dof numbers,
    +      // as well as a scratch array needed for the complicated case below
    +      std::vector primary_dofs;
    +      std::vector dependent_dofs;
           std::vector scratch_dofs;
     
           // caches for the face and subface interpolation matrices between
    @@ -999,8 +1002,9 @@ namespace DoFTools
               GeometryInfo::max_children_per_face);
     
           // similarly have a cache for the matrices that are split into their
    -      // master and slave parts, and for which the master part is inverted.
    -      // these two matrices are derived from the face interpolation matrix
    +      // primary and dependent parts, and for which the primary part is
    +      // inverted. these two matrices are derived from the face interpolation
    +      // matrix
           // as described in the @ref hp_paper "hp paper"
           Table<2,
                 std::unique_ptr, FullMatrix>>>
    @@ -1009,8 +1013,8 @@ namespace DoFTools
     
           // finally, for each pair of finite elements, have a mask that states
           // which of the degrees of freedom on the coarse side of a refined face
    -      // will act as master dofs.
    -      Table<2, std::unique_ptr>> master_dof_masks(
    +      // will act as primary dofs.
    +      Table<2, std::unique_ptr>> primary_dof_masks(
             n_finite_elements(dof_handler), n_finite_elements(dof_handler));
     
           // loop over all faces
    @@ -1103,10 +1107,10 @@ namespace DoFTools
                             //
                             // so we are going to constrain the DoFs on the face
                             // children against the DoFs on the face itself
    -                        master_dofs.resize(cell->get_fe().dofs_per_face);
    +                        primary_dofs.resize(cell->get_fe().dofs_per_face);
     
                             cell->face(face)->get_dof_indices(
    -                          master_dofs, cell->active_fe_index());
    +                          primary_dofs, cell->active_fe_index());
     
                             // Now create constraints for the subfaces and
                             // assemble it. ignore all interfaces with artificial
    @@ -1147,16 +1151,17 @@ namespace DoFTools
     
                                 // Same procedure as for the mother cell. Extract
                                 // the face DoFs from the cell DoFs.
    -                            slave_dofs.resize(
    +                            dependent_dofs.resize(
                                   subface->get_fe(subface_fe_index).dofs_per_face);
    -                            subface->get_dof_indices(slave_dofs,
    +                            subface->get_dof_indices(dependent_dofs,
                                                          subface_fe_index);
     
    -                            for (const types::global_dof_index slave_dof :
    -                                 slave_dofs)
    +                            for (const types::global_dof_index dependent_dof :
    +                                 dependent_dofs)
                                   {
    -                                (void)slave_dof;
    -                                Assert(slave_dof != numbers::invalid_dof_index,
    +                                (void)dependent_dof;
    +                                Assert(dependent_dof !=
    +                                         numbers::invalid_dof_index,
                                            ExcInternalError());
                                   }
     
    @@ -1191,8 +1196,8 @@ namespace DoFTools
     
                                 // Add constraints to global AffineConstraints
                                 // object.
    -                            filter_constraints(master_dofs,
    -                                               slave_dofs,
    +                            filter_constraints(primary_dofs,
    +                                               dependent_dofs,
                                                    *(subface_interpolation_matrices
                                                        [cell->active_fe_index()]
                                                        [subface_fe_index][c]),
    @@ -1266,72 +1271,73 @@ namespace DoFTools
                               face_interpolation_matrices[dominating_fe_index]
                                                          [cell->active_fe_index()]);
     
    -                        // split this matrix into master and slave components.
    -                        // invert the master component
    -                        ensure_existence_of_master_dof_mask(
    +                        // split this matrix into primary and dependent
    +                        // components. invert the primary component
    +                        ensure_existence_of_primary_dof_mask(
                               cell->get_fe(),
                               dominating_fe,
                               (*face_interpolation_matrices
                                  [dominating_fe_index][cell->active_fe_index()]),
    -                          master_dof_masks[dominating_fe_index]
    -                                          [cell->active_fe_index()]);
    +                          primary_dof_masks[dominating_fe_index]
    +                                           [cell->active_fe_index()]);
     
                             ensure_existence_of_split_face_matrix(
                               *face_interpolation_matrices[dominating_fe_index]
                                                           [cell->active_fe_index()],
    -                          (*master_dof_masks[dominating_fe_index]
    -                                            [cell->active_fe_index()]),
    +                          (*primary_dof_masks[dominating_fe_index]
    +                                             [cell->active_fe_index()]),
                               split_face_interpolation_matrices
                                 [dominating_fe_index][cell->active_fe_index()]);
     
                             const FullMatrix
    -                          &restrict_mother_to_virtual_master_inv =
    +                          &restrict_mother_to_virtual_primary_inv =
                                 (split_face_interpolation_matrices
                                    [dominating_fe_index][cell->active_fe_index()]
                                      ->first);
     
                             const FullMatrix
    -                          &restrict_mother_to_virtual_slave =
    +                          &restrict_mother_to_virtual_dependent =
                                 (split_face_interpolation_matrices
                                    [dominating_fe_index][cell->active_fe_index()]
                                      ->second);
     
                             // now compute the constraint matrix as the product
    -                        // between the inverse matrix and the slave part
    +                        // between the inverse matrix and the dependent part
                             constraint_matrix.reinit(cell->get_fe().dofs_per_face -
                                                        dominating_fe.dofs_per_face,
                                                      dominating_fe.dofs_per_face);
    -                        restrict_mother_to_virtual_slave.mmult(
    +                        restrict_mother_to_virtual_dependent.mmult(
                               constraint_matrix,
    -                          restrict_mother_to_virtual_master_inv);
    +                          restrict_mother_to_virtual_primary_inv);
     
    -                        // then figure out the global numbers of master and
    -                        // slave dofs and apply constraints
    +                        // then figure out the global numbers of primary and
    +                        // dependent dofs and apply constraints
                             scratch_dofs.resize(cell->get_fe().dofs_per_face);
                             cell->face(face)->get_dof_indices(
                               scratch_dofs, cell->active_fe_index());
     
    -                        // split dofs into master and slave components
    -                        master_dofs.clear();
    -                        slave_dofs.clear();
    +                        // split dofs into primary and dependent components
    +                        primary_dofs.clear();
    +                        dependent_dofs.clear();
                             for (unsigned int i = 0;
                                  i < cell->get_fe().dofs_per_face;
                                  ++i)
    -                          if ((*master_dof_masks[dominating_fe_index]
    -                                                [cell->active_fe_index()])[i] ==
    +                          if ((*primary_dof_masks[dominating_fe_index]
    +                                                 [cell
    +                                                    ->active_fe_index()])[i] ==
                                   true)
    -                            master_dofs.push_back(scratch_dofs[i]);
    +                            primary_dofs.push_back(scratch_dofs[i]);
                               else
    -                            slave_dofs.push_back(scratch_dofs[i]);
    +                            dependent_dofs.push_back(scratch_dofs[i]);
     
    -                        AssertDimension(master_dofs.size(),
    +                        AssertDimension(primary_dofs.size(),
                                             dominating_fe.dofs_per_face);
    -                        AssertDimension(slave_dofs.size(),
    +                        AssertDimension(dependent_dofs.size(),
                                             cell->get_fe().dofs_per_face -
                                               dominating_fe.dofs_per_face);
     
    -                        filter_constraints(master_dofs,
    -                                           slave_dofs,
    +                        filter_constraints(primary_dofs,
    +                                           dependent_dofs,
                                                constraint_matrix,
                                                constraints);
     
    @@ -1386,14 +1392,14 @@ namespace DoFTools
     
                                 restrict_subface_to_virtual.mmult(
                                   constraint_matrix,
    -                              restrict_mother_to_virtual_master_inv);
    +                              restrict_mother_to_virtual_primary_inv);
     
    -                            slave_dofs.resize(subface_fe.dofs_per_face);
    +                            dependent_dofs.resize(subface_fe.dofs_per_face);
                                 cell->face(face)->child(sf)->get_dof_indices(
    -                              slave_dofs, subface_fe_index);
    +                              dependent_dofs, subface_fe_index);
     
    -                            filter_constraints(master_dofs,
    -                                               slave_dofs,
    +                            filter_constraints(primary_dofs,
    +                                               dependent_dofs,
                                                    constraint_matrix,
                                                    constraints);
                               } // loop over subfaces
    @@ -1449,19 +1455,20 @@ namespace DoFTools
                               {
                                 // Get DoFs on dominating and dominated side of the
                                 // face
    -                            master_dofs.resize(cell->get_fe().dofs_per_face);
    +                            primary_dofs.resize(cell->get_fe().dofs_per_face);
                                 cell->face(face)->get_dof_indices(
    -                              master_dofs, cell->active_fe_index());
    +                              primary_dofs, cell->active_fe_index());
     
    -                            // break if the n_master_dofs == 0, because we are
    +                            // break if the n_primary_dofs == 0, because we are
                                 // attempting to constrain to an element that has no
                                 // face dofs
    -                            if (master_dofs.size() == 0)
    +                            if (primary_dofs.size() == 0)
                                   break;
     
    -                            slave_dofs.resize(neighbor->get_fe().dofs_per_face);
    +                            dependent_dofs.resize(
    +                              neighbor->get_fe().dofs_per_face);
                                 cell->face(face)->get_dof_indices(
    -                              slave_dofs, neighbor->active_fe_index());
    +                              dependent_dofs, neighbor->active_fe_index());
     
                                 // make sure the element constraints for this face
                                 // are available
    @@ -1474,8 +1481,8 @@ namespace DoFTools
     
                                 // Add constraints to global constraint matrix.
                                 filter_constraints(
    -                              master_dofs,
    -                              slave_dofs,
    +                              primary_dofs,
    +                              dependent_dofs,
                                   *(face_interpolation_matrices
                                       [cell->active_fe_index()]
                                       [neighbor->active_fe_index()]),
    @@ -1529,10 +1536,11 @@ namespace DoFTools
                                 // FEs to that one. More precisely, we follow the
                                 // strategy outlined on page 17 of the hp paper:
                                 // First we find the dominant FE space S. Then we
    -                            // divide our dofs in master and slave such that
    -                            // I^{face,master}_{S^{face}->S} is invertible. And
    -                            // finally constrain slave dofs to master dofs based
    -                            // on the interpolation matrix.
    +                            // divide our dofs in primary and dependent such
    +                            // that I^{face,primary}_{S^{face}->S} is
    +                            // invertible. And finally constrain dependent dofs
    +                            // to primary dofs based on the interpolation
    +                            // matrix.
     
                                 const unsigned int this_fe_index =
                                   cell->active_fe_index();
    @@ -1575,74 +1583,74 @@ namespace DoFTools
                                   face_interpolation_matrices
                                     [dominating_fe_index][cell->active_fe_index()]);
     
    -                            // split this matrix into master and slave
    -                            // components. invert the master component
    -                            ensure_existence_of_master_dof_mask(
    +                            // split this matrix into primary and dependent
    +                            // components. invert the primary component
    +                            ensure_existence_of_primary_dof_mask(
                                   cell->get_fe(),
                                   dominating_fe,
                                   (*face_interpolation_matrices
                                      [dominating_fe_index]
                                      [cell->active_fe_index()]),
    -                              master_dof_masks[dominating_fe_index]
    -                                              [cell->active_fe_index()]);
    +                              primary_dof_masks[dominating_fe_index]
    +                                               [cell->active_fe_index()]);
     
                                 ensure_existence_of_split_face_matrix(
                                   *face_interpolation_matrices
                                     [dominating_fe_index][cell->active_fe_index()],
    -                              (*master_dof_masks[dominating_fe_index]
    -                                                [cell->active_fe_index()]),
    +                              (*primary_dof_masks[dominating_fe_index]
    +                                                 [cell->active_fe_index()]),
                                   split_face_interpolation_matrices
                                     [dominating_fe_index][cell->active_fe_index()]);
     
                                 const FullMatrix<
    -                              double> &restrict_mother_to_virtual_master_inv =
    +                              double> &restrict_mother_to_virtual_primary_inv =
                                   (split_face_interpolation_matrices
                                      [dominating_fe_index][cell->active_fe_index()]
                                        ->first);
     
                                 const FullMatrix<
    -                              double> &restrict_mother_to_virtual_slave =
    +                              double> &restrict_mother_to_virtual_dependent =
                                   (split_face_interpolation_matrices
                                      [dominating_fe_index][cell->active_fe_index()]
                                        ->second);
     
                                 // now compute the constraint matrix as the product
    -                            // between the inverse matrix and the slave part
    +                            // between the inverse matrix and the dependent part
                                 constraint_matrix.reinit(
                                   cell->get_fe().dofs_per_face -
                                     dominating_fe.dofs_per_face,
                                   dominating_fe.dofs_per_face);
    -                            restrict_mother_to_virtual_slave.mmult(
    +                            restrict_mother_to_virtual_dependent.mmult(
                                   constraint_matrix,
    -                              restrict_mother_to_virtual_master_inv);
    +                              restrict_mother_to_virtual_primary_inv);
     
    -                            // then figure out the global numbers of master and
    -                            // slave dofs and apply constraints
    +                            // then figure out the global numbers of primary and
    +                            // dependent dofs and apply constraints
                                 scratch_dofs.resize(cell->get_fe().dofs_per_face);
                                 cell->face(face)->get_dof_indices(
                                   scratch_dofs, cell->active_fe_index());
     
    -                            // split dofs into master and slave components
    -                            master_dofs.clear();
    -                            slave_dofs.clear();
    +                            // split dofs into primary and dependent components
    +                            primary_dofs.clear();
    +                            dependent_dofs.clear();
                                 for (unsigned int i = 0;
                                      i < cell->get_fe().dofs_per_face;
                                      ++i)
    -                              if ((*master_dof_masks[dominating_fe_index]
    -                                                    [cell->active_fe_index()])
    +                              if ((*primary_dof_masks[dominating_fe_index]
    +                                                     [cell->active_fe_index()])
                                         [i] == true)
    -                                master_dofs.push_back(scratch_dofs[i]);
    +                                primary_dofs.push_back(scratch_dofs[i]);
                                   else
    -                                slave_dofs.push_back(scratch_dofs[i]);
    +                                dependent_dofs.push_back(scratch_dofs[i]);
     
    -                            AssertDimension(master_dofs.size(),
    +                            AssertDimension(primary_dofs.size(),
                                                 dominating_fe.dofs_per_face);
    -                            AssertDimension(slave_dofs.size(),
    +                            AssertDimension(dependent_dofs.size(),
                                                 cell->get_fe().dofs_per_face -
                                                   dominating_fe.dofs_per_face);
     
    -                            filter_constraints(master_dofs,
    -                                               slave_dofs,
    +                            filter_constraints(primary_dofs,
    +                                               dependent_dofs,
                                                    constraint_matrix,
                                                    constraints);
     
    @@ -1672,14 +1680,15 @@ namespace DoFTools
     
                                 restrict_secondface_to_virtual.mmult(
                                   constraint_matrix,
    -                              restrict_mother_to_virtual_master_inv);
    +                              restrict_mother_to_virtual_primary_inv);
     
    -                            slave_dofs.resize(neighbor->get_fe().dofs_per_face);
    +                            dependent_dofs.resize(
    +                              neighbor->get_fe().dofs_per_face);
                                 cell->face(face)->get_dof_indices(
    -                              slave_dofs, neighbor->active_fe_index());
    +                              dependent_dofs, neighbor->active_fe_index());
     
    -                            filter_constraints(master_dofs,
    -                                               slave_dofs,
    +                            filter_constraints(primary_dofs,
    +                                               dependent_dofs,
                                                    constraint_matrix,
                                                    constraints);
     
    diff --git a/source/fe/fe_q_hierarchical.cc b/source/fe/fe_q_hierarchical.cc
    index e6b6460391..ea724014ab 100644
    --- a/source/fe/fe_q_hierarchical.cc
    +++ b/source/fe/fe_q_hierarchical.cc
    @@ -79,12 +79,12 @@ FE_Q_Hierarchical::FE_Q_Hierarchical(const unsigned int degree)
     
       // The matrix @p{dofs_cell} contains the
       // values of the linear functionals of
    -  // the master 1d cell applied to the
    +  // the parent 1d cell applied to the
       // shape functions of the two 1d subcells.
       // The matrix @p{dofs_subcell} contains
       // the values of the linear functionals
       // on each 1d subcell applied to the
    -  // shape functions on the master 1d
    +  // shape functions on the parent 1d
       // subcell.
       // We use @p{dofs_cell} and
       // @p{dofs_subcell} to compute the
    @@ -709,7 +709,7 @@ FE_Q_Hierarchical::initialize_embedding_and_restriction(
       // the embedding matrix.
       //
       // i loops over the dofs in the
    -  // master cell. These are the
    +  // parent cell. These are the
       // columns in the embedding matrix.
       for (unsigned int j = 0; j < this->dofs_per_cell; ++j)
         for (unsigned int i = 0; i < this->dofs_per_cell; ++i)
    diff --git a/source/grid/grid_out.cc b/source/grid/grid_out.cc
    index cacec43d38..ef1bde0f28 100644
    --- a/source/grid/grid_out.cc
    +++ b/source/grid/grid_out.cc
    @@ -3498,9 +3498,9 @@ GridOut::write_mesh_per_processor_as_vtu(
                                     ".proc" + Utilities::int_to_string(i, 4) +
                                     ".vtu");
     
    -          const std::string pvtu_master_filename =
    +          const std::string pvtu_filename =
                 (filename_without_extension + ".pvtu");
    -          std::ofstream pvtu_master(pvtu_master_filename.c_str());
    +          std::ofstream pvtu_output(pvtu_filename.c_str());
     
               DataOut> data_out;
               data_out.attach_triangulation(*tr);
    @@ -3515,7 +3515,7 @@ GridOut::write_mesh_per_processor_as_vtu(
     
               data_out.build_patches();
     
    -          data_out.write_pvtu_record(pvtu_master, filenames);
    +          data_out.write_pvtu_record(pvtu_output, filenames);
             }
         }
     
    diff --git a/source/lac/ginkgo_solver.cc b/source/lac/ginkgo_solver.cc
    index 4e158c59b6..5f5d302eb1 100644
    --- a/source/lac/ginkgo_solver.cc
    +++ b/source/lac/ginkgo_solver.cc
    @@ -137,14 +137,14 @@ namespace GinkgoWrappers
         // logger returns a `linop`, it is necessary to convert it to a Dense
         // matrix. Additionally, if the logger is logging on the gpu, it is
         // necessary to copy the data to the host and hence the
    -    // `residual_norm_d_master`
    +    // `residual_norm_d_parent`
         auto residual_norm = convergence_logger->get_residual_norm();
         auto residual_norm_d =
           gko::as>(residual_norm);
    -    auto residual_norm_d_master =
    +    auto residual_norm_d_parent =
           gko::matrix::Dense::create(executor->get_master(),
                                                 gko::dim<2>{1, 1});
    -    residual_norm_d_master->copy_from(residual_norm_d);
    +    residual_norm_d_parent->copy_from(residual_norm_d);
     
         // Get the number of iterations taken to converge to the solution.
         auto num_iteration = convergence_logger->get_num_iterations();
    @@ -171,12 +171,12 @@ namespace GinkgoWrappers
     
         Assert(b_norm.get()->at(0, 0) != 0.0, ExcDivideByZero());
         // Pass the number of iterations and residual norm to the solver_control
    -    // object. As both `residual_norm_d_master` and `b_norm` are seen as Dense
    +    // object. As both `residual_norm_d_parent` and `b_norm` are seen as Dense
         // matrices, we use the `at` function to get the first value here. In case
         // of multiple right hand sides, this will need to be modified.
         const SolverControl::State state =
           solver_control.check(num_iteration,
    -                           residual_norm_d_master->at(0, 0) / b_norm->at(0, 0));
    +                           residual_norm_d_parent->at(0, 0) / b_norm->at(0, 0));
     
         // in case of failure: throw exception
         if (state != SolverControl::success)
    diff --git a/tests/data_out/data_out_13.cc b/tests/data_out/data_out_13.cc
    index 6218ebb5d7..4ca79d3ead 100644
    --- a/tests/data_out/data_out_13.cc
    +++ b/tests/data_out/data_out_13.cc
    @@ -178,8 +178,8 @@ check()
       filenames.push_back("output_" + Utilities::int_to_string(dim) + "d.vtu");
     
       /*
    -  std::ofstream master_output("output_" + Utilities::int_to_string(dim) +
    -  "d.pvtu"); data_out.write_pvtu_record(master_output, filenames);
    +  std::ofstream pvtu_output("output_" + Utilities::int_to_string(dim) +
    +  "d.pvtu"); data_out.write_pvtu_record(pvtu_output, filenames);
     
       std::ofstream out(filenames[0]);
       data_out.write_vtu(out);
    diff --git a/tests/data_out/data_out_base_pvd.cc b/tests/data_out/data_out_base_pvd.cc
    index f07c759b65..182f665f03 100644
    --- a/tests/data_out/data_out_base_pvd.cc
    +++ b/tests/data_out/data_out_base_pvd.cc
    @@ -14,7 +14,7 @@
     // ---------------------------------------------------------------------
     
     
    -// write the pvd master record for parallel visualization through the
    +// write the pvd primary record for parallel visualization through the
     // vtu file format
     
     #include 
    diff --git a/tests/data_out/data_out_base_pvtu.cc b/tests/data_out/data_out_base_pvtu.cc
    index dfdebc7c56..4ec47dea18 100644
    --- a/tests/data_out/data_out_base_pvtu.cc
    +++ b/tests/data_out/data_out_base_pvtu.cc
    @@ -14,7 +14,7 @@
     // ---------------------------------------------------------------------
     
     
    -// write the pvtu master record for parallel visualization through the
    +// write the pvtu primary record for parallel visualization through the
     // vtu file format
     
     #include 
    diff --git a/tests/distributed_grids/2d_refinement_10.cc b/tests/distributed_grids/2d_refinement_10.cc
    index 7cda1a0f48..aa73d51de3 100644
    --- a/tests/distributed_grids/2d_refinement_10.cc
    +++ b/tests/distributed_grids/2d_refinement_10.cc
    @@ -337,8 +337,8 @@ TriaTest::write_vtu(const unsigned int counter) const
               filenames.push_back(output_tag + ".slot-" +
                                   Utilities::int_to_string(i, 4) + ".vtu");
             }
    -      std::ofstream master_output((output_tag + ".pvtu").c_str());
    -      data_out.write_pvtu_record(master_output, filenames);
    +      std::ofstream pvtu_output((output_tag + ".pvtu").c_str());
    +      data_out.write_pvtu_record(pvtu_output, filenames);
         }
     #else
       (void)counter;
    diff --git a/tests/distributed_grids/3d_refinement_12.cc b/tests/distributed_grids/3d_refinement_12.cc
    index 5112e62aa0..594a181881 100644
    --- a/tests/distributed_grids/3d_refinement_12.cc
    +++ b/tests/distributed_grids/3d_refinement_12.cc
    @@ -337,8 +337,8 @@ TriaTest::write_vtu(const unsigned int counter) const
               filenames.push_back(output_tag + ".slot-" +
                                   Utilities::int_to_string(i, 4) + ".vtu");
             }
    -      std::ofstream master_output((output_tag + ".pvtu").c_str());
    -      data_out.write_pvtu_record(master_output, filenames);
    +      std::ofstream pvtu_output((output_tag + ".pvtu").c_str());
    +      data_out.write_pvtu_record(pvtu_output, filenames);
         }
     #else
       (void)counter;
    diff --git a/tests/dofs/dof_tools_extract_dofs_with_support_contained_within_02.cc b/tests/dofs/dof_tools_extract_dofs_with_support_contained_within_02.cc
    index 3881f21b2b..1638f6e1e1 100644
    --- a/tests/dofs/dof_tools_extract_dofs_with_support_contained_within_02.cc
    +++ b/tests/dofs/dof_tools_extract_dofs_with_support_contained_within_02.cc
    @@ -168,10 +168,10 @@ test(const unsigned int flag)
                    ++i)
                 filenames.push_back(output_name(flag, i));
     
    -          const std::string master_name =
    +          const std::string pvtu_filename =
                 "output" + Utilities::int_to_string(flag) + ".pvtu";
    -          std::ofstream pvtu_master(master_name.c_str());
    -          data_out.write_pvtu_record(pvtu_master, filenames);
    +          std::ofstream pvtu_output(pvtu_filename.c_str());
    +          data_out.write_pvtu_record(pvtu_output, filenames);
             }
         }
     
    diff --git a/tests/dofs/dof_tools_extract_dofs_with_support_contained_within_04.cc b/tests/dofs/dof_tools_extract_dofs_with_support_contained_within_04.cc
    index 7f396a3a9f..e32f9970c2 100644
    --- a/tests/dofs/dof_tools_extract_dofs_with_support_contained_within_04.cc
    +++ b/tests/dofs/dof_tools_extract_dofs_with_support_contained_within_04.cc
    @@ -292,9 +292,9 @@ test()
                      ++i)
                   filenames.push_back(output_name(i));
     
    -            const std::string master_name = "output.pvtu";
    -            std::ofstream     pvtu_master(master_name.c_str());
    -            data_out.write_pvtu_record(pvtu_master, filenames);
    +            const std::string pvtu_filename = "output.pvtu";
    +            std::ofstream     pvtu_output(pvtu_filename.c_str());
    +            data_out.write_pvtu_record(pvtu_output, filenames);
               }
           }
         }
    diff --git a/tests/fe/nedelec_crash_hp.cc b/tests/fe/nedelec_crash_hp.cc
    index 2e73a59b35..0636ce28b1 100644
    --- a/tests/fe/nedelec_crash_hp.cc
    +++ b/tests/fe/nedelec_crash_hp.cc
    @@ -18,7 +18,7 @@
     // interpolation matrices from lower to higher order elements. This
     // consequently led to a situation where
     // DoFTools::make_hanging_node_constraints got into trouble because it could
    -// not find a master DoF for one particular slave DoF.
    +// not find a primary DoF for one particular dependent DoF.
     
     
     char logname[] = "output";
    diff --git a/tests/fullydistributed_grids/copy_serial_tria_grouped_01.cc b/tests/fullydistributed_grids/copy_serial_tria_grouped_01.cc
    index f9b3c992c5..324bedcf01 100644
    --- a/tests/fullydistributed_grids/copy_serial_tria_grouped_01.cc
    +++ b/tests/fullydistributed_grids/copy_serial_tria_grouped_01.cc
    @@ -16,7 +16,7 @@
     
     // Create the TriangulationDescription::Description with
     // create_description_from_triangulation_in_groups, i.e. by a set of
    -// master processes.
    +// parent processes.
     
     #include 
     
    diff --git a/tests/hp/crash_12.cc b/tests/hp/crash_12.cc
    index 6f1c339e58..cc951b14b0 100644
    --- a/tests/hp/crash_12.cc
    +++ b/tests/hp/crash_12.cc
    @@ -20,7 +20,7 @@
     //
     // this code in particular tests some compensating code in
     // dof_tools.cc, where we have to make sure that we select a suitable
    -// set of master dofs. this is mostly trivial in 2d and for most fe
    +// set of primary dofs. this is mostly trivial in 2d and for most fe
     // combinations in 3d as well. the exceptions are that it doesn't work
     // as easily in 3d for the combinations Q4/Q3, Q5/Q3, and
     // Q5/Q4. Higher order finite elements in 3d will probably only
    diff --git a/tests/mpi/interpolate_to_different_mesh_01.cc b/tests/mpi/interpolate_to_different_mesh_01.cc
    index 6e31fe9ce8..262c4446f2 100644
    --- a/tests/mpi/interpolate_to_different_mesh_01.cc
    +++ b/tests/mpi/interpolate_to_different_mesh_01.cc
    @@ -97,10 +97,10 @@ output(DoFHandler & dh,
                ++i)
             filenames.push_back(filename_ + Utilities::int_to_string(loop, 2) +
                                 "." + Utilities::int_to_string(i, 2) + ".vtu");
    -      const std::string pvtu_master_filename =
    +      const std::string pvtu_filename =
             (filename_ + Utilities::int_to_string(loop, 2) + ".pvtu");
    -      std::ofstream pvtu_master(pvtu_master_filename.c_str());
    -      data_out.write_pvtu_record(pvtu_master, filenames);
    +      std::ofstream pvtu_output(pvtu_filename.c_str());
    +      data_out.write_pvtu_record(pvtu_output, filenames);
         }
     }
     
    diff --git a/tests/mpi/muelu_periodicity.cc b/tests/mpi/muelu_periodicity.cc
    index 388bc532f0..8342b37d5d 100644
    --- a/tests/mpi/muelu_periodicity.cc
    +++ b/tests/mpi/muelu_periodicity.cc
    @@ -704,11 +704,11 @@ namespace Step22
               filenames.push_back(std::string("solution-") +
                                   Utilities::int_to_string(refinement_cycle, 2) +
                                   "." + Utilities::int_to_string(i, 2) + ".vtu");
    -        const std::string pvtu_master_filename =
    +        const std::string pvtu_filename =
               ("solution-" + Utilities::int_to_string(refinement_cycle, 2) +
                ".pvtu");
    -        std::ofstream pvtu_master(pvtu_master_filename.c_str());
    -        data_out.write_pvtu_record(pvtu_master, filenames);
    +        std::ofstream pvtu_output(pvtu_filename.c_str());
    +        data_out.write_pvtu_record(pvtu_output, filenames);
           }
       }
     
    diff --git a/tests/mpi/parallel_vtu_01.cc b/tests/mpi/parallel_vtu_01.cc
    index ddf8fee10d..5f82563ce4 100644
    --- a/tests/mpi/parallel_vtu_01.cc
    +++ b/tests/mpi/parallel_vtu_01.cc
    @@ -77,8 +77,8 @@ test()
           std::vector filenames;
           filenames.push_back("output.vtu");
           {
    -        std::ofstream master("output.pvtu");
    -        data_out.write_pvtu_record(master, filenames);
    +        std::ofstream pvtu_output("output.pvtu");
    +        data_out.write_pvtu_record(pvtu_output, filenames);
           }
     
           cat_file("output.vtu");
    diff --git a/tests/mpi/periodicity_01.cc b/tests/mpi/periodicity_01.cc
    index cd1ff8615d..720c3f7944 100644
    --- a/tests/mpi/periodicity_01.cc
    +++ b/tests/mpi/periodicity_01.cc
    @@ -505,8 +505,8 @@ namespace Step40
               filenames.push_back("solution-" + Utilities::int_to_string(cycle, 2) +
                                   "." + Utilities::int_to_string(i, 4) + ".vtu");
     
    -        std::ofstream master_output((filename + ".pvtu").c_str());
    -        data_out.write_pvtu_record(master_output, filenames);
    +        std::ofstream pvtu_output((filename + ".pvtu").c_str());
    +        data_out.write_pvtu_record(pvtu_output, filenames);
           }
       }
     
    diff --git a/tests/mpi/periodicity_02.cc b/tests/mpi/periodicity_02.cc
    index 9bfe65091b..4d51fdb634 100644
    --- a/tests/mpi/periodicity_02.cc
    +++ b/tests/mpi/periodicity_02.cc
    @@ -722,11 +722,11 @@ namespace Step22
               filenames.push_back(std::string("solution-") +
                                   Utilities::int_to_string(refinement_cycle, 2) +
                                   "." + Utilities::int_to_string(i, 2) + ".vtu");
    -        const std::string pvtu_master_filename =
    +        const std::string pvtu_filename =
               ("solution-" + Utilities::int_to_string(refinement_cycle, 2) +
                ".pvtu");
    -        std::ofstream pvtu_master(pvtu_master_filename.c_str());
    -        data_out.write_pvtu_record(pvtu_master, filenames);
    +        std::ofstream pvtu_output(pvtu_filename.c_str());
    +        data_out.write_pvtu_record(pvtu_output, filenames);
           }
       }
     
    diff --git a/tests/mpi/periodicity_03.cc b/tests/mpi/periodicity_03.cc
    index c1b6a22669..8d545e6033 100644
    --- a/tests/mpi/periodicity_03.cc
    +++ b/tests/mpi/periodicity_03.cc
    @@ -803,11 +803,11 @@ namespace Step22
               filenames.push_back(std::string("solution-") +
                                   Utilities::int_to_string(refinement_cycle, 2) +
                                   "." + Utilities::int_to_string(i, 2) + ".vtu");
    -        const std::string pvtu_master_filename =
    +        const std::string pvtu_filename =
               ("solution-" + Utilities::int_to_string(refinement_cycle, 2) +
                ".pvtu");
    -        std::ofstream pvtu_master(pvtu_master_filename.c_str());
    -        data_out.write_pvtu_record(pvtu_master, filenames);
    +        std::ofstream pvtu_output(pvtu_filename.c_str());
    +        data_out.write_pvtu_record(pvtu_output, filenames);
           }
       }
     
    diff --git a/tests/mpi/step-37.cc b/tests/mpi/step-37.cc
    index 82e994820c..fca726b571 100644
    --- a/tests/mpi/step-37.cc
    +++ b/tests/mpi/step-37.cc
    @@ -480,10 +480,10 @@ namespace Step37
               filenames.emplace_back("solution-" + std::to_string(cycle) + "." +
                                      std::to_string(i) + ".vtu");
     
    -        std::string master_name =
    +        std::string pvtu_filename =
               "solution-" + Utilities::to_string(cycle) + ".pvtu";
    -        std::ofstream master_output(master_name.c_str());
    -        data_out.write_pvtu_record(master_output, filenames);
    +        std::ofstream pvtu_output(pvtu_filename.c_str());
    +        data_out.write_pvtu_record(pvtu_output, filenames);
           }
     
         if (dim == 2 && Utilities::MPI::n_mpi_processes(MPI_COMM_WORLD) == 1)
    diff --git a/tests/physics/step-18-rotation_matrix.cc b/tests/physics/step-18-rotation_matrix.cc
    index b8106a8529..7a00496532 100644
    --- a/tests/physics/step-18-rotation_matrix.cc
    +++ b/tests/physics/step-18-rotation_matrix.cc
    @@ -557,17 +557,18 @@ namespace Step18
               filenames.push_back("solution-" +
                                   Utilities::int_to_string(timestep_no, 4) + "." +
                                   Utilities::int_to_string(i, 3) + ".vtu");
    -        const std::string visit_master_filename =
    +        const std::string visit_filename =
               ("solution-" + Utilities::int_to_string(timestep_no, 4) + ".visit");
    -        std::ofstream visit_master(visit_master_filename.c_str());
    -        DataOutBase::write_visit_record(visit_master, filenames);
    -        const std::string pvtu_master_filename =
    +        std::ofstream visit_output(visit_filename.c_str());
    +        DataOutBase::write_visit_record(visit_output, filenames);
    +
    +        const std::string pvtu_filename =
               ("solution-" + Utilities::int_to_string(timestep_no, 4) + ".pvtu");
    -        std::ofstream pvtu_master(pvtu_master_filename.c_str());
    -        data_out.write_pvtu_record(pvtu_master, filenames);
    +        std::ofstream pvtu_output(pvtu_filename.c_str());
    +        data_out.write_pvtu_record(pvtu_output, filenames);
             static std::vector> times_and_names;
             times_and_names.push_back(
    -          std::pair(present_time, pvtu_master_filename));
    +          std::pair(present_time, pvtu_filename));
             std::ofstream pvd_output("solution.pvd");
             DataOutBase::write_pvd_record(pvd_output, times_and_names);
           }
    diff --git a/tests/physics/step-18.cc b/tests/physics/step-18.cc
    index 0ea7392da7..82e7a35b1b 100644
    --- a/tests/physics/step-18.cc
    +++ b/tests/physics/step-18.cc
    @@ -573,17 +573,18 @@ namespace Step18
               filenames.push_back("solution-" +
                                   Utilities::int_to_string(timestep_no, 4) + "." +
                                   Utilities::int_to_string(i, 3) + ".vtu");
    -        const std::string visit_master_filename =
    +        const std::string visit_filename =
               ("solution-" + Utilities::int_to_string(timestep_no, 4) + ".visit");
    -        std::ofstream visit_master(visit_master_filename.c_str());
    -        DataOutBase::write_visit_record(visit_master, filenames);
    -        const std::string pvtu_master_filename =
    +        std::ofstream visit_output(visit_filename.c_str());
    +        DataOutBase::write_visit_record(visit_output, filenames);
    +
    +        const std::string pvtu_filename =
               ("solution-" + Utilities::int_to_string(timestep_no, 4) + ".pvtu");
    -        std::ofstream pvtu_master(pvtu_master_filename.c_str());
    -        data_out.write_pvtu_record(pvtu_master, filenames);
    +        std::ofstream pvtu_output(pvtu_filename.c_str());
    +        data_out.write_pvtu_record(pvtu_output, filenames);
             static std::vector> times_and_names;
             times_and_names.push_back(
    -          std::pair(present_time, pvtu_master_filename));
    +          std::pair(present_time, pvtu_filename));
             std::ofstream pvd_output("solution.pvd");
             DataOutBase::write_pvd_record(pvd_output, times_and_names);
           }
    diff --git a/tests/trilinos/solver_control_06.cc b/tests/trilinos/solver_control_06.cc
    index 32b7664870..d406393f8b 100644
    --- a/tests/trilinos/solver_control_06.cc
    +++ b/tests/trilinos/solver_control_06.cc
    @@ -477,9 +477,9 @@ Test_Solver_Output::output(unsigned int cycle)
                ++i)
             filenames.push_back("solution-" + Utilities::int_to_string(cycle, 2) +
                                 "." + Utilities::int_to_string(i, 4) + ".vtu");
    -      std::ofstream master_output(
    +      std::ofstream pvtu_output(
             ("solution-" + Utilities::int_to_string(cycle, 2) + ".pvtu").c_str());
    -      data_out.write_pvtu_record(master_output, filenames);
    +      data_out.write_pvtu_record(pvtu_output, filenames);
         }
     }
     
    -- 
    2.39.5