/**
   * Set the solver configuration object.
   */
  void set_solver_configuration(SolverConfiguration & solver_configuration)
  {
    this->set_solver_configuration(&solver_configuration);
  }

protected:
  /**

                      sender_could_become_owner)
                    {
                      if (it != repartitioned_node_pids.end() &&
                          pid < it->second)
                        it->second = pid;
                      else
                        repartitioned_node_pids[n] = pid;
                    }
                  else
                    if (it == repartitioned_node_pids.end())
                      repartitioned_node_pids[n] =
                        DofObject::invalid_processor_id;

                  repartitioned_node_sets_to_push[pid].insert(n);

    {
      ray_target = inside - Point(1);
      intersection_distances =
        this->find_ray_intersections(inside, ray_target);
    }

  // I'd make this an assert, but I'm not 100% confident we can't

}

template <typename T>
SolverConfiguration * LinearSolver<T>::solver_configuration() const
{
  return _solver_configuration;
}

template <typename T>
void LinearSolver<T>::set_solver_configuration(SolverConfiguration * solver_configuration)
{
  _solver_configuration = solver_configuration;
}

template <typename T>

  if (setting.has_value())
    return setting.value();

  if (_solver_configuration)
    if (const auto it = this->_solver_configuration->real_valued_data.find(setting_name);
        it != this->_solver_configuration->real_valued_data.end())
      return double(it->second);

  if (default_value.has_value())
    return default_value.value();

  libmesh_error_msg("Linear solver setting '"
                    << setting_name
                    << "' must be supplied through an input argument, a SolverConfiguration "
                    << "object, or a default value.");

  if (setting.has_value())
    return setting.value();

  if (_solver_configuration)
    if (const auto it = this->_solver_configuration->int_valued_data.find(setting_name);
        it != this->_solver_configuration->int_valued_data.end())
      return it->second;

  if (default_value.has_value())
    return default_value.value();

  libmesh_error_msg("Linear solver setting '"
                    << setting_name
                    << "' must be supplied through an input argument, a SolverConfiguration "
                    << "object, or a default value.");

class ScopedSolverConfiguration
{
public:
  ScopedSolverConfiguration(LinearSolver<Number> & solver,
                            SolverConfiguration * temporary_configuration)
    : _solver(solver),
      _previous_configuration(solver.solver_configuration()),
      _restore(temporary_configuration != nullptr)
  {
    if (_restore)
      _solver.set_solver_configuration(temporary_configuration);
  }

  ~ScopedSolverConfiguration()
  {
    if (_restore)
      _solver.set_solver_configuration(_previous_configuration);
  }

private:
  LinearSolver<Number> & _solver;

class SubsetRestrictionGuard
{
public:
  explicit SubsetRestrictionGuard(LinearSolver<Number> & solver)
    : _solver(solver), _restricted(false)
  {
  }

  ~SubsetRestrictionGuard()
  {
    if (_restricted)
      _solver.restrict_solve_to(nullptr);
  }

  void restrict(const std::vector<unsigned int> * dofs, const SubsetSolveMode subset_solve_mode)
  {
    _restricted = true;
    _solver.restrict_solve_to(dofs, subset_solve_mode);
  }

  void clear()
  {
    if (_restricted)
      {
        _solver.restrict_solve_to(nullptr);
        _restricted = false;
      }
  }

private:
  LinearSolver<Number> & _solver;

void LinearImplicitSystem::solve ()
{
  this->solve(LinearImplicitSystemSolveOptions{});
}

void LinearImplicitSystem::solve(const LinearImplicitSystemSolveOptions & options)
{
  LinearSolver<Number> * const solver = options.solver ? options.solver : linear_solver.get();
  libmesh_assert(solver);

#ifndef NDEBUG
#ifdef LIBMESH_HAVE_MPI
  int communicator_comparison;
  libmesh_call_mpi(
      MPI_Comm_compare(solver->comm().get(), this->comm().get(), &communicator_comparison));
  libmesh_assert(communicator_comparison == MPI_IDENT || communicator_comparison == MPI_CONGRUENT);
#else
  libmesh_assert_equal_to(solver->comm().get(), this->comm().get());
#endif
#endif

  const bool assemble = options.assemble_before_solve.value_or(this->assemble_before_solve);

  if (assemble)
    // Assemble the linear system
    this->assemble();

  ScopedSolverConfiguration scoped_configuration(*solver, options.solver_configuration);

  // If the linear solver hasn't been initialized, we do so here.
  if (this->prefix_with_name())
    solver->init(this->prefix().c_str());
  else
    solver->init();

  solver->init_systems(*this);

  SubsetRestrictionGuard subset_guard(*solver);

  if (_subset != nullptr)
    subset_guard.restrict(&_subset->dof_ids(), _subset_solve_mode);

  // Solve the linear system.  Several cases:
  std::pair<unsigned int, Real> rval = std::make_pair(0,0.0);
  SparseMatrix<Number> * const preconditioner = this->request_matrix("Preconditioner");

  if (options.solver_configuration)
    {
      if (_shell_matrix)
        // 1.) Shell matrix with or without user-supplied preconditioner.
        rval = solver->solve(*_shell_matrix, preconditioner, *solution, *rhs);
      else
        // 2.) No shell matrix, with or without user-supplied preconditioner.
        rval = solver->solve(*matrix, preconditioner, *solution, *rhs);
    }
  else
    {
      // Get the user-specified linear solver tolerance and iteration limit.
      const auto [maxits, tol] = this->get_linear_solve_parameters();

      if (_shell_matrix)
        // 1.) Shell matrix with or without user-supplied preconditioner.
        rval = solver->solve(*_shell_matrix, preconditioner, *solution, *rhs, tol, maxits);
      else
        // 2.) No shell matrix, with or without user-supplied preconditioner.
        rval = solver->solve(*matrix, preconditioner, *solution, *rhs, tol, maxits);
    }

  subset_guard.clear();

  // Store the number of linear iterations required to
  // solve and the final residual.