Replace lfp_factors unordered_map with flat arrays (#3781)

Replace `CellMapping::lfp_factors` (`std::unordered_map<int, std::vector<double>>`) with two flat contiguous vectors:
- `lfp_segment_ids`: segment IDs (one per compartment)
- `lfp_factors_flat`: all electrode weights in a single allocation (stride = num_electrodes)

Additionally:
- `num_electrodes()` is now derived from the arrays (`lfp_factors_flat.size() / lfp_segment_ids.size()`) — no stored member needed
- `add_segment_lfp_factor()` validates stride consistency on every insertion (mismatched factor count → abort with clear error)
- Renamed `to_report` → `electrode_outputs` in `lfp_calc` for clarity

## Motivation

The unordered_map was never used for random O(1) lookup in the hot path — `lfp_calc` iterates ALL entries sequentially. The hash map introduces:
- ~84 bytes overhead per entry (bucket + inner vector header + heap allocation)
- Pointer chasing and scattered memory in the hot path
- ~3x more memory than needed

The flat layout matches the actual access pattern: sequential iteration with a constant stride.

## Changes

- `nrnsection_mapping.hpp`:
  - Replace `unordered_map<int, vector<double>>` with `vector<int>` + `vector<double>`
  - `num_electrodes()` returns `size_t`, derived from array sizes
  - `add_segment_lfp_factor()` validates stride consistency, returns early on empty factors
- `report_event.cpp`:
  - `lfp_calc` uses index-based iteration over flat arrays
  - Uses `size_t` for loop indices, `const auto` for locals
  - Renamed `to_report` → `electrode_outputs`
- `test/coreneuron/unit/lfp/lfp.cpp`: Update assertion to use `lfp_segment_ids.size()`

## Testing

- nrn `ctest -R lfp` passes
- neurodamus `tox -m local` passes (all envs including scientific LFP tests)
- No behavioral change — purely internal data structure swap
- The `add_segment_lfp_factor` API is unchanged (same signature), so no changes needed in callers

Author: cattabiani

src/coreneuron/io/nrn_filehandler.hpp

@@ -144,20 +144,16 @@ class FileHandler {
                 lfp_factors = read_vector<double>(total_lfp_factors);
             }
 
-            int factor_offset = 0;
             for (int i = 0; i < nseg; i++) {
                 mapinfo->add_segment(sec[i], seg[i]);
                 ntmapping->add_segment_id(seg[i]);
-                int factor_offset = i * num_electrodes;
                 if (total_lfp_factors > 0) {
                     // Abort if the factors contains a NaN
                     nrn_assert(count_if(lfp_factors.begin(), lfp_factors.end(), [](double d) {
                                    return std::isnan(d);
                                }) == 0);
-                    std::vector<double> segment_factors(lfp_factors.begin() + factor_offset,
-                                                        lfp_factors.begin() + factor_offset +
-                                                            num_electrodes);
-                    cmap->add_segment_lfp_factor(seg[i], segment_factors);
+                    auto begin = lfp_factors.begin() + i * num_electrodes;
+                    cmap->add_segment_lfp_factor(seg[i], begin, begin + num_electrodes);
                 }
             }
         }

src/coreneuron/io/nrnsection_mapping.hpp

@@ -18,6 +18,7 @@
 #include <vector>
 
 #include "coreneuron/io/reports/nrnreport.hpp"
+#include "coreneuron/utils/nrn_assert.h"
 #include "coreneuron/utils/utils.hpp"
 
 namespace coreneuron {
@@ -73,8 +74,11 @@ struct CellMapping {
     /** list of section lists (like soma, axon, apic) */
     std::vector<std::shared_ptr<SecMapping>> sec_mappings;
 
-    /** map containing segment ids an its respective lfp factors */
-    std::unordered_map<int, std::vector<double>> lfp_factors;
+    /** segment ids for lfp factors (one per compartment with LFP data) */
+    std::vector<int> lfp_segment_ids;
+
+    /** flat array of lfp factors: stride = num_electrodes, indexed as [i * stride + e] */
+    std::vector<double> lfp_factors_flat;
 
     CellMapping(int g)
         : gid(g) {}
@@ -99,13 +103,9 @@ struct CellMapping {
                                });
     }
 
