rhs computer cleans up arrays before interpolation

cpp/particles/interpolation/particle_set.hpp

@@ -215,6 +215,8 @@ class particle_set: public abstract_particle_set
         int template_sample(const field<field_rnumber, be, fc> &field_to_sample,
                    particle_rnumber *result)
         {
+            // attention: compute_distr adds result on top of existing values.
+            // please clean up result as appropriate before call.
             this->pdistributor.template compute_distr<interpolator_class,
                                                       field<field_rnumber, be, fc>,
                                                       state_size,
@@ -283,13 +285,6 @@ class particle_set: public abstract_particle_set
             this->local_index = particles_input.getMyParticlesIndexes();
             this->local_number_of_particles = particles_input.getLocalNbParticles();
 
-            for (partsize_t idx=0; idx < this->local_number_of_particles; idx++)
-            {
-                DEBUG_MSG_WAIT(this->mpi_comm, "idx = %d, z = %g\n",
-                        this->local_index[idx],
-                        this->local_state[idx*state_size+2]);
-            }
-
             particles_utils::partition_extra_z<partsize_t, state_size>(
                     &this->local_state[0],
                     this->local_number_of_particles,
@@ -298,9 +293,6 @@ class particle_set: public abstract_particle_set
                     this->offset_particles_for_partition.get(),
                     [&](const particle_rnumber& z_pos){
                         const int partition_level = this->pinterpolator.pbc_field_layer(z_pos, IDXC_Z);
-                        DEBUG_MSG("z_pos = %g, partition_level is %d\n",
-                                z_pos,
-                                partition_level);
                         assert(current_partition_interval.first <= partition_level && partition_level < current_partition_interval.second);
                         return partition_level - current_partition_interval.first;
                     },

cpp/particles/particles_distr_mpi.hpp

@@ -182,10 +182,6 @@ public:
         partsize_t myTotalNbParticles = 0;
         for(int idxPartition = 0 ; idxPartition < current_partition_size ; ++idxPartition){
             myTotalNbParticles += current_my_nb_particles_per_partition[idxPartition];
-            DEBUG_MSG("idxPartition = %d, current_offset_particles_for_partition = %d, current_my_nb_particles_per_partition = %d\n",
-                    idxPartition,
-                    current_offset_particles_for_partition[idxPartition],
-                    current_my_nb_particles_per_partition[idxPartition]);
             current_offset_particles_for_partition[idxPartition+1] = current_offset_particles_for_partition[idxPartition] + current_my_nb_particles_per_partition[idxPartition];
         }
 
@@ -215,8 +211,6 @@ public:
 
                 const int nbPartitionsToSend = std::min(current_partition_size, interpolation_size-(idxLower-1));
                 assert(nbPartitionsToSend >= 0);
-                DEBUG_MSG("idxLower = %d, nbPartitionsToSend = %d, current_offset_particles_for_partition = %d, current_offset_particles_for_partition[0] = %d\n",
-                        idxLower, nbPartitionsToSend, current_offset_particles_for_partition[nbPartitionsToSend], current_offset_particles_for_partition[0]);
                 const partsize_t nbParticlesToSend = current_offset_particles_for_partition[nbPartitionsToSend] - current_offset_particles_for_partition[0];
                 assert(nbParticlesToSend >= 0);
 
@@ -565,11 +559,6 @@ public:
                 for(partsize_t idx = 0 ; idx < current_my_nb_particles_per_partition[idxPartition] ; ++idx){
                     const int partition_level = in_computer.pbc_field_layer((*inout_positions_particles)[(idx+partOffset)*size_particle_positions+IDXC_Z], IDXC_Z);
                     variable_used_only_in_assert(partition_level);
-                    DEBUG_MSG("partition_level = %d, current_parition_interval.first = %d, idxPartition = %d\n",
-                              partition_level,
-                              current_partition_interval.first,
-                              idxPartition
-                            );
                     assert(partition_level == current_partition_interval.first + idxPartition
                            || partition_level == (current_partition_interval.first + idxPartition-1+int(field_grid_dim[IDXC_Z]))%int(field_grid_dim[IDXC_Z])
                            || partition_level == (current_partition_interval.first + idxPartition+1)%int(field_grid_dim[IDXC_Z]));

cpp/particles/particles_input_random.hpp

@@ -99,7 +99,6 @@ class particles_input_random: public abstract_particles_input<partsize_t, partic
                 for (int cc=0; cc < 2; cc++)
                     this->local_particle_state[idx*state_size + cc] = twopi*udist(rgen);
                 this->local_particle_state[idx*state_size + 2] = uzdist(rgen);
-                DEBUG_MSG("zpos = %g\n", this->local_particle_state[idx*state_size + 2]);
                 for (int cc = 3; cc < state_size; cc++)
                     this->local_particle_state[idx*state_size + cc] = gdist(rgen);
             }

cpp/particles/rhs/tracer_rhs.hpp

@@ -54,6 +54,8 @@ class tracer_rhs: public abstract_particle_rhs
                 abstract_particle_set &pset,
                 particle_rnumber *result) const
         {
+            // interpolation adds on top of existing values, so result must be cleared.
+            std::fill_n(result, pset.getLocalNumberOfParticles()*3, 0);
             return (*(this->velocity))(t, pset, result);
         }
 };