switch (totalorder)
    {
      // Constant shape functions
    case CONSTANT:
      {
        libmesh_assert_equal_to (elem_soln.size(), 1);

        std::fill(nodal_soln.begin(), nodal_soln.end(), elem_soln[0]);

        return;
      }

                      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);

  // NOTE: Currently, this reader is capable of reading only individual components of vector types,
  //       and each must be written out to its own scalar elemental data variable.
  const auto & var_type = system.variable_type(var_num);
  libmesh_error_msg_if(!EquationSystems::is_elemental_data_fe_type(var_type),
                       "Error! Trying to copy elemental solution into a variable that is not elemental data.");

  const MeshBase & mesh = MeshInput<MeshBase>::mesh();

  // Get a subset of all variable names that can be written directly
  // as elemental data. We treat those slightly differently since they
  // truly only have a single value per Elem.
  std::vector<std::string> elemental_var_names;
  if (!_output_variables.empty())
    elemental_var_names.assign(_output_variables.begin(), _output_variables.end());
  es.build_elemental_data_variable_names(elemental_var_names, system_names);

  // Remove all names from var_names that are not in _output_variables.
  // Note: This approach avoids errors when the user provides invalid

      const std::string & orig_name = name_and_id.first;

      // Was the original name an elemental data variable?
      if (std::count(elemental_var_names.begin(),
                     elemental_var_names.end(),
                     orig_name))
        {

  {
    std::vector<std::string> derived_var_names_edited;
    std::vector<std::set<subdomain_id_type>> derived_vars_active_subdomains_edited;
    std::vector<unsigned int> found_first(elemental_var_names.size());

    for (auto i : index_range(derived_var_names))
      {

        // Determine whether we will keep this derived variable name in
        // the final container.
        bool keep = true;
        for (auto j : index_range(elemental_var_names))
          if (derived_var_name == elemental_var_names[j])
            {
              if (!found_first[j])
                found_first[j] = 1;

  if (var_nums.empty())
    {
      if (_verbose)
        libMesh::out << "No elemental data variables to be written." << std::endl;
      return;
    }

  const unsigned int var_num = system.variable_number(system_var_name);
  const auto & var_type = system.variable_type(var_num);
  libmesh_error_msg_if(!EquationSystems::is_elemental_data_fe_type(var_type) ||
                       FEInterface::field_type(var_type) == TYPE_VECTOR,
                       "Error! Trying to copy elemental solution into a variable that is not scalar elemental data.");

bool EquationSystems::is_elemental_data_fe_type (const FEType & type)
{
  return type.order == CONSTANT &&
         (type.family == MONOMIAL ||
          type.family == MONOMIAL_VEC ||
          type.family == XYZ);
}