-    /** @brief return the number of electrodes in the lfp_factors map **/
-    int num_electrodes() const {
-        int num_electrodes = 0;
-        if (!lfp_factors.empty()) {
-            num_electrodes = lfp_factors.begin()->second.size();
-        }
-        return num_electrodes;
+    /** @brief return the number of electrodes per segment **/
+    size_t num_electrodes() const {
+        return lfp_segment_ids.empty() ? 0 : lfp_factors_flat.size() / lfp_segment_ids.size();
     }
 
     /** @brief number of section lists */
@@ -148,8 +148,18 @@ struct CellMapping {
     }
 
     /** @brief add the lfp electrode factors of a segment_id */
-    void add_segment_lfp_factor(const int segment_id, std::vector<double>& factors) {
-        lfp_factors.insert({segment_id, factors});
+    void add_segment_lfp_factor(const int segment_id,
+                                std::vector<double>::const_iterator begin,
+                                std::vector<double>::const_iterator end) {
+        const size_t n = std::distance(begin, end);
+        if (n == 0) {
+            return;
+        }
+        const auto curr_n_electrodes = num_electrodes();
+        // All segments must have the same number of electrode factors
+        nrn_assert(curr_n_electrodes == 0 || n == curr_n_electrodes);
+        lfp_segment_ids.push_back(segment_id);
+        lfp_factors_flat.insert(lfp_factors_flat.end(), begin, end);
     }
 };
 

src/coreneuron/io/phase3.cpp

@@ -83,16 +83,13 @@ void Phase3::read_direct(NrnThreadMappingInfo* ntmapping, const NrnThread& nt) {
             for (int i_seg = 0; i_seg < n_seg; i_seg++) {
                 smap->add_segment(data_sec[i_seg], data_seg[i_seg]);
                 ntmapping->add_segment_id(data_seg[i_seg]);
-                int factor_offset = i_seg * n_electrodes;
                 if (total_lfp_factors > 0) {
                     // Abort if the factors contains a NaN
                     nrn_assert(count_if(data_lfp.begin(), data_lfp.end(), [](double d) {
                                    return std::isnan(d);
                                }) == 0);
-                    std::vector<double> segment_factors(data_lfp.begin() + factor_offset,
-                                                        data_lfp.begin() + factor_offset +
-                                                            n_electrodes);
-                    cmap->add_segment_lfp_factor(data_seg[i_seg], segment_factors);
+                    auto begin = data_lfp.begin() + i_seg * n_electrodes;
+                    cmap->add_segment_lfp_factor(data_seg[i_seg], begin, begin + n_electrodes);
                 }
             }
             cmap->add_sec_map(smap);

src/coreneuron/io/reports/report_event.cpp

@@ -7,6 +7,9 @@
 */
 
 #include "report_event.hpp"
+
+#include <numeric>
+
 #include "coreneuron/sim/multicore.hpp"
 #include "coreneuron/io/reports/nrnreport.hpp"
 #include "coreneuron/utils/nrn_assert.h"
@@ -77,33 +80,44 @@ void ReportEvent::summation_alu(NrnThread* nt) {
     }
 }
 
+/** @brief Compute Local Field Potentials (LFP) for each cell.
+ *
+ * For every segment of a cell, computes the total membrane current (imem + iclamp)
+ * and accumulates the weighted contribution to each electrode using precomputed
+ * transfer factors. Results are written into the report output buffers.
+ */
 void ReportEvent::lfp_calc(NrnThread* nt) {
     auto* mapinfo = static_cast<NrnThreadMappingInfo*>(nt->mapping);
     double* fast_imem_rhs = nt->nrn_fast_imem->nrn_sav_rhs;
     auto& summation_report = nt->summation_report_handler_->summation_reports_[report_path];
     for (const auto& kv: vars_to_report) {
         int gid = kv.first;
-        const auto& to_report = kv.second;
+        const auto& electrode_outputs = kv.second;
         const auto& cell_mapping = mapinfo->get_cell_mapping(gid);
-        int num_electrodes = cell_mapping->num_electrodes();
-        std::vector<double> lfp_values(num_electrodes, 0.0);
-        for (const auto& kv: cell_mapping->lfp_factors) {
-            int segment_id = kv.first;
-            const auto& factors = kv.second;
-            int electrode_id = 0;
-            for (const auto& factor: factors) {
-                double iclamp = 0.0;
-                for (const auto& value: summation_report.currents_[segment_id]) {
-                    double current_value = *value.first;
-                    int scale = value.second;
-                    iclamp += current_value * scale;
-                }
-                lfp_values[electrode_id] += (fast_imem_rhs[segment_id] + iclamp) * factor;
-                electrode_id++;
+        const auto n_electrodes = cell_mapping->num_electrodes();
+        const auto n_segments = cell_mapping->lfp_segment_ids.size();
+        std::vector<double> lfp_values(n_electrodes, 0.0);
+        for (size_t i = 0; i < n_segments; i++) {
+            const auto segment_id = cell_mapping->lfp_segment_ids[i];
+
+            // compute imem + iclamp
+            const double imem = std::accumulate(summation_report.currents_[segment_id].begin(),
+                                                summation_report.currents_[segment_id].end(),
+                                                fast_imem_rhs[segment_id],
+                                                [](double sum, const auto& value) {
+                                                    return sum + *value.first * value.second;
+                                                });
+
+            // dot product with the factors
+            const double* factors = &cell_mapping->lfp_factors_flat[i * n_electrodes];
+            for (size_t e = 0; e < n_electrodes; e++) {
+                lfp_values[e] += imem * factors[e];
             }
         }
-        for (int i = 0; i < to_report.size(); i++) {
-            *(to_report[i].var_value) = lfp_values[i];
+
+        // write LFP values to report output buffers
+        for (size_t e = 0; e < electrode_outputs.size(); e++) {
+            *(electrode_outputs[e].var_value) = lfp_values[e];
         }
     }
 }

test/coreneuron/unit/lfp/lfp.cpp

@@ -131,15 +131,15 @@ TEST_CASE("LFP_ReportEvent") {
         mapinfo->add_cell_mapping(cmap);
         for (const auto& segment: segment_ids) {
             std::vector<double> lfp_factors{segment + 1.0, segment + 2.0};
-            cmap->add_segment_lfp_factor(segment, lfp_factors);
+            cmap->add_segment_lfp_factor(segment, lfp_factors.begin(), lfp_factors.end());
         }
     }
     mapinfo->prepare_lfp();
     // Total number of electrodes 2 gids * 2 factors
 
     auto c42 = mapinfo->get_cell_mapping(42);
     auto c134 = mapinfo->get_cell_mapping(134);
-    REQUIRE(c42->lfp_factors.size() == 5);
+    REQUIRE(c42->lfp_segment_ids.size() == 5);
     REQUIRE(c134->num_electrodes() == 2);
 
     // Pass _lfp variable to vars_to_report