remove old file -- update builder -- use field class to access field data

bfps/cpp/field.hpp

@@ -134,6 +134,13 @@ class field
             return *(this->data + rindex*ncomp(fc) + component);
         }
 
+        inline const rnumber& rval(ptrdiff_t rindex, unsigned int component = 0) const
+        {
+            assert(fc == ONE || fc == THREE);
+            assert(component >= 0 && component < ncomp(fc));
+            return *(this->data + rindex*ncomp(fc) + component);
+        }
+
         inline rnumber &rval(ptrdiff_t rindex, int comp1, int comp0)
         {
             assert(fc == THREExTHREE);
@@ -242,6 +249,22 @@ class field
                      zindex)*this->clayout->subsizes[2] +
                     xindex);
         }
+
+        ptrdiff_t get_rindex(
+                ptrdiff_t xindex,
+                ptrdiff_t yindex,
+                ptrdiff_t zindex) const
+        {
+            return ((yindex*this->rmemlayout->subsizes[1] +
+                     zindex)*this->rmemlayout->subsizes[2] +
+                    xindex);
+        }
+
+        ptrdiff_t get_rindex_from_global(const ptrdiff_t in_global_x, const ptrdiff_t in_global_y, const ptrdiff_t in_global_z) const {
+            return get_rindex(in_global_x - this->rlayout->starts[2],
+                              in_global_y - this->rlayout->starts[1],
+                              in_global_z - this->rlayout->starts[0]);
+        }
 };
 
 template <typename rnumber,

bfps/cpp/particles/field_accessor.hpp

-#ifndef FIELD_ACCESSOR_HPP
-#define FIELD_ACCESSOR_HPP
-
-#include <algorithm>
-#include <array>
-
-#include "particles_utils.hpp"
-
-template <class real_number>
-class field_accessor {
-    static const int nb_dim = 3;
-
-    const real_number* field_date;
-    std::array<size_t,3> local_field_dims;
-    std::array<size_t,3> local_field_offset;
-    std::array<size_t,3> field_memory_dims;
-
-public:
-    field_accessor(const real_number* in_field_date, const std::array<size_t,3>& in_dims,
-                   const std::array<size_t,3>& in_local_field_offset,
-                   const std::array<size_t,3>& in_field_memory_dims)
-            : field_date(in_field_date), local_field_dims(in_dims),
-              local_field_offset(in_local_field_offset),
-              field_memory_dims(in_field_memory_dims){
-    }
-
-    ~field_accessor(){}
-
-    const real_number& getValue(const size_t in_index, const int in_dim) const {
-        assert(in_index < field_memory_dims[IDX_X]*field_memory_dims[IDX_Y]*field_memory_dims[IDX_Z]);
-        return field_date[in_index*nb_dim + in_dim];
-    }
-
-    size_t getIndexFromGlobalPosition(const size_t in_global_x, const size_t in_global_y, const size_t in_global_z) const {
-        return getIndexFromLocalPosition(in_global_x - local_field_offset[IDX_X],
-                                         in_global_y - local_field_offset[IDX_Y],
-                                         in_global_z - local_field_offset[IDX_Z]);
-    }
-
-    size_t getIndexFromLocalPosition(const size_t in_local_x, const size_t in_local_y, const size_t in_local_z) const {
-        assert(0 <= in_local_x && in_local_x < local_field_dims[IDX_X]);
-        assert(0 <= in_local_y && in_local_y < local_field_dims[IDX_Y]);
-        assert(0 <= in_local_z && in_local_z < local_field_dims[IDX_Z]);
-        return (((in_local_z)*field_memory_dims[IDX_Y] +
-                in_local_y)*(field_memory_dims[IDX_X]) +
-                in_local_x);
-    }
-};
-
-
-#endif

bfps/cpp/particles/particles_field_computer.hpp

@@ -132,12 +132,12 @@ class particles_field_computer : public abstract_particles_distr<partsize_t, rea
                                                     * by[idx_y-interp_limit_my]
                                                     * bx[idx_x-interp_limit_mx]);
 
-                            const ptrdiff_t tindex = field.getIndexFromGlobalPosition(idx_x_pbc, idx_y_pbc, idx_z_pbc);
+                            const ptrdiff_t tindex = field.get_rindex_from_global(idx_x_pbc, idx_y_pbc, idx_z_pbc);
 
                             // getValue does not necessary return real_number
-                            particles_current_rhs[idxPart*3+IDX_X] += real_number(field.getValue(tindex,IDX_X))*coef;
-                            particles_current_rhs[idxPart*3+IDX_Y] += real_number(field.getValue(tindex,IDX_Y))*coef;
-                            particles_current_rhs[idxPart*3+IDX_Z] += real_number(field.getValue(tindex,IDX_Z))*coef;
+                            particles_current_rhs[idxPart*3+IDX_X] += real_number(field.rval(tindex,IDX_X))*coef;
+                            particles_current_rhs[idxPart*3+IDX_Y] += real_number(field.rval(tindex,IDX_Y))*coef;
+                            particles_current_rhs[idxPart*3+IDX_Z] += real_number(field.rval(tindex,IDX_Z))*coef;
                         }
                     }
                 }

bfps/cpp/particles/particles_system.hpp

@@ -7,23 +7,20 @@
 #include "particles_output_hdf5.hpp"
 #include "particles_output_mpiio.hpp"
 #include "particles_field_computer.hpp"
-#include "field_accessor.hpp"
 #include "abstract_particles_input.hpp"
 #include "particles_adams_bashforth.hpp"
 #include "scope_timer.hpp"
 
