Add/use DofObject::old_dof_object accessors

* Decided to call the pointer-returning version get_old_dof_object() and the
  reference-returning version get_old_dof_object_ref() for brevity.
* Use old_dof_object accessors in dof_map.C
* Use old_dof_object accessors in system_projection.C

Author: jwpeterson

include/base/dof_object.h

@@ -80,6 +80,31 @@ class DofObject : public ReferenceCountedObject<DofObject>
    */
   std::unique_ptr<DofObject> old_dof_object;
 
+  /**
+   * Pointer accessor for previously public old_dof_object. If you
+   * want to assert that the old_dof_object pointer is valid as well,
+   * consider using the get_old_dof_object_ref() accessor instead.
+   */
+  DofObject * get_old_dof_object() { return old_dof_object.get(); }
+  const DofObject * get_old_dof_object() const  { return old_dof_object.get(); }
+
+  /**
+   * As above, but do not use in situations where the old_dof_object
+   * may be nullptr, since this function asserts that the
+   * old_dof_object is valid before returning a reference to it.
+   */
+  DofObject & get_old_dof_object_ref()
+  {
+    libmesh_assert(old_dof_object);
+    return *old_dof_object;
+  }
+
+  const DofObject & get_old_dof_object_ref() const
+  {
+    libmesh_assert(old_dof_object);
+    return *old_dof_object;
+  }
+
   /**
    * Sets the \p old_dof_object to nullptr
    */

include/systems/generic_projector.h

@@ -887,24 +887,23 @@ class OldSolutionValue : public OldSolutionBase<Output, point_output>
     // zero.
     if (nc != 0)
       {
-        const DofObject *old_dof_object = old_elem.old_dof_object.get();
-        libmesh_assert(old_dof_object);
+        const DofObject & old_dof_object = old_elem.get_old_dof_object_ref();
         libmesh_assert_greater(elem.n_systems(), sys_num);
 
         const std::pair<unsigned int, unsigned int>
           vg_and_offset = elem.var_to_vg_and_offset(sys_num,var_num);
         const unsigned int vg = vg_and_offset.first;
         const unsigned int vig = vg_and_offset.second;
 
-        unsigned int n_comp = old_dof_object->n_comp_group(sys_num,vg);
+        unsigned int n_comp = old_dof_object.n_comp_group(sys_num,vg);
         n_comp = std::min(n_comp, nc);
 
         std::vector<dof_id_type> old_dof_indices(n_comp);
 
         for (unsigned int i=0; i != n_comp; ++i)
           {
             const dof_id_type d_old =
-              old_dof_object->dof_number(sys_num, vg, vig, i, n_comp);
+              old_dof_object.dof_number(sys_num, vg, vig, i, n_comp);
             const dof_id_type d_new =
               elem.dof_number(sys_num, vg, vig, i, n_comp);
             libmesh_assert_not_equal_to (d_old, DofObject::invalid_id);

src/base/dof_map.C

@@ -2260,9 +2260,8 @@ void DofMap::old_dof_indices (const Elem & elem,
                               std::vector<dof_id_type> & di,
                               const unsigned int vn) const
 {
-  const DofObject * old_obj = elem.node_ref(n).old_dof_object.get();
-  libmesh_assert(old_obj);
-  this->_node_dof_indices(elem, n, *old_obj, di, vn);
+  const DofObject & old_obj = elem.node_ref(n).get_old_dof_object_ref();
+  this->_node_dof_indices(elem, n, old_obj, di, vn);
 }
 
 #endif // LIBMESH_ENABLE_AMR
@@ -2687,8 +2686,7 @@ void DofMap::old_dof_indices (const Elem * const elem,
                     for (unsigned int n=0; n<n_nodes; n++)
                       {
                         const Node * node = nodes_ptr[n];
-                        const DofObject * old_dof_obj = node->old_dof_object.get();
-                        libmesh_assert(old_dof_obj);
+                        const DofObject & old_dof_obj = node->get_old_dof_object_ref();
 
                         // There is a potential problem with h refinement.  Imagine a
                         // quad9 that has a linear FE on it.  Then, on the hanging side,
@@ -2701,7 +2699,7 @@ void DofMap::old_dof_indices (const Elem * const elem,
 #endif
                           ndan (type, static_cast<Order>(var.type().order + extra_order), n);
 
-                        const int n_comp = old_dof_obj->n_comp_group(sys_num,vg);
+                        const int n_comp = old_dof_obj.n_comp_group(sys_num,vg);
 
                         // If this is a non-vertex on a hanging node with extra
                         // degrees of freedom, we use the non-vertex dofs (which
@@ -2724,7 +2722,7 @@ void DofMap::old_dof_indices (const Elem * const elem,
                               for (int i=n_comp-1; i>=dof_offset; i--)
                                 {
                                   const dof_id_type d =
-                                    old_dof_obj->dof_number(sys_num, vg, vig, i, n_comp);
+                                    old_dof_obj.dof_number(sys_num, vg, vig, i, n_comp);
 
                                   // On a newly-expanded subdomain, we
                                   // may have some DoFs that didn't
@@ -2748,7 +2746,7 @@ void DofMap::old_dof_indices (const Elem * const elem,
                             for (unsigned int i=0; i != old_nc; ++i)
                               {
                                 const dof_id_type d =
-                                  old_dof_obj->dof_number(sys_num, vg, vig, i, n_comp);
+                                  old_dof_obj.dof_number(sys_num, vg, vig, i, n_comp);
 
                                 libmesh_assert_not_equal_to (d, DofObject::invalid_id);
 
@@ -2765,20 +2763,19 @@ void DofMap::old_dof_indices (const Elem * const elem,
 
                     if (nc != 0)
                       {
-                        const DofObject * old_dof_obj = elem->old_dof_object.get();
-                        libmesh_assert(old_dof_obj);
+                        const DofObject & old_dof_obj = elem->get_old_dof_object_ref();
 
                         const unsigned int n_comp =
-                          old_dof_obj->n_comp_group(sys_num,vg);
+                          old_dof_obj.n_comp_group(sys_num,vg);
 
-                        if (old_dof_obj->n_systems() > sys_num &&
+                        if (old_dof_obj.n_systems() > sys_num &&
                             nc <= n_comp)
                           {
 
                             for (unsigned int i=0; i<nc; i++)
                               {
                                 const dof_id_type d =
-                                  old_dof_obj->dof_number(sys_num, vg, vig, i, n_comp);
+                                  old_dof_obj.dof_number(sys_num, vg, vig, i, n_comp);
 
                                 di.push_back(d);
                               }

src/base/dof_object.C

@@ -81,7 +81,7 @@ DofObject & DofObject::operator= (const DofObject & dof_obj)
 
 #ifdef LIBMESH_ENABLE_AMR
   this->clear_old_dof_object();
-  this->old_dof_object = this->construct(dof_obj.old_dof_object.get());
+  this->old_dof_object = this->construct(dof_obj.get_old_dof_object());
 #endif
 
   _id           = dof_obj._id;

src/systems/system_projection.C

@@ -1379,7 +1379,7 @@ void BuildProjectionList::operator()(const ConstElemRange & range)
 
           for (auto & node : elem->node_ref_range())
             {
-              const DofObject * old_dofs = node.old_dof_object.get();
+              const DofObject * old_dofs = node.get_old_dof_object();
 
               if (old_dofs)
                 {