Add writeable particle location reference

diff --git a/include/deal.II/particles/particle.h b/include/deal.II/particles/particle.h
index 776969dd99f6629dba75758e85f84e9d020010cc..600d6712935baba956c835af10791f57c099d730 100644 (file)
--- a/include/deal.II/particles/particle.h
+++ b/include/deal.II/particles/particle.h
@@ -250,6 +250,14 @@ namespace Particles
     const Point<spacedim> &
     get_location() const;
 
+    /**
+     * Get the location of this particle.
+     *
+     * @return The location of this particle.
+     */
+    Point<spacedim> &
+    get_location();
+
     /**
      * Set the reference location of this particle.
      *
@@ -279,6 +287,12 @@ namespace Particles
     const Point<dim> &
     get_reference_location() const;
 
+    /**
+     * Return the reference location of this particle in its current cell.
+     */
+    Point<dim> &
+    get_reference_location();
+
     /**
      * Return the ID number of this particle. The ID of a particle is intended
      * to be a property that is globally unique even in parallel computations
@@ -537,6 +551,15 @@ namespace Particles
 
 
 
+  template <int dim, int spacedim>
+  inline Point<spacedim> &
+  Particle<dim, spacedim>::get_location()
+  {
+    return property_pool->get_location(property_pool_handle);
+  }
+
+
+
   template <int dim, int spacedim>
   inline void
   Particle<dim, spacedim>::set_reference_location(const Point<dim> &new_loc)
@@ -555,6 +578,15 @@ namespace Particles
 
 
 
+  template <int dim, int spacedim>
+  inline Point<dim> &
+  Particle<dim, spacedim>::get_reference_location()
+  {
+    return property_pool->get_reference_location(property_pool_handle);
+  }
+
+
+
   template <int dim, int spacedim>
   inline types::particle_index
   Particle<dim, spacedim>::get_id() const

diff --git a/include/deal.II/particles/particle_accessor.h b/include/deal.II/particles/particle_accessor.h
index 67f3097842a9ce848ab4c2dc21148872790932ba..1bce933fe6be46fdae56ba36823c851ac9b322c7 100644 (file)
--- a/include/deal.II/particles/particle_accessor.h
+++ b/include/deal.II/particles/particle_accessor.h
@@ -156,6 +156,14 @@ namespace Particles
     const Point<spacedim> &
     get_location() const;
 
+    /**
+     * Get the location of this particle.
+     *
+     * @return The location of this particle.
+     */
+    Point<spacedim> &
+    get_location();
+
     /**
      * Set the reference location of this particle.
      *
@@ -185,6 +193,12 @@ namespace Particles
     const Point<dim> &
     get_reference_location() const;
 
+    /**
+     * Return the reference location of this particle in its current cell.
+     */
+    Point<dim> &
+    get_reference_location();
+
     /**
      * Set the ID number of this particle.
      */
@@ -650,6 +664,17 @@ namespace Particles
 
 
 
+  template <int dim, int spacedim>
+  inline Point<spacedim> &
+  ParticleAccessor<dim, spacedim>::get_location()
+  {
+    Assert(state() == IteratorState::valid, ExcInternalError());
+
+    return property_pool->get_location(get_handle());
+  }
+
+
+
   template <int dim, int spacedim>
   inline void
   ParticleAccessor<dim, spacedim>::set_reference_location(
@@ -673,6 +698,17 @@ namespace Particles
 
 
 
+  template <int dim, int spacedim>
+  inline Point<dim> &
+  ParticleAccessor<dim, spacedim>::get_reference_location()
+  {
+    Assert(state() == IteratorState::valid, ExcInternalError());
+
+    return property_pool->get_reference_location(get_handle());
+  }
+
+
+
   template <int dim, int spacedim>
   inline types::particle_index
   ParticleAccessor<dim, spacedim>::get_id() const

diff --git a/include/deal.II/particles/property_pool.h b/include/deal.II/particles/property_pool.h
index 5d3fd350a94eb605d641aafd4331d957b57c41a8..7131149956045df41c095d8bab0b4f4feba5e401 100644 (file)
--- a/include/deal.II/particles/property_pool.h
+++ b/include/deal.II/particles/property_pool.h
@@ -151,11 +151,19 @@ namespace Particles
     deregister_particle(Handle &handle);
 
     /**
-     * Return the location of a particle identified by the given `handle`.
+     * Return a read-only reference to the location of a particle
+     * identified by the given `handle`.
      */
     const Point<spacedim> &
     get_location(const Handle handle) const;
 
+    /**
+     * Return a writeable reference to the location of a particle
+     * identified by the given `handle`.
+     */
+    Point<spacedim> &
+    get_location(const Handle handle);
+
     /**
      * Set the location of a particle identified by the given `handle`.
      */
@@ -163,12 +171,19 @@ namespace Particles
     set_location(const Handle handle, const Point<spacedim> &new_location);
 
     /**
-     * Return the reference_location of a particle identified by the given
-     * `handle`.
+     * Return a read-only reference to the reference location of a particle
+     * identified by the given `handle`.
      */
     const Point<dim> &
     get_reference_location(const Handle handle) const;
 
+    /**
+     * Return a writeable reference to the reference location of a particle
+     * identified by the given `handle`.
+     */
+    Point<dim> &
+    get_reference_location(const Handle handle);
+
     /**
      * Set the reference location of a particle identified by the given
      * `handle`.
@@ -306,6 +321,29 @@ namespace Particles
 
 
 
+  template <int dim, int spacedim>
+  inline Point<spacedim> &
+  PropertyPool<dim, spacedim>::get_location(const Handle handle)
+  {
+    const std::vector<double>::size_type data_index =
+      (handle != invalid_handle) ? handle : 0;
+
+    // Ideally we would need to assert that 'handle' has not been deallocated
+    // by searching through 'currently_available_handles'. However, this
+    // is expensive and this function is performance critical, so instead
+    // just check against the array range, and rely on the fact
+    // that handles are invalidated when handed over to
+    // deallocate_properties_array().
+    Assert(data_index <= locations.size() - 1,
+           ExcMessage("Invalid location handle. This can happen if the "
+                      "handle was duplicated and then one copy was deallocated "
+                      "before trying to access the properties."));
+
+    return locations[data_index];
+  }
+
+
+
   template <int dim, int spacedim>
   inline void
   PropertyPool<dim, spacedim>::set_location(const Handle           handle,
@@ -353,6 +391,29 @@ namespace Particles
 
 
 
+  template <int dim, int spacedim>
+  inline Point<dim> &
+  PropertyPool<dim, spacedim>::get_reference_location(const Handle handle)
+  {
+    const std::vector<double>::size_type data_index =
+      (handle != invalid_handle) ? handle : 0;
+
+    // Ideally we would need to assert that 'handle' has not been deallocated
+    // by searching through 'currently_available_handles'. However, this
+    // is expensive and this function is performance critical, so instead
+    // just check against the array range, and rely on the fact
+    // that handles are invalidated when handed over to
+    // deallocate_properties_array().
+    Assert(data_index <= reference_locations.size() - 1,
+           ExcMessage("Invalid location handle. This can happen if the "
+                      "handle was duplicated and then one copy was deallocated "
+                      "before trying to access the properties."));
+
+    return reference_locations[data_index];
+  }
+
+
+
   template <int dim, int spacedim>
   inline void
   PropertyPool<dim, spacedim>::set_reference_location(