-template <class partsize_t, class real_number, class field_rnumber, class interpolator_class, int interp_neighbours>
+template <class partsize_t, class real_number, class field_rnumber, class field_class, class interpolator_class, int interp_neighbours>
 class particles_system : public abstract_particles_system<partsize_t, real_number> {
     MPI_Comm mpi_com;
 
     const std::pair<int,int> current_partition_interval;
     const int partition_interval_size;
 
-    field_accessor<field_rnumber> field;
-
     interpolator_class interpolator;
 
-    particles_field_computer<partsize_t, real_number, interpolator_class, field_accessor<field_rnumber>, interp_neighbours, particles_adams_bashforth<partsize_t, real_number, 3,3>> computer;
+    particles_field_computer<partsize_t, real_number, interpolator_class, field_class, interp_neighbours, particles_adams_bashforth<partsize_t, real_number, 3,3>> computer;
 
     std::unique_ptr<partsize_t[]> current_my_nb_particles_per_partition;
     std::unique_ptr<partsize_t[]> current_offset_particles_for_partition;
@@ -45,18 +42,17 @@ public:
                      const std::array<real_number,3>& in_spatial_box_offset,
                      const std::array<real_number,3>& in_spatial_partition_width,
                      const real_number in_my_spatial_low_limit, const real_number in_my_spatial_up_limit,
-                     const field_rnumber* in_field_data, const std::array<size_t,3>& in_local_field_dims,
+                     const std::array<size_t,3>& in_local_field_dims,
                      const std::array<size_t,3>& in_local_field_offset,
-                     const std::array<size_t,3>& in_field_memory_dims,
+                     const field_class& in_field,
                      MPI_Comm in_mpi_com,
                      const int in_current_iteration = 1)
         : mpi_com(in_mpi_com),
           current_partition_interval({in_local_field_offset[IDX_Z], in_local_field_offset[IDX_Z] + in_local_field_dims[IDX_Z]}),
           partition_interval_size(current_partition_interval.second - current_partition_interval.first),
-          field(in_field_data, in_local_field_dims, in_local_field_offset, in_field_memory_dims),
           interpolator(),
           computer(in_mpi_com, field_grid_dim, current_partition_interval,
-                   interpolator, field, in_spatial_box_width, in_spatial_box_offset, in_spatial_partition_width),
+                   interpolator, in_field, in_spatial_box_width, in_spatial_box_offset, in_spatial_partition_width),
           spatial_box_width(in_spatial_box_width), spatial_partition_width(in_spatial_partition_width),
           my_spatial_low_limit(in_my_spatial_low_limit), my_spatial_up_limit(in_my_spatial_up_limit),
           my_nb_particles(0), step_idx(in_current_iteration){

bfps/cpp/particles/particles_system_builder.hpp

@@ -170,12 +170,6 @@ struct particles_system_build_container {
                    || (my_rank != nb_processes_involved-1 && local_field_offset[IDX_Z]+local_field_dims[IDX_Z] != field_grid_dim[IDX_Z])));
         }
 
-        // The offset of the local field grid
-        std::array<size_t,3> local_field_mem_size;
-        local_field_mem_size[IDX_X] = fs_field->rmemlayout->subsizes[FIELD_IDX_X];
-        local_field_mem_size[IDX_Y] = fs_field->rmemlayout->subsizes[FIELD_IDX_Y];
-        local_field_mem_size[IDX_Z] = fs_field->rmemlayout->subsizes[FIELD_IDX_Z];
-
         // The spatial box size (all particles should be included inside)
         std::array<particles_rnumber,3> spatial_box_width;
         spatial_box_width[IDX_X] = 4 * acos(0) / (fs_kk->dkx);
@@ -198,17 +192,16 @@ struct particles_system_build_container {
         const particles_rnumber my_spatial_up_limit_z = particles_rnumber(local_field_offset[IDX_Z]+local_field_dims[IDX_Z])*spatial_partition_width[IDX_Z];
 
         // Create the particles system
-        particles_system<partsize_t, particles_rnumber, field_rnumber, particles_interp_spline<particles_rnumber, interpolation_size,spline_mode>, interpolation_size>* part_sys
-         = new particles_system<partsize_t, particles_rnumber, field_rnumber, particles_interp_spline<particles_rnumber, interpolation_size,spline_mode>, interpolation_size>(field_grid_dim,
+        particles_system<partsize_t, particles_rnumber, field_rnumber, field<field_rnumber, be, THREE>, particles_interp_spline<particles_rnumber, interpolation_size,spline_mode>, interpolation_size>* part_sys
+         = new particles_system<partsize_t, particles_rnumber, field_rnumber, field<field_rnumber, be, THREE>, particles_interp_spline<particles_rnumber, interpolation_size,spline_mode>, interpolation_size>(field_grid_dim,
                                                                                                    spatial_box_width,
                                                                                                    spatial_box_offset,
                                                                                                    spatial_partition_width,
                                                                                                    my_spatial_low_limit_z,
                                                                                                    my_spatial_up_limit_z,
-                                                                                                   fs_field->get_rdata(),
                                                                                                    local_field_dims,
                                                                                                    local_field_offset,
-                                                                                                   local_field_mem_size,
+                                                                                                   (*fs_field),
                                                                                                    mpi_comm,
                                                                                                    in_current_iteration);
 

setup.py

@@ -126,7 +126,6 @@ particle_headers = [
         'cpp/particles/abstract_particles_output.hpp',
         'cpp/particles/abstract_particles_system.hpp',
         'cpp/particles/alltoall_exchanger.hpp',
-        'cpp/particles/field_accessor.hpp',
         'cpp/particles/particles_adams_bashforth.hpp',
         'cpp/particles/particles_field_computer.hpp',
         'cpp/particles/particles_input_hdf5.hpp',