Refactor reporting config file reading (#431)

* Refactor reporting config file reading
* Use ifstream to read directly
* Fix compilation issues in OSX

Co-authored-by: Sergio <[email protected]>

Author: jorblancoa

coreneuron/apps/main1.cpp

@@ -407,14 +407,14 @@ static void trajectory_return() {
 
 std::unique_ptr<ReportHandler> create_report_handler(ReportConfiguration& config) {
     std::unique_ptr<ReportHandler> report_handler;
-    if (std::strcmp(config.format, "Bin") == 0) {
+    if (config.format == "Bin") {
         report_handler = std::make_unique<BinaryReportHandler>(config);
-    } else if (std::strcmp(config.format, "SONATA") == 0) {
+    } else if (config.format == "SONATA") {
         report_handler = std::make_unique<SonataReportHandler>(config);
     }
     else {
         if (nrnmpi_myid == 0) {
-            printf(" WARNING : Report name '%s' has unknown format: '%s'.\n", config.name, config.format);
+            printf(" WARNING : Report name '%s' has unknown format: '%s'.\n", config.name.data(), config.format.data());
         }
         return nullptr;
     }
@@ -477,8 +477,8 @@ extern "C" int run_solve_core(int argc, char** argv) {
     }
 
     if (!corenrn_param.reportfilepath.empty()) {
-        configs = create_report_configurations(corenrn_param.reportfilepath.c_str(),
-                                               corenrn_param.outpath.c_str(),
+        configs = create_report_configurations(corenrn_param.reportfilepath,
+                                               corenrn_param.outpath,
                                                spikes_population_name);
         reports_needs_finalize = configs.size();
     }

coreneuron/io/reports/binary_report_handler.cpp

@@ -74,15 +74,15 @@ void BinaryReportHandler::register_report(const NrnThread& nt,
         const CellMapping* m = mapinfo->get_cell_mapping(gid);
         extra[0] = vars.size();
         create_extra(*m, extra);
-        records_add_report(config.output_path, gid, gid, gid, config.start, config.stop,
-                           config.report_dt, sizemapping, config.type_str, extramapping,
-                           config.unit);
+        records_add_report(config.output_path.data(), gid, gid, gid, config.start, config.stop,
+                           config.report_dt, sizemapping, config.type_str.data(), extramapping,
+                           config.unit.data());
 
-        records_set_report_max_buffer_size_hint(config.output_path, config.buffer_size);
-        records_extra_mapping(config.output_path, gid, 5, extra.data());
+        records_set_report_max_buffer_size_hint(config.output_path.data(), config.buffer_size);
+        records_extra_mapping(config.output_path.data(), gid, 5, extra.data());
         for (const auto& var : vars) {
             mapping[0] = var.id;
-            records_add_var_with_mapping(config.output_path, gid, var.var_value, sizemapping,
+            records_add_var_with_mapping(config.output_path.data(), gid, var.var_value, sizemapping,
                                          mapping.data());
         }
     }

coreneuron/io/reports/nrnreport.hpp

@@ -59,30 +59,30 @@ enum ReportType { SomaReport, CompartmentReport, SynapseReport,
 enum SectionType { Axon, Dendrite, Apical };
 
 struct ReportConfiguration {
-    char name[REPORT_MAX_NAME_LEN];         // name of the report
-    char output_path[REPORT_MAX_FILEPATH_LEN];     // full path of the report
-    char target_name[REPORT_MAX_NAME_LEN];  // target of the report
-    char mech_name[REPORT_MAX_NAME_LEN];    // mechanism name
-    char var_name[REPORT_MAX_NAME_LEN];     // variable name
-    char unit[REPORT_MAX_NAME_LEN];         // unit of the report
-    char format[REPORT_MAX_NAME_LEN];       // format of the report (Bin, hdf5, SONATA)
-    char type_str[REPORT_MAX_NAME_LEN];     // type of report string
-    char population_name[REPORT_MAX_NAME_LEN];  // population name of the report
-    ReportType type;                        // type of the report
-    SectionType section_type;               // type of section report
-    bool section_all_compartments;          // flag for section report (all values)
-    int mech_id;                            // mechanism
-    double report_dt;                       // reporting timestep
-    double start;                           // start time of report
-    double stop;                            // stop time of report
-    int num_gids;                           // total number of gids
-    int buffer_size;                        // hint on buffer size used for this report
-    std::set<int> target;                   // list of gids for this report
+    std::string name;               // name of the report
+    std::string output_path;        // full path of the report
+    std::string target_name;        // target of the report
+    std::string mech_name;          // mechanism name
+    std::string var_name;           // variable name
+    std::string unit;               // unit of the report
+    std::string format;             // format of the report (Bin, hdf5, SONATA)
+    std::string type_str;           // type of report string
+    std::string population_name;    // population name of the report
+    ReportType type;                // type of the report
+    SectionType section_type;       // type of section report
+    bool section_all_compartments;  // flag for section report (all values)
+    int mech_id;                    // mechanism
+    double report_dt;               // reporting timestep
+    double start;                   // start time of report
+    double stop;                    // stop time of report
+    int num_gids;                   // total number of gids
+    int buffer_size;                // hint on buffer size used for this report
+    std::set<int> target;           // list of gids for this report
 };
 
 void setup_report_engine(double dt_report, double mindelay);
-std::vector<ReportConfiguration> create_report_configurations(const char* filename,
-                                                              const char* output_dir,
+std::vector<ReportConfiguration> create_report_configurations(const std::string& filename,
+                                                              const std::string& output_dir,
                                                               std::string& spikes_population_name);
 void finalize_report();
 void nrn_flush_reports(double t);

coreneuron/io/reports/report_configuration_parser.cpp

@@ -25,17 +25,20 @@
    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
    THE POSSIBILITY OF SUCH DAMAGE.
 */
+#include <algorithm>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
+#include <fstream>
 #include <iostream>
+#include <sstream>
 #include <string>
 #include <vector>
 
-#include "coreneuron/utils/nrn_assert.h"
 #include "coreneuron/io/reports/nrnreport.hpp"
-#include "coreneuron/sim/fast_imem.hpp"
 #include "coreneuron/mechanism/mech_mapping.hpp"
+#include "coreneuron/sim/fast_imem.hpp"
+#include "coreneuron/utils/nrn_assert.h"
 
 namespace coreneuron {
 
@@ -44,8 +47,7 @@ namespace coreneuron {
  *   0=Compartment, 1=Cell/Soma, Section { 2=Axon, 3=Dendrite, 4=Apical }
  * The "Comp" variations are compartment-based (all segments, not middle only)
  */
-enum class TargetType
-{
+enum class TargetType {
     Compartment = 0,
     Soma = 1,
     Axon = 2,
@@ -59,62 +61,44 @@ enum class TargetType
 /*
  * Split filter string ("mech.var_name") into mech_id and var_name
  */
-void parse_filter_string(char* filter, ReportConfiguration& config) {
-    char* token = strtok(filter, ".");
-    if (!token) {
-        std::cerr << "Error : Invalid report variable, should be mch_name.var_name" << std::endl;
-        nrn_abort(1);
-    }
-    strcpy(config.mech_name, token);
-    token = strtok(nullptr, "\n");
-    if (!token) {
-        std::cerr << "Error : Invalid report variable, should be mch_name.var_name" << std::endl;
-        nrn_abort(1);
-    }
-    strcpy(config.var_name, token);
+void parse_filter_string(const std::string &filter, ReportConfiguration &config) {
+    std::istringstream iss(filter);
+    std::string token;
+    std::getline(iss, config.mech_name, '.');
+    std::getline(iss, config.var_name, '.');
 }
 
-std::vector<ReportConfiguration> create_report_configurations(const char* conf_file,
-                                                              const char* output_dir,
-                                                              std::string& spikes_population_name) {
+std::vector<ReportConfiguration> create_report_configurations(const std::string &conf_file,
+                                                              const std::string &output_dir,
+                                                              std::string &spikes_population_name) {
     std::vector<ReportConfiguration> reports;
-    int num_reports = 0;
-    char report_on[REPORT_MAX_NAME_LEN] = "";
-    char raw_line[REPORT_MAX_FILEPATH_LEN] = "";
-    char spikes_population[REPORT_MAX_NAME_LEN] = "";
-    TargetType target_type;
-    int* gids;
-
-    FILE* fp = fopen(conf_file, "r");
-    if (!fp) {
-        std::cerr << "Cannot open configuration file: " << conf_file << ", aborting execution"
-                  << std::endl;
-        nrn_abort(1);
-    }
+    std::string report_on;
+    int target_type;
+    std::ifstream report_conf(conf_file);
 
-    fgets(raw_line, REPORT_MAX_FILEPATH_LEN, fp);
-    sscanf(raw_line, "%d\n", &num_reports);
+    int num_reports = 0;
+    report_conf >> num_reports;
     for (int i = 0; i < num_reports; i++) {
-        reports.push_back(ReportConfiguration());
-        ReportConfiguration& report = reports[reports.size() - 1];
+        ReportConfiguration report;
         // mechansim id registered in coreneuron
         report.mech_id = -1;
-        report.buffer_size = 4;  // default size to 4 Mb
-        fgets(raw_line, REPORT_MAX_FILEPATH_LEN, fp);
-        sscanf(raw_line, "\n%s %s %s %s %s %s %d %lf %lf %lf %d %d %s\n", report.name,
-               report.target_name, report.type_str, report_on, report.unit, report.format, &target_type,
-               &report.report_dt, &report.start, &report.stop, &report.num_gids,
-               &report.buffer_size, report.population_name);
-        for (int i = 0; i < REPORT_MAX_NAME_LEN; i++) {
-            report.type_str[i] = tolower(report.type_str[i]);
-        }
-        sprintf(report.output_path, "%s/%s", output_dir, report.name);
-        if (strcmp(report.type_str, "compartment") == 0) {
-            if (strcmp(report_on, "i_membrane") == 0) {
+        report.buffer_size = 4; // default size to 4 Mb
+
+        report_conf >> report.name >> report.target_name >> report.type_str >> report_on >>
+               report.unit >> report.format >> target_type >> report.report_dt >>
+               report.start >> report.stop >> report.num_gids >> report.buffer_size >>
+               report.population_name;
+
+        std::transform(report.type_str.begin(), report.type_str.end(),
+                       report.type_str.begin(),
+                       [](unsigned char c) { return std::tolower(c); });
+        report.output_path = output_dir + "/" + report.name;
+        if (report.type_str == "compartment") {
+            if (report_on == "i_membrane") {
                 nrn_use_fast_imem = true;
                 report.type = IMembraneReport;
             } else {
-                switch (target_type) {
+                switch (static_cast<TargetType>(target_type)) {
                     case TargetType::Soma:
                         report.type = SomaReport;
                         break;
@@ -156,31 +140,27 @@ std::vector<ReportConfiguration> create_report_configurations(const char* conf_f
                         nrn_abort(1);
                 }
             }
-        } else if (strcmp(report.type_str, "synapse") == 0) {
+        } else if (report.type_str == "synapse") {
             report.type = SynapseReport;
         } else {
             std::cerr << "Report error: unsupported type " << report.type_str << std::endl;
             nrn_abort(1);
         }
-
-        if (report.type == SynapseReport)
+        if (report.type == SynapseReport) {
             parse_filter_string(report_on, report);
-
+        }
         if (report.num_gids) {
-            gids = (int*)calloc(report.num_gids, sizeof(int));
-            fread(gids, sizeof(int), report.num_gids, fp);
-            // extra new line
-            fgets(raw_line, REPORT_MAX_FILEPATH_LEN, fp);
-            for (int i = 0; i < report.num_gids; i++) {
-                report.target.insert(gids[i]);
-            }
-            free(gids);
+            std::vector<int> new_gids(report.num_gids);
+            report_conf.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
+            report_conf.read(reinterpret_cast<char *>(new_gids.data()), report.num_gids * sizeof(int));
+            report.target = std::set<int>(new_gids.begin(), new_gids.end());
+            // extra new line: skip
+            report_conf.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
         }
+        reports.push_back(report);
     }
-    fgets(raw_line, REPORT_MAX_NAME_LEN, fp);
-    sscanf(raw_line, "%s\n", spikes_population);
-    spikes_population_name = spikes_population;
-    fclose(fp);
+
+    report_conf >> spikes_population_name;
     return reports;
 }
 }  // namespace coreneuron

coreneuron/io/reports/report_handler.cpp

@@ -11,7 +11,7 @@ void ReportHandler::create_report(double dt, double tstop, double delay) {
     }
     m_report_config.stop = std::min(m_report_config.stop, tstop);
 
-    m_report_config.mech_id = nrn_get_mechtype(m_report_config.mech_name);
+    m_report_config.mech_id = nrn_get_mechtype(m_report_config.mech_name.data());
     if (m_report_config.type == SynapseReport && m_report_config.mech_id == -1) {
         std::cerr << "[ERROR] mechanism to report: " << m_report_config.mech_name
                   << " is not mapped in this simulation, cannot report on it \n";
@@ -51,7 +51,7 @@ void ReportHandler::create_report(double dt, double tstop, double delay) {
         }
         if (!vars_to_report.empty()) {
             auto report_event =
-                std::make_unique<ReportEvent>(dt, t, vars_to_report, m_report_config.output_path);
+                std::make_unique<ReportEvent>(dt, t, vars_to_report, m_report_config.output_path.data());
             report_event->send(t, net_cvode_instance, &nt);
             m_report_events.push_back(std::move(report_event));
         }
@@ -263,7 +263,7 @@ VarsToReport ReportHandler::get_custom_vars_to_report(const NrnThread& nt,
             }
             if ((nodes_to_gids[ml->nodeindices[j]] == gid) && report_variable) {
                 double* var_value =
-                    get_var_location_from_var_name(report.mech_id, report.var_name, ml, j);
+                    get_var_location_from_var_name(report.mech_id, report.var_name.data(), ml, j);
                 const auto synapse_id = static_cast<int>(
                     *get_var_location_from_var_name(report.mech_id, SYNAPSE_ID_MOD_NAME, ml, j));
                 nrn_assert(synapse_id && var_value);

coreneuron/io/reports/sonata_report_handler.cpp

@@ -38,20 +38,20 @@ void SonataReportHandler::register_custom_report(const NrnThread& nt,
 void SonataReportHandler::register_report(const NrnThread& nt,
                                           ReportConfiguration& config,
                                           const VarsToReport& vars_to_report) {
-    sonata_create_report(config.output_path, config.start, config.stop, config.report_dt,
-                         config.type_str);
-    sonata_set_report_max_buffer_size_hint(config.output_path, config.buffer_size);
+    sonata_create_report(config.output_path.data(), config.start, config.stop, config.report_dt,
+                         config.type_str.data());
+    sonata_set_report_max_buffer_size_hint(config.output_path.data(), config.buffer_size);
 
     for (const auto& kv : vars_to_report) {
         int gid = kv.first;
         const std::vector<VarWithMapping>& vars = kv.second;
         if (!vars.size())
             continue;
 
-        sonata_add_node(config.output_path, config.population_name, gid);
-        sonata_set_report_max_buffer_size_hint(config.output_path, config.buffer_size);
+        sonata_add_node(config.output_path.data(), config.population_name.data(), gid);
+        sonata_set_report_max_buffer_size_hint(config.output_path.data(), config.buffer_size);
         for (const auto& variable : vars) {
-            sonata_add_element(config.output_path, config.population_name, gid, variable.id, variable.var_value);
+            sonata_add_element(config.output_path.data(), config.population_name.data(), gid, variable.id, variable.var_value);
         }
     }
 }