corenrn permute for reports (#3587)

### Context

Until now, corenrn reports were not really addressing corenrn permutations. They were not tested too since cell_permute is hardcoded to 0 in neurodamus. 

### Scope

This small pr fixes this to the root (where possible). 
- `compartment sets report`: in this case the report passes manually the node indexes. At the loading moment `NrnThread` is empty and I cannot do the node conversion on the spot (@nrnhines if you know of a better way I would actually prefer to permute immediately, when I load this file. I mean in `report_configuration_parser.cpp`. Let me know if you want a zoom call). For this reason the permutation is done in `get_compartment_set_vars_to_report`
- **all the other reports**: use `cell_mapping`. We apply the permutation as soon as we load the indexes in memory thus nobody can uses stale values. This is done largely in `phase3.cpp`. 

### Tests

This was already successfully tested manually in neurodamus for all the reports (lfp included). 

- [ ] run tests with cell_permute 1 once the option can be passed to neurodamus 

### Note

This pr does not block nor is blocked by the neurodamus side. Current neurodamus has hardcoded `cell_permute = 0` and this pr should not change anything if cell_permute is 0

Author: cattabiani

src/coreneuron/io/nrn_filehandler.hpp

@@ -14,8 +14,10 @@
 #include <cmath>
 #include <sys/stat.h>
 
-#include "coreneuron/utils/nrn_assert.h"
 #include "coreneuron/io/nrnsection_mapping.hpp"
+#include "coreneuron/permute/node_permute.h"
+#include "coreneuron/sim/multicore.hpp"
+#include "coreneuron/utils/nrn_assert.h"
 
 namespace coreneuron {
 /** Encapsulate low-level reading of coreneuron input data files.
@@ -114,7 +116,8 @@ class FileHandler {
     template <typename T>
     int read_mapping_info(T mapinfo,
                           NrnThreadMappingInfo* ntmapping,
-                          std::shared_ptr<CellMapping> cmap) {
+                          std::shared_ptr<CellMapping> cmap,
+                          const NrnThread& nt) {
         int nsec, nseg, n_scan;
         size_t total_lfp_factors;
         int num_electrodes;
@@ -132,6 +135,10 @@ class FileHandler {
             auto sec = read_vector<int>(nseg);
             auto seg = read_vector<int>(nseg);
 
+            if (nt._permute) {
+                node_permute(seg.data(), seg.size(), nt._permute);
+            }
+
             std::vector<double> lfp_factors;
             if (total_lfp_factors > 0) {
                 lfp_factors = read_vector<double>(total_lfp_factors);

src/coreneuron/io/nrn_setup.cpp

@@ -944,11 +944,11 @@ void read_phase3(NrnThread& nt, UserParams& userParams) {
 
     Phase3 p3;
     if (corenrn_embedded && !corenrn_file_mode) {
-        p3.read_direct(ntmapping);
+        p3.read_direct(ntmapping, nt);
     } else {
         auto& F = userParams.file_reader[nt.id];
         F.restore_checkpoint();
-        p3.read_file(F, ntmapping);
+        p3.read_file(F, ntmapping, nt);
     }
 
     // make number #cells match with mapping size

src/coreneuron/io/phase3.cpp

@@ -26,7 +26,7 @@ void (*nrn2core_get_dat3_secmapping_)(int i_c,
                                       std::vector<double>& data_lfp);
 
 namespace coreneuron {
-void Phase3::read_file(FileHandler& F, NrnThreadMappingInfo* ntmapping) {
+void Phase3::read_file(FileHandler& F, NrnThreadMappingInfo* ntmapping, const NrnThread& nt) {
     int count = 0;
     F.read_mapping_cell_count(&count);
     /** for every neuron */
@@ -38,14 +38,14 @@ void Phase3::read_file(FileHandler& F, NrnThreadMappingInfo* ntmapping) {
         // read section-segment mapping for every section list
         for (int j = 0; j < nseclist; j++) {
             auto smap = std::make_shared<SecMapping>();
-            F.read_mapping_info(smap, ntmapping, cmap);
+            F.read_mapping_info(smap, ntmapping, cmap, nt);
             cmap->add_sec_map(smap);
         }
         ntmapping->add_cell_mapping(cmap);
     }
 }
 
-void Phase3::read_direct(NrnThreadMappingInfo* ntmapping) {
+void Phase3::read_direct(NrnThreadMappingInfo* ntmapping, const NrnThread& nt) {
     int count;
     nrn2core_get_dat3_cell_count_(count);
     /** for every neuron */
@@ -75,6 +75,9 @@ void Phase3::read_direct(NrnThreadMappingInfo* ntmapping) {
                                           data_sec,
                                           data_seg,
                                           data_lfp);
+            if (nt._permute) {
+                node_permute(data_seg.data(), data_seg.size(), nt._permute);
+            }
             auto smap = std::make_shared<SecMapping>();
             smap->type = section_type_from_string(sclname);
             for (int i_seg = 0; i_seg < n_seg; i_seg++) {

src/coreneuron/io/phase3.hpp

@@ -9,13 +9,15 @@
 #pragma once
 
 #include "coreneuron/io/nrn_filehandler.hpp"
+#include "coreneuron/sim/multicore.hpp"
+
 
 namespace coreneuron {
 struct NrnThreadMappingInfo;
 
 class Phase3 {
   public:
-    void read_file(FileHandler& F, NrnThreadMappingInfo* ntmapping);
-    void read_direct(NrnThreadMappingInfo* ntmapping);
+    void read_file(FileHandler& F, NrnThreadMappingInfo* ntmapping, const NrnThread& nt);
+    void read_direct(NrnThreadMappingInfo* ntmapping, const NrnThread& nt);
 };
 }  // namespace coreneuron

src/coreneuron/io/reports/report_handler.cpp

@@ -11,6 +11,7 @@
 #include "report_handler.hpp"
 #include "coreneuron/io/nrnsection_mapping.hpp"
 #include "coreneuron/mechanism/mech_mapping.hpp"
+#include "coreneuron/permute/node_permute.h"
 #include "coreneuron/utils/utils.hpp"
 
 namespace coreneuron {
@@ -371,7 +372,11 @@ static VarsToReport get_compartment_set_vars_to_report(const NrnThread& nt,
     for (const auto& intersection_id: intersection_ids) {
         const auto gid = report.target[intersection_id];
         const auto section_id = report.point_section_ids[intersection_id];
-        const auto compartment_id = report.point_compartment_ids[intersection_id];
+        auto compartment_id = report.point_compartment_ids[intersection_id];
+        if (nt._permute) {
+            node_permute(&compartment_id, 1, nt._permute);
+        }
+
         if (old_gid != gid) {
             // clear cache for new gid. We know they are strictly ordered
             segment_id_2_node_id.clear();