x[id] = _args[1];
So, the R
in AST needs to be renamed with _args[1]
.
-Definition at line 2141 of file codegen_neuron_cpp_visitor.cpp.
+Definition at line 2147 of file codegen_neuron_cpp_visitor.cpp.
diff --git a/doxygen/src_2codegen_2codegen__neuron__cpp__visitor_8cpp_source.html b/doxygen/src_2codegen_2codegen__neuron__cpp__visitor_8cpp_source.html
index 4bc58c0b8..30f4fb7fd 100644
--- a/doxygen/src_2codegen_2codegen__neuron__cpp__visitor_8cpp_source.html
+++ b/doxygen/src_2codegen_2codegen__neuron__cpp__visitor_8cpp_source.html
@@ -1209,1123 +1209,1129 @@
1113 printer->add_newline();
- 1116 if (info.diam_used) {
- 1117 printer->add_line(
"_morphology_sym = hoc_lookup(\"morphology\");");
- 1118 printer->add_newline();
-
-
- 1121 for (
const auto& ion: info.ions) {
- 1122 printer->fmt_line(
"_{0}_sym = hoc_lookup(\"{0}_ion\");", ion.name);
-
- 1124 if (!info.ions.empty()) {
- 1125 printer->add_newline();
-
-
- 1128 const auto compute_functions_parameters =
-
- 1130 ? fmt::format(
"{}, {}, {}",
-
-
-
- 1134 :
"nullptr, nullptr, nullptr";
- 1135 const auto register_mech_args = fmt::format(
"{}, {}, {}, {}, {}, {}",
- 1136 get_channel_info_var_name(),
-
- 1138 compute_functions_parameters,
-
-
- 1141 1 + info.thread_data_index);
- 1142 if (info.point_process) {
-
- 1144 "_pointtype = point_register_mech({}, _hoc_create_pnt, _hoc_destroy_pnt, "
-
- 1146 register_mech_args);
-
- 1148 printer->fmt_line(
"register_mech({});", register_mech_args);
-
-
-
- 1152 printer->add_newline();
- 1153 printer->fmt_line(
"mech_type = nrn_get_mechtype({}[1]);", get_channel_info_var_name());
-
-
- 1156 if (info.table_count > 0) {
- 1157 printer->fmt_line(
"_nrn_thread_table_reg(mech_type, {});", table_thread_function_name());
-
-
-
-
+ 1116 for (
const auto& ion: info.ions) {
+ 1117 printer->fmt_line(
"_{0}_sym = hoc_lookup(\"{0}_ion\");", ion.name);
+
+ 1119 if (!info.ions.empty()) {
+ 1120 printer->add_newline();
+
+
+ 1123 const auto compute_functions_parameters =
+
+ 1125 ? fmt::format(
"{}, {}, {}",
+
+
+
+ 1129 :
"nullptr, nullptr, nullptr";
+ 1130 const auto register_mech_args = fmt::format(
"{}, {}, {}, {}, {}, {}",
+ 1131 get_channel_info_var_name(),
+
+ 1133 compute_functions_parameters,
+
+
+ 1136 1 + info.thread_data_index);
+ 1137 if (info.point_process) {
+
+ 1139 "_pointtype = point_register_mech({}, _hoc_create_pnt, _hoc_destroy_pnt, "
+
+ 1141 register_mech_args);
+
+ 1143 printer->fmt_line(
"register_mech({});", register_mech_args);
+
+
+
+ 1147 printer->add_newline();
+ 1148 printer->fmt_line(
"mech_type = nrn_get_mechtype({}[1]);", get_channel_info_var_name());
+
+
+ 1151 if (info.table_count > 0) {
+ 1152 printer->fmt_line(
"_nrn_thread_table_reg(mech_type, {});", table_thread_function_name());
+
+
+
+
+
+
+
+
+
-
-
-
-
-
-
- 1169 printer->add_line(
"_nrn_mechanism_register_data_fields(mech_type,");
- 1170 printer->increase_indent();
-
- 1172 const auto codegen_float_variables_size = codegen_float_variables.size();
- 1173 std::vector<std::string> mech_register_args;
-
- 1175 for (
int i = 0; i < codegen_float_variables_size; ++i) {
- 1176 const auto& float_var = codegen_float_variables[i];
- 1177 if (float_var->is_array()) {
- 1178 mech_register_args.push_back(
- 1179 fmt::format(
"_nrn_mechanism_field<double>{{\"{}\", {}}} /* {} */",
- 1180 float_var->get_name(),
- 1181 float_var->get_length(),
-
-
- 1184 mech_register_args.push_back(fmt::format(
- 1185 "_nrn_mechanism_field<double>{{\"{}\"}} /* {} */", float_var->get_name(), i));
-
-
-
- 1189 const auto codegen_int_variables_size = codegen_int_variables.size();
- 1190 for (
int i = 0; i < codegen_int_variables_size; ++i) {
- 1191 const auto& int_var = codegen_int_variables[i];
- 1192 const auto& name = int_var.symbol->get_name();
- 1193 if (i != info.semantics[i].index) {
- 1194 throw std::runtime_error(
"Broken logic.");
-
-
- 1197 auto type =
"double*";
-
- 1199 type =
"Point_process*";
-
-
-
- 1203 mech_register_args.push_back(
- 1204 fmt::format(
"_nrn_mechanism_field<{}>{{\"{}\", \"{}\"}} /* {} */",
-
-
- 1207 info.semantics[i].name,
-
-
- 1210 if (info.emit_cvode) {
- 1211 mech_register_args.push_back(
- 1212 "_nrn_mechanism_field<int>{\"_cvode_ieq\", \"cvodeieq\"} /* 0 */");
-
-
- 1215 printer->add_multi_line(fmt::format(
"{}", fmt::join(mech_register_args,
",\n")));
+
+ 1164 printer->add_line(
"_nrn_mechanism_register_data_fields(mech_type,");
+ 1165 printer->increase_indent();
+
+ 1167 const auto codegen_float_variables_size = codegen_float_variables.size();
+ 1168 std::vector<std::string> mech_register_args;
+
+ 1170 for (
int i = 0; i < codegen_float_variables_size; ++i) {
+ 1171 const auto& float_var = codegen_float_variables[i];
+ 1172 if (float_var->is_array()) {
+ 1173 mech_register_args.push_back(
+ 1174 fmt::format(
"_nrn_mechanism_field<double>{{\"{}\", {}}} /* {} */",
+ 1175 float_var->get_name(),
+ 1176 float_var->get_length(),
+
+
+ 1179 mech_register_args.push_back(fmt::format(
+ 1180 "_nrn_mechanism_field<double>{{\"{}\"}} /* {} */", float_var->get_name(), i));
+
+
+
+ 1184 const auto codegen_int_variables_size = codegen_int_variables.size();
+ 1185 for (
int i = 0; i < codegen_int_variables_size; ++i) {
+ 1186 const auto& int_var = codegen_int_variables[i];
+ 1187 const auto& name = int_var.symbol->get_name();
+ 1188 if (i != info.semantics[i].index) {
+ 1189 throw std::runtime_error(
"Broken logic.");
+
+
+ 1192 auto type =
"double*";
+
+ 1194 type =
"Point_process*";
+
+
+
+ 1198 mech_register_args.push_back(
+ 1199 fmt::format(
"_nrn_mechanism_field<{}>{{\"{}\", \"{}\"}} /* {} */",
+
+
+ 1202 info.semantics[i].name,
+
+
+ 1205 if (info.emit_cvode) {
+ 1206 mech_register_args.push_back(
+ 1207 "_nrn_mechanism_field<int>{\"_cvode_ieq\", \"cvodeieq\"} /* 0 */");
+
+
+ 1210 printer->add_multi_line(fmt::format(
"{}", fmt::join(mech_register_args,
",\n")));
+
+ 1212 printer->decrease_indent();
+ 1213 printer->add_line(
");");
+ 1214 printer->add_newline();
+
- 1217 printer->decrease_indent();
- 1218 printer->add_line(
");");
- 1219 printer->add_newline();
+ 1217 printer->fmt_line(
"hoc_register_prop_size(mech_type, {}, {});",
+ 1218 float_variables_size(),
+ 1219 int_variables_size());
-
- 1222 printer->fmt_line(
"hoc_register_prop_size(mech_type, {}, {});",
- 1223 float_variables_size(),
- 1224 int_variables_size());
+ 1221 for (
int i = 0; i < codegen_int_variables_size; ++i) {
+ 1222 if (i != info.semantics[i].index) {
+ 1223 throw std::runtime_error(
"Broken logic.");
+
- 1226 for (
int i = 0; i < codegen_int_variables_size; ++i) {
- 1227 if (i != info.semantics[i].index) {
- 1228 throw std::runtime_error(
"Broken logic.");
-
+ 1226 printer->fmt_line(
"hoc_register_dparam_semantics(mech_type, {}, \"{}\");",
+
+ 1228 info.semantics[i].name);
+
- 1231 printer->fmt_line(
"hoc_register_dparam_semantics(mech_type, {}, \"{}\");",
-
- 1233 info.semantics[i].name);
-
-
- 1236 if (info.artificial_cell) {
- 1237 printer->fmt_line(
"add_nrn_artcell(mech_type, {});", info.tqitem_index);
+ 1231 if (info.artificial_cell) {
+ 1232 printer->fmt_line(
"add_nrn_artcell(mech_type, {});", info.tqitem_index);
+
+
+ 1235 printer->add_line(
"hoc_register_var(hoc_scalar_double, hoc_vector_double, hoc_intfunc);");
+ 1236 if (!info.point_process) {
+ 1237 printer->add_line(
"hoc_register_npy_direct(mech_type, npy_direct_func_proc);");
-
- 1240 printer->add_line(
"hoc_register_var(hoc_scalar_double, hoc_vector_double, hoc_intfunc);");
- 1241 if (!info.point_process) {
- 1242 printer->add_line(
"hoc_register_npy_direct(mech_type, npy_direct_func_proc);");
-
- 1244 if (info.net_receive_node) {
- 1245 printer->fmt_line(
"pnt_receive[mech_type] = nrn_net_receive_{};", info.mod_suffix);
- 1246 printer->fmt_line(
"pnt_receive_size[mech_type] = {};", info.num_net_receive_parameters);
+ 1239 if (info.net_receive_node) {
+ 1240 printer->fmt_line(
"pnt_receive[mech_type] = nrn_net_receive_{};", info.mod_suffix);
+ 1241 printer->fmt_line(
"pnt_receive_size[mech_type] = {};", info.num_net_receive_parameters);
+
+
+ 1244 if (info.thread_callback_register) {
+ 1245 printer->add_line(
"_nrn_thread_reg(mech_type, 1, thread_mem_init);");
+ 1246 printer->add_line(
"_nrn_thread_reg(mech_type, 0, thread_mem_cleanup);");
- 1249 if (info.thread_callback_register) {
- 1250 printer->add_line(
"_nrn_thread_reg(mech_type, 1, thread_mem_init);");
- 1251 printer->add_line(
"_nrn_thread_reg(mech_type, 0, thread_mem_cleanup);");
-
-
- 1254 printer->pop_block();
-
-
+ 1249 printer->pop_block();
+
+
+
+
+ 1254 if (!info.thread_callback_register) {
+
+
-
- 1259 if (!info.thread_callback_register) {
-
-
-
- 1263 auto static_thread_data = get_variable_name(
"thread_data",
false);
- 1264 auto inuse = get_variable_name(
"thread_data_in_use",
false);
- 1265 auto thread_data_index = info.thread_var_thread_id;
- 1266 printer->push_block(
"static void thread_mem_init(Datum* _thread) ");
- 1267 printer->push_block(fmt::format(
"if({})", inuse));
- 1268 printer->fmt_line(
"_thread[{}] = {{neuron::container::do_not_search, new double[{}]{{}}}};",
+ 1258 auto static_thread_data = get_variable_name(
"thread_data",
false);
+ 1259 auto inuse = get_variable_name(
"thread_data_in_use",
false);
+ 1260 auto thread_data_index = info.thread_var_thread_id;
+ 1261 printer->push_block(
"static void thread_mem_init(Datum* _thread) ");
+ 1262 printer->push_block(fmt::format(
"if({})", inuse));
+ 1263 printer->fmt_line(
"_thread[{}] = {{neuron::container::do_not_search, new double[{}]{{}}}};",
+
+ 1265 info.thread_var_data_size + info.top_local_thread_size);
+ 1266 printer->pop_block();
+ 1267 printer->push_block(
"else");
+ 1268 printer->fmt_line(
"_thread[{}] = {{neuron::container::do_not_search, {}}};",
- 1270 info.thread_var_data_size + info.top_local_thread_size);
- 1271 printer->pop_block();
- 1272 printer->push_block(
"else");
- 1273 printer->fmt_line(
"_thread[{}] = {{neuron::container::do_not_search, {}}};",
-
- 1275 static_thread_data);
- 1276 printer->fmt_line(
"{} = 1;", inuse);
- 1277 printer->pop_block();
- 1278 printer->pop_block();
-
- 1280 printer->push_block(
"static void thread_mem_cleanup(Datum* _thread) ");
- 1281 printer->fmt_line(
"double * _thread_data_ptr = _thread[{}].get<double*>();", thread_data_index);
- 1282 printer->push_block(fmt::format(
"if(_thread_data_ptr == {})", static_thread_data));
- 1283 printer->fmt_line(
"{} = 0;", inuse);
- 1284 printer->pop_block();
- 1285 printer->push_block(
"else");
- 1286 printer->add_line(
"delete[] _thread_data_ptr;");
- 1287 printer->pop_block();
- 1288 printer->pop_block();
-
-
-
-
- 1293 for (
auto const& [var, type]: info.neuron_global_variables) {
- 1294 auto const name = var->get_name();
- 1295 printer->fmt_line(
"extern {} {};", type, name);
-
-
-
-
- 1300 auto const value_initialize = print_initializers ?
"{}" :
"";
- 1301 auto int_type = default_int_data_type();
- 1302 printer->add_newline(2);
- 1303 printer->add_line(
"/** all mechanism instance variables and global variables */");
- 1304 printer->fmt_push_block(
"struct {} ", instance_struct());
-
- 1306 for (
auto const& [var, type]: info.neuron_global_variables) {
- 1307 auto const name = var->get_name();
- 1308 printer->fmt_line(
"{}* {}{};",
-
-
- 1311 print_initializers ? fmt::format(
"{{&::{}}}", name) : std::string{});
-
- 1313 for (
auto& var: codegen_float_variables) {
- 1314 const auto& name = var->get_name();
- 1315 printer->fmt_line(
"double* {}{};", name, value_initialize);
-
- 1317 for (
auto& var: codegen_int_variables) {
- 1318 const auto& name = var.symbol->get_name();
-
-
- 1321 }
else if (var.is_index || var.is_integer) {
- 1322 auto qualifier = var.is_constant ?
"const " :
"";
- 1323 printer->fmt_line(
"{}{}* const* {}{};", qualifier, int_type, name, value_initialize);
-
- 1325 auto qualifier = var.is_constant ?
"const " :
"";
- 1326 auto type = var.is_vdata ?
"void*" : default_float_data_type();
- 1327 printer->fmt_line(
"{}{}* const* {}{};", qualifier, type, name, value_initialize);
-
-
-
- 1331 printer->fmt_line(
"{}* {}{};",
-
-
- 1334 print_initializers ? fmt::format(
"{{&{}}}", global_struct_instance())
-
- 1336 printer->pop_block(
";");
-
-
-
- 1340 printer->add_newline(2);
- 1341 printer->fmt_push_block(
"static {} make_instance_{}(_nrn_mechanism_cache_range& _lmc)",
-
-
- 1344 printer->fmt_push_block(
"return {}", instance_struct());
-
- 1346 std::vector<std::string> make_instance_args;
-
+ 1270 static_thread_data);
+ 1271 printer->fmt_line(
"{} = 1;", inuse);
+ 1272 printer->pop_block();
+ 1273 printer->pop_block();
+
+ 1275 printer->push_block(
"static void thread_mem_cleanup(Datum* _thread) ");
+ 1276 printer->fmt_line(
"double * _thread_data_ptr = _thread[{}].get<double*>();", thread_data_index);
+ 1277 printer->push_block(fmt::format(
"if(_thread_data_ptr == {})", static_thread_data));
+ 1278 printer->fmt_line(
"{} = 0;", inuse);
+ 1279 printer->pop_block();
+ 1280 printer->push_block(
"else");
+ 1281 printer->add_line(
"delete[] _thread_data_ptr;");
+ 1282 printer->pop_block();
+ 1283 printer->pop_block();
+
+
+
+
+ 1288 for (
auto const& [var, type]: info.neuron_global_variables) {
+ 1289 auto const name = var->get_name();
+ 1290 printer->fmt_line(
"extern {} {};", type, name);
+
+
+
+
+ 1295 auto const value_initialize = print_initializers ?
"{}" :
"";
+ 1296 auto int_type = default_int_data_type();
+ 1297 printer->add_newline(2);
+ 1298 printer->add_line(
"/** all mechanism instance variables and global variables */");
+ 1299 printer->fmt_push_block(
"struct {} ", instance_struct());
+
+ 1301 for (
auto const& [var, type]: info.neuron_global_variables) {
+ 1302 auto const name = var->get_name();
+ 1303 printer->fmt_line(
"{}* {}{};",
+
+
+ 1306 print_initializers ? fmt::format(
"{{&::{}}}", name) : std::string{});
+
+ 1308 for (
auto& var: codegen_float_variables) {
+ 1309 const auto& name = var->get_name();
+ 1310 printer->fmt_line(
"double* {}{};", name, value_initialize);
+
+ 1312 for (
auto& var: codegen_int_variables) {
+ 1313 const auto& name = var.symbol->get_name();
+
+
+ 1316 }
else if (var.is_index || var.is_integer) {
+ 1317 auto qualifier = var.is_constant ?
"const " :
"";
+ 1318 printer->fmt_line(
"{}{}* const* {}{};", qualifier, int_type, name, value_initialize);
+
+ 1320 auto qualifier = var.is_constant ?
"const " :
"";
+ 1321 auto type = var.is_vdata ?
"void*" : default_float_data_type();
+ 1322 printer->fmt_line(
"{}{}* const* {}{};", qualifier, type, name, value_initialize);
+
+
+
+ 1326 printer->fmt_line(
"{}* {}{};",
+
+
+ 1329 print_initializers ? fmt::format(
"{{&{}}}", global_struct_instance())
+
+ 1331 printer->pop_block(
";");
+
+
+
+ 1335 printer->add_newline(2);
+ 1336 printer->fmt_push_block(
"static {} make_instance_{}(_nrn_mechanism_cache_range& _lmc)",
+
+
+ 1339 printer->fmt_push_block(
"return {}", instance_struct());
+
+ 1341 std::vector<std::string> make_instance_args;
+
+
+ 1344 for (
auto const& [var, type]: info.neuron_global_variables) {
+ 1345 auto const name = var->get_name();
+ 1346 make_instance_args.push_back(fmt::format(
"&::{}", name));
+
- 1349 for (
auto const& [var, type]: info.neuron_global_variables) {
- 1350 auto const name = var->get_name();
- 1351 make_instance_args.push_back(fmt::format(
"&::{}", name));
-
-
-
- 1355 const auto codegen_float_variables_size = codegen_float_variables.size();
- 1356 for (
int i = 0; i < codegen_float_variables_size; ++i) {
- 1357 const auto& float_var = codegen_float_variables[i];
- 1358 if (float_var->is_array()) {
- 1359 make_instance_args.push_back(
- 1360 fmt::format(
"_lmc.template data_array_ptr<{}, {}>()", i, float_var->get_length()));
-
- 1362 make_instance_args.push_back(fmt::format(
"_lmc.template fpfield_ptr<{}>()", i));
-
-
-
- 1366 const auto codegen_int_variables_size = codegen_int_variables.size();
- 1367 for (
size_t i = 0; i < codegen_int_variables_size; ++i) {
- 1368 const auto& var = codegen_int_variables[i];
- 1369 auto name = var.symbol->get_name();
- 1370 auto const variable = [&var, i]() -> std::string {
- 1371 if (var.is_index || var.is_integer) {
-
- 1373 }
else if (var.is_vdata) {
-
-
- 1376 return fmt::format(
"_lmc.template dptr_field_ptr<{}>()", i);
-
-
- 1379 if (variable !=
"") {
- 1380 make_instance_args.push_back(variable);
-
-
-
- 1384 printer->add_multi_line(fmt::format(
"{}", fmt::join(make_instance_args,
",\n")));
-
- 1386 printer->pop_block(
";");
- 1387 printer->pop_block();
-
-
-
- 1391 printer->add_newline(2);
- 1392 printer->fmt_push_block(
"struct {} ", node_data_struct());
-
-
- 1395 printer->add_line(
"int const * nodeindices;");
- 1396 printer->add_line(
"double const * node_voltages;");
- 1397 printer->add_line(
"double * node_diagonal;");
- 1398 printer->add_line(
"double * node_rhs;");
- 1399 printer->add_line(
"int nodecount;");
-
- 1401 printer->pop_block(
";");
-
-
-
- 1405 printer->add_newline(2);
- 1406 printer->fmt_push_block(
"static {} make_node_data_{}(NrnThread& nt, Memb_list& _ml_arg)",
-
-
-
- 1410 std::vector<std::string> make_node_data_args = {
"_ml_arg.nodeindices",
- 1411 "nt.node_voltage_storage()",
- 1412 "nt.node_d_storage()",
- 1413 "nt.node_rhs_storage()",
- 1414 "_ml_arg.nodecount"};
-
- 1416 printer->fmt_push_block(
"return {}", node_data_struct());
- 1417 printer->add_multi_line(fmt::format(
"{}", fmt::join(make_node_data_args,
",\n")));
-
- 1419 printer->pop_block(
";");
- 1420 printer->pop_block();
-
+
+ 1350 const auto codegen_float_variables_size = codegen_float_variables.size();
+ 1351 for (
int i = 0; i < codegen_float_variables_size; ++i) {
+ 1352 const auto& float_var = codegen_float_variables[i];
+ 1353 if (float_var->is_array()) {
+ 1354 make_instance_args.push_back(
+ 1355 fmt::format(
"_lmc.template data_array_ptr<{}, {}>()", i, float_var->get_length()));
+
+ 1357 make_instance_args.push_back(fmt::format(
"_lmc.template fpfield_ptr<{}>()", i));
+
+
+
+ 1361 const auto codegen_int_variables_size = codegen_int_variables.size();
+ 1362 for (
size_t i = 0; i < codegen_int_variables_size; ++i) {
+ 1363 const auto& var = codegen_int_variables[i];
+ 1364 auto name = var.symbol->get_name();
+ 1365 auto const variable = [&var, i]() -> std::string {
+ 1366 if (var.is_index || var.is_integer) {
+
+ 1368 }
else if (var.is_vdata) {
+
+
+ 1371 return fmt::format(
"_lmc.template dptr_field_ptr<{}>()", i);
+
+
+ 1374 if (variable !=
"") {
+ 1375 make_instance_args.push_back(variable);
+
+
+
+ 1379 printer->add_multi_line(fmt::format(
"{}", fmt::join(make_instance_args,
",\n")));
+
+ 1381 printer->pop_block(
";");
+ 1382 printer->pop_block();
+
+
+
+ 1386 printer->add_newline(2);
+ 1387 printer->fmt_push_block(
"struct {} ", node_data_struct());
+
+
+ 1390 printer->add_line(
"int const * nodeindices;");
+ 1391 printer->add_line(
"double const * node_voltages;");
+ 1392 printer->add_line(
"double * node_diagonal;");
+ 1393 printer->add_line(
"double * node_rhs;");
+ 1394 printer->add_line(
"int nodecount;");
+
+ 1396 printer->pop_block(
";");
+
+
+
+ 1400 printer->add_newline(2);
+ 1401 printer->fmt_push_block(
"static {} make_node_data_{}(NrnThread& nt, Memb_list& _ml_arg)",
+
+
+
+ 1405 std::vector<std::string> make_node_data_args = {
"_ml_arg.nodeindices",
+ 1406 "nt.node_voltage_storage()",
+ 1407 "nt.node_d_storage()",
+ 1408 "nt.node_rhs_storage()",
+ 1409 "_ml_arg.nodecount"};
+
+ 1411 printer->fmt_push_block(
"return {}", node_data_struct());
+ 1412 printer->add_multi_line(fmt::format(
"{}", fmt::join(make_node_data_args,
",\n")));
+
+ 1414 printer->pop_block(
";");
+ 1415 printer->pop_block();
+
+
+
+ 1419 if (codegen_thread_variables.empty()) {
+
+
-
- 1424 if (codegen_thread_variables.empty()) {
-
-
+ 1423 printer->add_newline(2);
+ 1424 printer->fmt_push_block(
"struct {} ", thread_variables_struct());
+ 1425 printer->add_line(
"double * thread_data;");
+ 1426 printer->add_newline();
- 1428 printer->add_newline(2);
- 1429 printer->fmt_push_block(
"struct {} ", thread_variables_struct());
- 1430 printer->add_line(
"double * thread_data;");
- 1431 printer->add_newline();
-
- 1433 std::string simd_width =
"1";
-
+ 1428 std::string simd_width =
"1";
+
+
+ 1431 for (
const auto& var_info: codegen_thread_variables) {
+ 1432 printer->fmt_push_block(
"double * {}_ptr(size_t id)", var_info.symbol->get_name());
+ 1433 printer->fmt_line(
"return thread_data + {} + (id % {});", var_info.offset, simd_width);
+ 1434 printer->pop_block();
- 1436 for (
const auto& var_info: codegen_thread_variables) {
- 1437 printer->fmt_push_block(
"double * {}_ptr(size_t id)", var_info.symbol->get_name());
- 1438 printer->fmt_line(
"return thread_data + {} + (id % {});", var_info.offset, simd_width);
- 1439 printer->pop_block();
-
- 1441 printer->fmt_push_block(
"double & {}(size_t id)", var_info.symbol->get_name());
- 1442 printer->fmt_line(
"return thread_data[{} + (id % {})];", var_info.offset, simd_width);
- 1443 printer->pop_block();
-
- 1445 printer->add_newline();
-
- 1447 printer->push_block(fmt::format(
"{}(double * const thread_data)", thread_variables_struct()));
- 1448 printer->fmt_line(
"this->thread_data = thread_data;");
- 1449 printer->pop_block();
-
- 1451 printer->pop_block(
";");
-
-
-
-
-
-
- 1458 for (
auto& statement: read_statements) {
- 1459 printer->add_line(statement);
-
-
-
- 1463 if (node !=
nullptr) {
-
- 1465 print_statement_block(*block,
false,
false);
-
-
-
-
- 1470 for (
auto& statement: write_statements) {
-
- 1472 printer->add_line(text);
-
-
-
-
-
- 1478 const std::string& function_name) {
- 1479 std::string method = function_name.empty() ? compute_method_name(type) : function_name;
- 1480 ParamVector args = {{
"",
"const _nrn_model_sorted_token&",
"",
"_sorted_token"},
- 1481 {
"",
"NrnThread*",
"",
"nt"},
- 1482 {
"",
"Memb_list*",
"",
"_ml_arg"},
- 1483 {
"",
"int",
"",
"_type"}};
- 1484 printer->fmt_push_block(
"void {}({})", method, get_parameter_str(args));
-
- 1486 printer->add_line(
"_nrn_mechanism_cache_range _lmc{_sorted_token, *nt, *_ml_arg, _type};");
- 1487 printer->fmt_line(
"auto inst = make_instance_{}(_lmc);", info.mod_suffix);
- 1488 printer->fmt_line(
"auto node_data = make_node_data_{}(*nt, *_ml_arg);", info.mod_suffix);
-
- 1490 printer->add_line(
"auto nodecount = _ml_arg->nodecount;");
- 1491 printer->add_line(
"auto* _thread = _ml_arg->_thread;");
- 1492 if (!codegen_thread_variables.empty()) {
- 1493 printer->fmt_line(
"auto _thread_vars = {}(_thread[{}].get<double*>());",
- 1494 thread_variables_struct(),
- 1495 info.thread_var_thread_id);
-
-
-
+ 1436 printer->fmt_push_block(
"double & {}(size_t id)", var_info.symbol->get_name());
+ 1437 printer->fmt_line(
"return thread_data[{} + (id % {})];", var_info.offset, simd_width);
+ 1438 printer->pop_block();
+
+ 1440 printer->add_newline();
+
+ 1442 printer->push_block(fmt::format(
"{}(double * const thread_data)", thread_variables_struct()));
+ 1443 printer->fmt_line(
"this->thread_data = thread_data;");
+ 1444 printer->pop_block();
+
+ 1446 printer->pop_block(
";");
+
+
+
+
+
+
+ 1453 for (
auto& statement: read_statements) {
+ 1454 printer->add_line(statement);
+
+
+
+ 1458 if (node !=
nullptr) {
+
+ 1460 print_statement_block(*block,
false,
false);
+
+
+
+
+ 1465 for (
auto& statement: write_statements) {
+
+ 1467 printer->add_line(text);
+
+
+
+
+
+ 1473 const std::string& function_name) {
+ 1474 std::string method = function_name.empty() ? compute_method_name(type) : function_name;
+ 1475 ParamVector args = {{
"",
"const _nrn_model_sorted_token&",
"",
"_sorted_token"},
+ 1476 {
"",
"NrnThread*",
"",
"nt"},
+ 1477 {
"",
"Memb_list*",
"",
"_ml_arg"},
+ 1478 {
"",
"int",
"",
"_type"}};
+ 1479 printer->fmt_push_block(
"void {}({})", method, get_parameter_str(args));
+
+ 1481 printer->add_line(
"_nrn_mechanism_cache_range _lmc{_sorted_token, *nt, *_ml_arg, _type};");
+ 1482 printer->fmt_line(
"auto inst = make_instance_{}(_lmc);", info.mod_suffix);
+ 1483 printer->fmt_line(
"auto node_data = make_node_data_{}(*nt, *_ml_arg);", info.mod_suffix);
+
+ 1485 printer->add_line(
"auto nodecount = _ml_arg->nodecount;");
+ 1486 printer->add_line(
"auto* _thread = _ml_arg->_thread;");
+ 1487 if (!codegen_thread_variables.empty()) {
+ 1488 printer->fmt_line(
"auto _thread_vars = {}(_thread[{}].get<double*>());",
+ 1489 thread_variables_struct(),
+ 1490 info.thread_var_thread_id);
+
+
+
+
+
+ 1496 printer->add_newline(2);
+
+
-
- 1501 printer->add_newline(2);
-
-
-
- 1505 printer->push_block(
"for (int id = 0; id < nodecount; id++)");
-
- 1507 printer->add_line(
"auto* _ppvar = _ml_arg->pdata[id];");
- 1508 if (!info.artificial_cell) {
- 1509 printer->add_line(
"int node_id = node_data.nodeindices[id];");
- 1510 printer->add_line(
"auto v = node_data.node_voltages[node_id];");
-
-
-
- 1514 print_initial_block(info.initial_node);
- 1515 printer->pop_block();
-
- 1517 printer->pop_block();
-
-
-
- 1521 printer->add_newline(2);
+ 1500 printer->push_block(
"for (int id = 0; id < nodecount; id++)");
+
+ 1502 printer->add_line(
"auto* _ppvar = _ml_arg->pdata[id];");
+ 1503 if (!info.artificial_cell) {
+ 1504 printer->add_line(
"int node_id = node_data.nodeindices[id];");
+ 1505 printer->add_line(
"auto v = node_data.node_voltages[node_id];");
+
+
+
+ 1509 print_initial_block(info.initial_node);
+ 1510 printer->pop_block();
+
+ 1512 printer->pop_block();
+
+
+
+ 1516 printer->add_newline(2);
+
+ 1518 ParamVector args = {{
"",
"const _nrn_model_sorted_token&",
"",
"_sorted_token"},
+ 1519 {
"",
"NrnThread*",
"",
"nt"},
+ 1520 {
"",
"Memb_list*",
"",
"_ml_arg"},
+ 1521 {
"",
"int",
"",
"_type"}};
- 1523 ParamVector args = {{
"",
"const _nrn_model_sorted_token&",
"",
"_sorted_token"},
- 1524 {
"",
"NrnThread*",
"",
"nt"},
- 1525 {
"",
"Memb_list*",
"",
"_ml_arg"},
- 1526 {
"",
"int",
"",
"_type"}};
+ 1523 printer->fmt_push_block(
"static void {}({})",
+
+ 1525 get_parameter_str(args));
+
- 1528 printer->fmt_push_block(
"static void {}({})",
-
- 1530 get_parameter_str(args));
-
-
- 1533 printer->add_multi_line(
- 1534 "_nrn_mechanism_cache_range _lmc{_sorted_token, *nt, *_ml_arg, _type};");
+ 1528 printer->add_multi_line(
+ 1529 "_nrn_mechanism_cache_range _lmc{_sorted_token, *nt, *_ml_arg, _type};");
+
+ 1531 printer->fmt_line(
"auto inst = make_instance_{}(_lmc);", info.mod_suffix);
+ 1532 printer->fmt_line(
"auto node_data = make_node_data_{}(*nt, *_ml_arg);", info.mod_suffix);
+ 1533 printer->fmt_line(
"auto nodecount = _ml_arg->nodecount;");
+ 1534 printer->push_block(
"for (int id = 0; id < nodecount; id++)");
- 1536 printer->fmt_line(
"auto inst = make_instance_{}(_lmc);", info.mod_suffix);
- 1537 printer->fmt_line(
"auto node_data = make_node_data_{}(*nt, *_ml_arg);", info.mod_suffix);
- 1538 printer->fmt_line(
"auto nodecount = _ml_arg->nodecount;");
- 1539 printer->push_block(
"for (int id = 0; id < nodecount; id++)");
-
- 1541 if (breakpoint_exist()) {
- 1542 printer->add_line(
"int node_id = node_data.nodeindices[id];");
- 1543 printer->fmt_line(
"node_data.node_diagonal[node_id] += inst.{}[id];",
-
-
-
-
- 1548 printer->pop_block();
- 1549 printer->pop_block();
-
-
-
-
-
-
-
-
-
-
-
-
-
+ 1536 if (breakpoint_exist()) {
+ 1537 printer->add_line(
"int node_id = node_data.nodeindices[id];");
+ 1538 printer->fmt_line(
"node_data.node_diagonal[node_id] += inst.{}[id];",
+
+
+
+
+ 1543 printer->pop_block();
+ 1544 printer->pop_block();
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 1562 printer->add_newline(2);
-
-
-
- 1567 printer->add_newline(2);
-
-
- 1570 printer->fmt_push_block(
"static void {}(Prop* _prop)", method);
- 1571 printer->add_multi_line(R
"CODE(
-
-
-
-
- 1576 if (info.point_process) {
- 1577 printer->push_block(
"if (nrn_point_prop_)");
- 1578 printer->add_multi_line(R
"CODE(
- 1579 _nrn_mechanism_access_alloc_seq(_prop) = _nrn_mechanism_access_alloc_seq(nrn_point_prop_);
- 1580 _ppvar = _nrn_mechanism_access_dparam(nrn_point_prop_);
-
- 1582 printer->chain_block("else");
+
+ 1565 printer->fmt_push_block(
"static void {}(Prop* _prop)", method);
+ 1566 printer->add_multi_line(R
"CODE(
+
+
+
+
+ 1571 if (info.point_process) {
+ 1572 printer->push_block(
"if (nrn_point_prop_)");
+ 1573 printer->add_multi_line(R
"CODE(
+ 1574 _nrn_mechanism_access_alloc_seq(_prop) = _nrn_mechanism_access_alloc_seq(nrn_point_prop_);
+ 1575 _ppvar = _nrn_mechanism_access_dparam(nrn_point_prop_);
+
+ 1577 printer->chain_block("else");
+
+ 1579 if (info.semantic_variable_count) {
+ 1580 printer->fmt_line(
"_ppvar = nrn_prop_datum_alloc(mech_type, {}, _prop);",
+ 1581 info.semantic_variable_count);
+ 1582 printer->add_line(
"_nrn_mechanism_access_dparam(_prop) = _ppvar;");
- 1584 if (info.semantic_variable_count) {
- 1585 printer->fmt_line(
"_ppvar = nrn_prop_datum_alloc(mech_type, {}, _prop);",
- 1586 info.semantic_variable_count);
- 1587 printer->add_line(
"_nrn_mechanism_access_dparam(_prop) = _ppvar;");
-
- 1589 printer->add_multi_line(R
"CODE(
- 1590 _nrn_mechanism_cache_instance _lmc{_prop};
- 1591 size_t const _iml{};
-
- 1593 printer->fmt_line("assert(_nrn_mechanism_get_num_vars(_prop) == {});",
- 1594 codegen_float_variables.size());
- 1595 if (float_variables_size()) {
- 1596 printer->add_line(
"/*initialize range parameters*/");
- 1597 for (
const auto& var: info.range_parameter_vars) {
- 1598 if (var->is_array()) {
-
-
- 1601 const auto& var_name = var->get_name();
- 1602 auto var_pos = position_of_float_var(var_name);
- 1603 double var_value = var->get_value() ==
nullptr ? 0.0 : *var->get_value();
-
- 1605 printer->fmt_line(
"_lmc.template fpfield<{}>(_iml) = {}; /* {} */",
-
-
-
-
-
- 1611 if (info.point_process) {
- 1612 printer->pop_block();
-
-
- 1615 if (info.semantic_variable_count) {
- 1616 printer->add_line(
"_nrn_mechanism_access_dparam(_prop) = _ppvar;");
-
-
- 1619 if (info.diam_used) {
- 1620 throw std::runtime_error(
"Diam allocation not implemented.");
-
+ 1584 printer->add_multi_line(R
"CODE(
+ 1585 _nrn_mechanism_cache_instance _lmc{_prop};
+ 1586 size_t const _iml{};
+
+ 1588 printer->fmt_line("assert(_nrn_mechanism_get_num_vars(_prop) == {});",
+ 1589 codegen_float_variables.size());
+ 1590 if (float_variables_size()) {
+ 1591 printer->add_line(
"/*initialize range parameters*/");
+ 1592 for (
const auto& var: info.range_parameter_vars) {
+ 1593 if (var->is_array()) {
+
+
+ 1596 const auto& var_name = var->get_name();
+ 1597 auto var_pos = position_of_float_var(var_name);
+ 1598 double var_value = var->get_value() ==
nullptr ? 0.0 : *var->get_value();
+
+ 1600 printer->fmt_line(
"_lmc.template fpfield<{}>(_iml) = {}; /* {} */",
+
+
+
+
+
+ 1606 if (info.point_process) {
+ 1607 printer->pop_block();
+
+
+ 1610 if (info.semantic_variable_count) {
+ 1611 printer->add_line(
"_nrn_mechanism_access_dparam(_prop) = _ppvar;");
+
+
+ 1614 const auto codegen_int_variables_size = codegen_int_variables.size();
+
+ 1616 if (info.diam_used || info.area_used) {
+ 1617 for (
size_t i = 0; i < codegen_int_variables.size(); ++i) {
+ 1618 auto var_info = codegen_int_variables[i];
+
+ 1620 printer->add_line(
"Symbol * morphology_sym = hoc_lookup(\"morphology\");");
+ 1621 printer->fmt_line(
"Prop * morphology_prop = need_memb(morphology_sym);");
- 1623 if (info.area_used) {
- 1624 throw std::runtime_error(
"Area allocation not implemented.");
-
-
- 1627 const auto codegen_int_variables_size = codegen_int_variables.size();
-
- 1629 for (
const auto& ion: info.ions) {
- 1630 printer->fmt_line(
"Symbol * {}_sym = hoc_lookup(\"{}_ion\");", ion.name, ion.name);
- 1631 printer->fmt_line(
"Prop * {}_prop = need_memb({}_sym);", ion.name, ion.name);
+
+ 1624 "_ppvar[{}] = _nrn_mechanism_get_param_handle(morphology_prop, 0);", i);
+
+
+ 1627 printer->fmt_line(
"_ppvar[{}] = _nrn_mechanism_get_area_handle(nrn_alloc_node_);",
+
+
+
+
- 1633 for (
size_t i = 0; i < codegen_int_variables_size; ++i) {
- 1634 const auto& var = codegen_int_variables[i];
-
-
- 1637 const std::string& var_name = var.symbol->get_name();
- 1638 if (var_name.rfind(
"ion_", 0) != 0) {
-
-
-
- 1642 std::string ion_var_name = std::string(var_name.begin() + 4, var_name.end());
- 1643 if (ion.is_ionic_variable(ion_var_name)) {
- 1644 printer->fmt_line(
"_ppvar[{}] = _nrn_mechanism_get_param_handle({}_prop, {});",
-
-
- 1647 ion.variable_index(ion_var_name));
-
-
- 1650 else if (ion.is_current_derivative(ion_var_name)) {
- 1651 printer->fmt_line(
"_ppvar[{}] = _nrn_mechanism_get_param_handle({}_prop, {});",
-
-
- 1654 ion.variable_index(ion_var_name));
-
-
-
-
-
-
-
- 1662 printer->pop_block();
-
-
-
-
-
-
-
-
-
- 1672 if (!nrn_state_required()) {
-
-
-
- 1676 printer->add_newline(2);
-
-
- 1679 printer->push_block(
"for (int id = 0; id < nodecount; id++)");
- 1680 printer->add_line(
"int node_id = node_data.nodeindices[id];");
- 1681 printer->add_line(
"auto* _ppvar = _ml_arg->pdata[id];");
- 1682 printer->add_line(
"auto v = node_data.node_voltages[node_id];");
-
-
-
-
-
- 1688 if (ion_variable_struct_required()) {
- 1689 throw std::runtime_error(
"Not implemented.");
-
-
-
- 1693 for (
auto& statement: read_statements) {
- 1694 printer->add_line(statement);
-
-
- 1697 if (info.nrn_state_block) {
- 1698 info.nrn_state_block->visit_children(*
this);
+ 1633 for (
const auto& ion: info.ions) {
+ 1634 printer->fmt_line(
"Symbol * {}_sym = hoc_lookup(\"{}_ion\");", ion.name, ion.name);
+ 1635 printer->fmt_line(
"Prop * {}_prop = need_memb({}_sym);", ion.name, ion.name);
+
+ 1637 for (
size_t i = 0; i < codegen_int_variables_size; ++i) {
+ 1638 const auto& var = codegen_int_variables[i];
+
+
+ 1641 const std::string& var_name = var.symbol->get_name();
+ 1642 if (var_name.rfind(
"ion_", 0) != 0) {
+
+
+
+ 1646 std::string ion_var_name = std::string(var_name.begin() + 4, var_name.end());
+ 1647 if (ion.is_ionic_variable(ion_var_name)) {
+ 1648 printer->fmt_line(
"_ppvar[{}] = _nrn_mechanism_get_param_handle({}_prop, {});",
+
+
+ 1651 ion.variable_index(ion_var_name));
+
+
+ 1654 else if (ion.is_current_derivative(ion_var_name)) {
+ 1655 printer->fmt_line(
"_ppvar[{}] = _nrn_mechanism_get_param_handle({}_prop, {});",
+
+
+ 1658 ion.variable_index(ion_var_name));
+
+
+
+
+
+
+
+ 1666 printer->pop_block();
+
+
+
+
+
+
+
+
+
+ 1676 if (!nrn_state_required()) {
+
+
+
+ 1680 printer->add_newline(2);
+
+
+ 1683 printer->push_block(
"for (int id = 0; id < nodecount; id++)");
+ 1684 printer->add_line(
"int node_id = node_data.nodeindices[id];");
+ 1685 printer->add_line(
"auto* _ppvar = _ml_arg->pdata[id];");
+ 1686 printer->add_line(
"auto v = node_data.node_voltages[node_id];");
+
+
+
+
+
+ 1692 if (ion_variable_struct_required()) {
+ 1693 throw std::runtime_error(
"Not implemented.");
+
+
+
+ 1697 for (
auto& statement: read_statements) {
+ 1698 printer->add_line(statement);
- 1701 if (info.currents.empty() && info.breakpoint_node !=
nullptr) {
- 1702 auto block = info.breakpoint_node->get_statement_block();
- 1703 print_statement_block(*block,
false,
false);
-
-
-
- 1707 for (
auto& statement: write_statements) {
- 1708 const auto& text = process_shadow_update_statement(statement,
BlockType::State);
- 1709 printer->add_line(text);
-
-
- 1712 printer->pop_block();
- 1713 printer->pop_block();
-
+ 1701 if (info.nrn_state_block) {
+ 1702 info.nrn_state_block->visit_children(*
this);
+
+
+ 1705 if (info.currents.empty() && info.breakpoint_node !=
nullptr) {
+ 1706 auto block = info.breakpoint_node->get_statement_block();
+ 1707 print_statement_block(*block,
false,
false);
+
+
+
+ 1711 for (
auto& statement: write_statements) {
+ 1712 const auto& text = process_shadow_update_statement(statement,
BlockType::State);
+ 1713 printer->add_line(text);
+
-
-
-
-
+ 1716 printer->pop_block();
+ 1717 printer->pop_block();
+
+
-
- 1722 return get_arg_str(nrn_current_parameters());
-
+
+
+
-
-
- 1727 if (ion_variable_struct_required()) {
- 1728 throw std::runtime_error(
"Not implemented.");
-
-
- 1731 ParamVector params = {{
"",
"_nrn_mechanism_cache_range&",
"",
"_lmc"},
- 1732 {
"",
"NrnThread*",
"",
"nt"},
- 1733 {
"",
"Datum*",
"",
"_ppvar"},
- 1734 {
"",
"Datum*",
"",
"_thread"}};
-
- 1736 if (info.thread_callback_register) {
- 1737 auto type_name = fmt::format(
"{}&", thread_variables_struct());
- 1738 params.emplace_back(
"", type_name,
"",
"_thread_vars");
-
- 1740 params.emplace_back(
"",
"size_t",
"",
"id");
- 1741 params.emplace_back(
"", fmt::format(
"{}&", instance_struct()),
"",
"inst");
- 1742 params.emplace_back(
"", fmt::format(
"{}&", node_data_struct()),
"",
"node_data");
- 1743 params.emplace_back(
"",
"double",
"",
"v");
-
-
-
-
-
-
- 1750 const auto& args = nrn_current_parameters();
-
- 1752 printer->add_newline(2);
- 1753 printer->fmt_push_block(
"inline double nrn_current_{}({})",
-
- 1755 get_parameter_str(args));
- 1756 printer->add_line(
"double current = 0.0;");
- 1757 print_statement_block(*block,
false,
false);
- 1758 for (
auto& current: info.currents) {
- 1759 const auto& name = get_variable_name(current);
- 1760 printer->fmt_line(
"current += {};", name);
-
- 1762 printer->add_line(
"return current;");
- 1763 printer->pop_block();
-
-
-
-
-
-
- 1770 print_statement_block(*block,
false,
false);
- 1771 if (!info.currents.empty()) {
-
- 1773 for (
const auto& current: info.currents) {
- 1774 auto var = breakpoint_current(current);
- 1775 sum += get_variable_name(var);
- 1776 if (¤t != &info.currents.back()) {
-
-
-
- 1780 printer->fmt_line(
"double rhs = {};", sum);
-
-
-
- 1784 for (
const auto& conductance: info.conductances) {
- 1785 auto var = breakpoint_current(conductance.variable);
- 1786 sum += get_variable_name(var);
- 1787 if (&conductance != &info.conductances.back()) {
-
-
-
- 1791 printer->fmt_line(
"double g = {};", sum);
-
- 1793 for (
const auto& conductance: info.conductances) {
- 1794 if (!conductance.ion.empty()) {
-
-
- 1797 const auto& rhs = get_variable_name(conductance.variable);
-
-
- 1800 printer->add_line(text);
-
-
-
-
-
-
-
- 1808 printer->fmt_line(
"double I1 = nrn_current_{}({}+0.001);",
-
- 1810 nrn_current_arguments());
- 1811 for (
auto& ion: info.ions) {
- 1812 for (
auto& var: ion.writes) {
- 1813 if (ion.is_ionic_current(var)) {
- 1814 const auto& name = get_variable_name(var);
- 1815 printer->fmt_line(
"double di{} = {};", ion.name, name);
-
-
-
- 1819 printer->fmt_line(
"double I0 = nrn_current_{}({});", info.mod_suffix, nrn_current_arguments());
- 1820 printer->add_line(
"double rhs = I0;");
-
- 1822 printer->add_line(
"double g = (I1-I0)/0.001;");
- 1823 for (
auto& ion: info.ions) {
- 1824 for (
auto& var: ion.writes) {
- 1825 if (ion.is_ionic_current(var)) {
-
- 1827 auto rhs = fmt::format(
"(di{}-{})/0.001", ion.name, get_variable_name(var));
- 1828 if (info.point_process) {
-
- 1830 rhs += fmt::format(
"*1.e2/{}", area);
-
-
-
- 1834 printer->add_line(text);
-
-
-
-
-
-
-
-
- 1843 printer->add_line(
"int node_id = node_data.nodeindices[id];");
- 1844 printer->add_line(
"double v = node_data.node_voltages[node_id];");
- 1845 printer->add_line(
"auto* _ppvar = _ml_arg->pdata[id];");
-
- 1847 for (
auto& statement: read_statements) {
- 1848 printer->add_line(statement);
-
-
- 1851 if (info.conductances.empty()) {
- 1852 print_nrn_cur_non_conductance_kernel();
-
- 1854 print_nrn_cur_conductance_kernel(node);
-
-
-
- 1858 for (
auto& statement: write_statements) {
-
- 1860 printer->add_line(text);
-
-
- 1863 if (info.point_process) {
-
- 1865 printer->fmt_line(
"double mfactor = 1.e2/{};", area);
- 1866 printer->add_line(
"g = g*mfactor;");
- 1867 printer->add_line(
"rhs = rhs*mfactor;");
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- 1882 if (!nrn_cur_required()) {
-
-
-
- 1886 if (info.conductances.empty()) {
- 1887 print_nrn_current(*info.breakpoint_node);
+
+ 1726 return get_arg_str(nrn_current_parameters());
+
+
+
+
+ 1731 if (ion_variable_struct_required()) {
+ 1732 throw std::runtime_error(
"Not implemented.");
+
+
+ 1735 ParamVector params = {{
"",
"_nrn_mechanism_cache_range&",
"",
"_lmc"},
+ 1736 {
"",
"NrnThread*",
"",
"nt"},
+ 1737 {
"",
"Datum*",
"",
"_ppvar"},
+ 1738 {
"",
"Datum*",
"",
"_thread"}};
+
+ 1740 if (info.thread_callback_register) {
+ 1741 auto type_name = fmt::format(
"{}&", thread_variables_struct());
+ 1742 params.emplace_back(
"", type_name,
"",
"_thread_vars");
+
+ 1744 params.emplace_back(
"",
"size_t",
"",
"id");
+ 1745 params.emplace_back(
"", fmt::format(
"{}&", instance_struct()),
"",
"inst");
+ 1746 params.emplace_back(
"", fmt::format(
"{}&", node_data_struct()),
"",
"node_data");
+ 1747 params.emplace_back(
"",
"double",
"",
"v");
+
+
+
+
+
+
+ 1754 const auto& args = nrn_current_parameters();
+
+ 1756 printer->add_newline(2);
+ 1757 printer->fmt_push_block(
"inline double nrn_current_{}({})",
+
+ 1759 get_parameter_str(args));
+ 1760 printer->add_line(
"double current = 0.0;");
+ 1761 print_statement_block(*block,
false,
false);
+ 1762 for (
auto& current: info.currents) {
+ 1763 const auto& name = get_variable_name(current);
+ 1764 printer->fmt_line(
"current += {};", name);
+
+ 1766 printer->add_line(
"return current;");
+ 1767 printer->pop_block();
+
+
+
+
+
+
+ 1774 print_statement_block(*block,
false,
false);
+ 1775 if (!info.currents.empty()) {
+
+ 1777 for (
const auto& current: info.currents) {
+ 1778 auto var = breakpoint_current(current);
+ 1779 sum += get_variable_name(var);
+ 1780 if (¤t != &info.currents.back()) {
+
+
+
+ 1784 printer->fmt_line(
"double rhs = {};", sum);
+
+
+
+ 1788 for (
const auto& conductance: info.conductances) {
+ 1789 auto var = breakpoint_current(conductance.variable);
+ 1790 sum += get_variable_name(var);
+ 1791 if (&conductance != &info.conductances.back()) {
+
+
+
+ 1795 printer->fmt_line(
"double g = {};", sum);
+
+ 1797 for (
const auto& conductance: info.conductances) {
+ 1798 if (!conductance.ion.empty()) {
+
+
+ 1801 const auto& rhs = get_variable_name(conductance.variable);
+
+
+ 1804 printer->add_line(text);
+
+
+
+
+
+
+
+ 1812 printer->fmt_line(
"double I1 = nrn_current_{}({}+0.001);",
+
+ 1814 nrn_current_arguments());
+ 1815 for (
auto& ion: info.ions) {
+ 1816 for (
auto& var: ion.writes) {
+ 1817 if (ion.is_ionic_current(var)) {
+ 1818 const auto& name = get_variable_name(var);
+ 1819 printer->fmt_line(
"double di{} = {};", ion.name, name);
+
+
+
+ 1823 printer->fmt_line(
"double I0 = nrn_current_{}({});", info.mod_suffix, nrn_current_arguments());
+ 1824 printer->add_line(
"double rhs = I0;");
+
+ 1826 printer->add_line(
"double g = (I1-I0)/0.001;");
+ 1827 for (
auto& ion: info.ions) {
+ 1828 for (
auto& var: ion.writes) {
+ 1829 if (ion.is_ionic_current(var)) {
+
+ 1831 auto rhs = fmt::format(
"(di{}-{})/0.001", ion.name, get_variable_name(var));
+ 1832 if (info.point_process) {
+
+ 1834 rhs += fmt::format(
"*1.e2/{}", area);
+
+
+
+ 1838 printer->add_line(text);
+
+
+
+
+
+
+
+
+ 1847 printer->add_line(
"int node_id = node_data.nodeindices[id];");
+ 1848 printer->add_line(
"double v = node_data.node_voltages[node_id];");
+ 1849 printer->add_line(
"auto* _ppvar = _ml_arg->pdata[id];");
+
+ 1851 for (
auto& statement: read_statements) {
+ 1852 printer->add_line(statement);
+
+
+ 1855 if (info.conductances.empty()) {
+ 1856 print_nrn_cur_non_conductance_kernel();
+
+ 1858 print_nrn_cur_conductance_kernel(node);
+
+
+
+ 1862 for (
auto& statement: write_statements) {
+
+ 1864 printer->add_line(text);
+
+
+ 1867 if (info.point_process) {
+
+ 1869 printer->fmt_line(
"double mfactor = 1.e2/{};", area);
+ 1870 printer->add_line(
"g = g*mfactor;");
+ 1871 printer->add_line(
"rhs = rhs*mfactor;");
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 1886 if (!nrn_cur_required()) {
+
- 1890 printer->add_newline(2);
- 1891 printer->add_line(
"/** update current */");
-
-
- 1894 printer->push_block(
"for (int id = 0; id < nodecount; id++)");
- 1895 print_nrn_cur_kernel(*info.breakpoint_node);
-
-
-
-
-
-
- 1902 printer->add_line(
"node_data.node_rhs[node_id] -= rhs;");
-
- 1904 if (breakpoint_exist()) {
- 1905 printer->fmt_line(
"inst.{}[id] = g;",
-
-
-
- 1909 printer->pop_block();
-
-
-
-
-
-
-
-
-
- 1919 printer->pop_block();
-
+ 1890 if (info.conductances.empty()) {
+ 1891 print_nrn_current(*info.breakpoint_node);
+
+
+ 1894 printer->add_newline(2);
+ 1895 printer->add_line(
"/** update current */");
+
+
+ 1898 printer->push_block(
"for (int id = 0; id < nodecount; id++)");
+ 1899 print_nrn_cur_kernel(*info.breakpoint_node);
+
+
+
+
+
+
+ 1906 printer->add_line(
"node_data.node_rhs[node_id] -= rhs;");
+
+ 1908 if (breakpoint_exist()) {
+ 1909 printer->fmt_line(
"inst.{}[id] = g;",
+
+
+
+ 1913 printer->pop_block();
+
+
+
+
+
+
+
-
-
-
-
+
+ 1923 printer->pop_block();
+
+
-
- 1928 print_standard_includes();
- 1929 print_neuron_includes();
+
+
+
- 1931 if (info.thread_callback_register) {
- 1932 printer->add_line(
"extern void _nrn_thread_reg(int, int, void(*)(Datum*));");
-
-
-
-
-
- 1938 print_global_macros();
- 1939 print_mechanism_variables_macros();
-
-
-
-
- 1944 printer->add_newline();
- 1945 printer->add_line(
"/* NEURON global macro definitions */");
- 1946 if (info.vectorize) {
- 1947 printer->add_multi_line(R
"CODE(
-
- 1949 #define NRN_VECTORIZED 1
-
-
- 1952 printer->add_multi_line(R
"CODE(
- 1953 /* NOT VECTORIZED */
- 1954 #define NRN_VECTORIZED 0
-
-
-
-
-
-
- 1961 printer->add_newline();
- 1962 printer->add_line(
"static constexpr auto number_of_datum_variables = ",
-
-
- 1965 printer->add_line(
"static constexpr auto number_of_floating_point_variables = ",
-
-
- 1968 printer->add_newline();
- 1969 printer->add_multi_line(R
"CODE(
-
- 1971 template <typename T>
- 1972 using _nrn_mechanism_std_vector = std::vector<T>;
- 1973 using _nrn_model_sorted_token = neuron::model_sorted_token;
- 1974 using _nrn_mechanism_cache_range = neuron::cache::MechanismRange<number_of_floating_point_variables, number_of_datum_variables>;
- 1975 using _nrn_mechanism_cache_instance = neuron::cache::MechanismInstance<number_of_floating_point_variables, number_of_datum_variables>;
- 1976 using _nrn_non_owning_id_without_container = neuron::container::non_owning_identifier_without_container;
+
+ 1932 print_standard_includes();
+ 1933 print_neuron_includes();
+
+ 1935 if (info.thread_callback_register) {
+ 1936 printer->add_line(
"extern void _nrn_thread_reg(int, int, void(*)(Datum*));");
+
+
+
+
+
+ 1942 print_global_macros();
+ 1943 print_mechanism_variables_macros();
+
+ 1945 printer->add_line(
"extern Node* nrn_alloc_node_;");
+
+
+
+
+ 1950 printer->add_newline();
+ 1951 printer->add_line(
"/* NEURON global macro definitions */");
+ 1952 if (info.vectorize) {
+ 1953 printer->add_multi_line(R
"CODE(
+
+ 1955 #define NRN_VECTORIZED 1
+
+
+ 1958 printer->add_multi_line(R
"CODE(
+ 1959 /* NOT VECTORIZED */
+ 1960 #define NRN_VECTORIZED 0
+
+
+
+
+
+
+ 1967 printer->add_newline();
+ 1968 printer->add_line(
"static constexpr auto number_of_datum_variables = ",
+
+
+ 1971 printer->add_line(
"static constexpr auto number_of_floating_point_variables = ",
+
+
+ 1974 printer->add_newline();
+ 1975 printer->add_multi_line(R
"CODE(
+
1977 template <typename T>
- 1978 using _nrn_mechanism_field = neuron::mechanism::field<T>;
- 1979 template <typename... Args>
- 1980 void _nrn_mechanism_register_data_fields(Args&&... args) {
- 1981 neuron::mechanism::register_data_fields(std::forward<Args>(args)...);
-
-
-
-
- 1986 if (info.point_process) {
- 1987 printer->add_line(
"extern Prop* nrn_point_prop_;");
-
- 1989 printer->add_line(
"Prop* hoc_getdata_range(int type);");
-
-
-
- 1993 if (info.table_count > 0) {
- 1994 printer->add_line(
"void _nrn_thread_table_reg(int, nrn_thread_table_check_t);");
-
-
-
-
-
- 2000 print_namespace_start();
-
-
+ 1978 using _nrn_mechanism_std_vector = std::vector<T>;
+ 1979 using _nrn_model_sorted_token = neuron::model_sorted_token;
+ 1980 using _nrn_mechanism_cache_range = neuron::cache::MechanismRange<number_of_floating_point_variables, number_of_datum_variables>;
+ 1981 using _nrn_mechanism_cache_instance = neuron::cache::MechanismInstance<number_of_floating_point_variables, number_of_datum_variables>;
+ 1982 using _nrn_non_owning_id_without_container = neuron::container::non_owning_identifier_without_container;
+ 1983 template <typename T>
+ 1984 using _nrn_mechanism_field = neuron::mechanism::field<T>;
+ 1985 template <typename... Args>
+ 1986 void _nrn_mechanism_register_data_fields(Args&&... args) {
+ 1987 neuron::mechanism::register_data_fields(std::forward<Args>(args)...);
+
+
+
+
+ 1992 if (info.point_process) {
+ 1993 printer->add_line(
"extern Prop* nrn_point_prop_;");
+
+ 1995 printer->add_line(
"Prop* hoc_getdata_range(int type);");
+
+
+
+ 1999 if (info.table_count > 0) {
+ 2000 printer->add_line(
"void _nrn_thread_table_reg(int, nrn_thread_table_check_t);");
+
+
-
- 2005 print_namespace_stop();
-
-
+
+
+ 2006 print_namespace_start();
+
-
- 2010 print_mechanism_global_var_structure(print_initializers);
- 2011 print_mechanism_range_var_structure(print_initializers);
- 2012 print_node_data_structure(print_initializers);
- 2013 print_thread_variables_structure(print_initializers);
- 2014 print_make_instance();
- 2015 print_make_node_data();
-
-
-
-
- 2020 if (!info.vectorize) {
-
-
- 2023 printer->add_multi_line(R
"CODE(
-
- 2025 inst->v_unused[id] = v;
-
-
-
-
-
-
- 2032 printer->add_multi_line(R
"CODE(
-
- 2034 inst->g_unused[id] = g;
-
-
-
-
-
-
-
- 2042 print_hoc_py_wrapper_function_definitions();
- 2043 for (
const auto& procedure: info.procedures) {
- 2044 print_procedure(*procedure);
-
- 2046 for (
const auto&
function: info.functions) {
- 2047 print_function(*
function);
-
-
-
-
-
- 2053 print_net_receive();
-
-
-
-
-
- 2059 print_backend_info();
- 2060 print_headers_include();
- 2061 print_macro_definitions();
- 2062 print_neuron_global_variable_declarations();
- 2063 print_namespace_begin();
- 2064 print_nmodl_constants();
- 2065 print_prcellstate_macros();
- 2066 print_mechanism_info();
- 2067 print_data_structures(
true);
-
- 2069 print_function_prototypes();
- 2070 print_functors_definitions();
- 2071 print_global_variables_for_hoc();
- 2072 print_thread_memory_callbacks();
- 2073 print_compute_functions();
- 2074 print_sdlists_init(
true);
- 2075 print_mechanism_register();
- 2076 print_namespace_end();
-
-
-
- 2080 throw std::runtime_error(
"Not implemented.");
-
-
-
-
-
-
- 2087 if (printing_net_init) {
- 2088 throw std::runtime_error(
"Not implemented. [jfiwoei]");
-
-
- 2091 std::string weight_pointer =
"nullptr";
-
-
- 2094 if (!printing_net_receive) {
- 2095 point_process +=
".get<Point_process*>()";
-
- 2097 const auto& tqitem = get_variable_name(
"tqitem",
false);
-
- 2099 printer->fmt_text(
"net_send(/* tqitem */ &{}, {}, {}, {} + ",
-
-
-
- 2103 get_variable_name(
"t"));
- 2104 print_vector_elements(arguments,
", ");
- 2105 printer->add_text(
')');
-
-
-
- 2109 const auto& point_process = get_variable_name(
"point_process",
false);
- 2110 const auto& tqitem = get_variable_name(
"tqitem",
false);
-
- 2112 printer->fmt_text(
"net_move(/* tqitem */ &{}, {}, ", tqitem, point_process);
+
+
+ 2011 print_namespace_stop();
+
+
+
+
+ 2016 print_mechanism_global_var_structure(print_initializers);
+ 2017 print_mechanism_range_var_structure(print_initializers);
+ 2018 print_node_data_structure(print_initializers);
+ 2019 print_thread_variables_structure(print_initializers);
+ 2020 print_make_instance();
+ 2021 print_make_node_data();
+
+
+
+
+ 2026 if (!info.vectorize) {
+
+
+ 2029 printer->add_multi_line(R
"CODE(
+
+ 2031 inst->v_unused[id] = v;
+
+
+
+
+
+
+ 2038 printer->add_multi_line(R
"CODE(
+
+ 2040 inst->g_unused[id] = g;
+
+
+
+
+
+
+
+ 2048 print_hoc_py_wrapper_function_definitions();
+ 2049 for (
const auto& procedure: info.procedures) {
+ 2050 print_procedure(*procedure);
+
+ 2052 for (
const auto&
function: info.functions) {
+ 2053 print_function(*
function);
+
+
+
+
+
+ 2059 print_net_receive();
+
+
+
+
+
+ 2065 print_backend_info();
+ 2066 print_headers_include();
+ 2067 print_macro_definitions();
+ 2068 print_neuron_global_variable_declarations();
+ 2069 print_namespace_begin();
+ 2070 print_nmodl_constants();
+ 2071 print_prcellstate_macros();
+ 2072 print_mechanism_info();
+ 2073 print_data_structures(
true);
+
+ 2075 print_function_prototypes();
+ 2076 print_functors_definitions();
+ 2077 print_global_variables_for_hoc();
+ 2078 print_thread_memory_callbacks();
+ 2079 print_compute_functions();
+ 2080 print_sdlists_init(
true);
+ 2081 print_mechanism_register();
+ 2082 print_namespace_end();
+
+
+
+ 2086 throw std::runtime_error(
"Not implemented.");
+
+
+
+
+
+
+ 2093 if (printing_net_init) {
+ 2094 throw std::runtime_error(
"Not implemented. [jfiwoei]");
+
+
+ 2097 std::string weight_pointer =
"nullptr";
+
+
+ 2100 if (!printing_net_receive) {
+ 2101 point_process +=
".get<Point_process*>()";
+
+ 2103 const auto& tqitem = get_variable_name(
"tqitem",
false);
+
+ 2105 printer->fmt_text(
"net_send(/* tqitem */ &{}, {}, {}, {} + ",
+
+
+
+ 2109 get_variable_name(
"t"));
+ 2110 print_vector_elements(arguments,
", ");
+ 2111 printer->add_text(
')');
+
-
- 2115 printer->add_text(
')');
-
+
+ 2115 const auto& point_process = get_variable_name(
"point_process",
false);
+ 2116 const auto& tqitem = get_variable_name(
"tqitem",
false);
-
-
-
- 2121 printer->fmt_text(
"net_event({}, t)", point_process);
+ 2118 printer->fmt_text(
"net_move(/* tqitem */ &{}, {}, ", tqitem, point_process);
+
+
+ 2121 printer->add_text(
')');
-
-
-
-
-
-
-
-
-
+
+
+
+
+ 2127 printer->fmt_text(
"net_event({}, t)", point_process);
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
-
-
- 2145 auto n_parameters = parameters.size();
- 2146 for (
size_t i = 0; i < n_parameters; ++i) {
- 2147 const auto& name = parameters[i]->get_node_name();
-
-
-
-
-
-
-
-
-
- 2157 printing_net_receive =
true;
- 2158 auto node = info.net_receive_node;
-
-
-
-
- 2163 ParamVector args = {{
"",
"Point_process*",
"",
"_pnt"},
- 2164 {
"",
"double*",
"",
"_args"},
- 2165 {
"",
"double",
"",
"flag"}};
-
- 2167 printer->fmt_push_block(
"static void nrn_net_receive_{}({})",
-
- 2169 get_parameter_str(args));
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+ 2151 auto n_parameters = parameters.size();
+ 2152 for (
size_t i = 0; i < n_parameters; ++i) {
+ 2153 const auto& name = parameters[i]->get_node_name();
+
+
+
+
+
+
+
+
+
+ 2163 printing_net_receive =
true;
+ 2164 auto node = info.net_receive_node;
+
+
+
+
+ 2169 ParamVector args = {{
"",
"Point_process*",
"",
"_pnt"},
+ 2170 {
"",
"double*",
"",
"_args"},
+ 2171 {
"",
"double",
"",
"flag"}};
- 2173 printer->add_line(
"_nrn_mechanism_cache_instance _lmc{_pnt->prop};");
- 2174 printer->add_line(
"auto * nt = static_cast<NrnThread*>(_pnt->_vnt);");
- 2175 printer->add_line(
"auto * _ppvar = _nrn_mechanism_access_dparam(_pnt->prop);");
+ 2173 printer->fmt_push_block(
"static void nrn_net_receive_{}({})",
+
+ 2175 get_parameter_str(args));
- 2177 printer->fmt_line(
"auto inst = make_instance_{}(_lmc);", info.mod_suffix);
- 2178 printer->fmt_line(
"// nocmodl has a nullptr dereference for thread variables.");
- 2179 printer->fmt_line(
"// NMODL will fail to compile at a later point, because of");
- 2180 printer->fmt_line(
"// missing '_thread_vars'.");
- 2181 printer->fmt_line(
"Datum * _thread = nullptr;");
+
+
+ 2179 printer->add_line(
"_nrn_mechanism_cache_instance _lmc{_pnt->prop};");
+ 2180 printer->add_line(
"auto * nt = static_cast<NrnThread*>(_pnt->_vnt);");
+ 2181 printer->add_line(
"auto * _ppvar = _nrn_mechanism_access_dparam(_pnt->prop);");
- 2183 printer->add_line(
"size_t id = 0;");
- 2184 printer->add_line(
"double t = nt->_t;");
-
- 2186 print_statement_block(*node->get_statement_block(),
false,
false);
-
- 2188 printer->add_newline();
- 2189 printer->pop_block();
- 2190 printing_net_receive =
false;
-
-
+ 2183 printer->fmt_line(
"auto inst = make_instance_{}(_lmc);", info.mod_suffix);
+ 2184 printer->fmt_line(
"// nocmodl has a nullptr dereference for thread variables.");
+ 2185 printer->fmt_line(
"// NMODL will fail to compile at a later point, because of");
+ 2186 printer->fmt_line(
"// missing '_thread_vars'.");
+ 2187 printer->fmt_line(
"Datum * _thread = nullptr;");
+
+ 2189 printer->add_line(
"size_t id = 0;");
+ 2190 printer->add_line(
"double t = nt->_t;");
+
+ 2192 print_statement_block(*node->get_statement_block(),
false,
false);
-
-
-
-
-
-
-
-
-
-
-
-
+ 2194 printer->add_newline();
+ 2195 printer->pop_block();
+ 2196 printing_net_receive =
false;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-void print_nrn_destructor() override
Print nrn_destructor function definition.
+void print_nrn_destructor() override
Print nrn_destructor function definition.
Base class for all AST node.
bool is_index
if this is pure index (e.g.
-void print_nrn_cur_non_conductance_kernel() override
Print the nrn_cur kernel without NMODL conductance keyword provisions.
+void print_nrn_cur_non_conductance_kernel() override
Print the nrn_cur kernel without NMODL conductance keyword provisions.
std::string py_function_signature(const std::string &function_or_procedure_name) const
Get the signature of the npy <func_or_proc_name> function.
Helper to represent information about index/int variables.
-void print_nrn_cur() override
Print nrn_cur / current update function definition.
-void print_macro_definitions()
Print all NEURON macros.
+void print_nrn_cur() override
Print nrn_cur / current update function definition.
+void print_macro_definitions()
Print all NEURON macros.
-void print_net_event_call(const ast::FunctionCall &node) override
Print call to net_event.
+void print_net_event_call(const ast::FunctionCall &node) override
Print call to net_event.
static constexpr char POINT_PROCESS_VARIABLE[]
inbuilt neuron variable for point process
void print_neuron_includes()
Print includes from NEURON.
static constexpr char NRN_JACOB_METHOD[]
nrn_jacob method in generated code
-void print_nrn_init(bool skip_init_check=true)
Print the nrn_init function definition.
+void print_nrn_init(bool skip_init_check=true)
Print the nrn_init function definition.
void print_hoc_py_wrapper_function_body(const ast::Block *function_or_procedure_block, InterpreterWrapper wrapper_type)
std::string internal_method_arguments() override
Arguments for functions that are defined and used internally.
std::shared_ptr< symtab::Symbol > SymbolType
-void print_nrn_alloc() override
Print nrn_alloc function definition.
+void print_nrn_alloc() override
Print nrn_alloc function definition.
static constexpr char VOLTAGE_UNUSED_VARIABLE[]
range variable for voltage when unused (for vectorized model)
std::string register_mechanism_arguments() const override
Arguments for register_mech or point_register_mech function.
int position_of_int_var(const std::string &name) const override
Determine the position in the data array for a given int variable.
const ArgumentVector & get_parameters() const noexcept override
Getter for member variable NetReceiveBlock::parameters.
-std::string nrn_current_arguments()
+std::string nrn_current_arguments()
std::string table_thread_function_name() const
Name of the threaded table checking function.
bool optimize_ion_variable_copies() const override
Check if ion variable copies should be avoided.
std::string hoc_function_name(const std::string &function_or_procedure_name) const
All functions and procedures need a hoc <func_or_proc_name> to be available to the HOC interpreter.
@@ -2336,30 +2342,30 @@
Visitor for printing C++ code compatible with legacy api of NEURON
std::string backend_name() const override
Name of the code generation backend.
std::string process_verbatim_text(std::string const &text) override
Process a verbatim block for possible variable renaming.
-ParamVector nrn_current_parameters()
+ParamVector nrn_current_parameters()
static constexpr char NTHREAD_DT_VARIABLE[]
dt variable in neuron thread structure
-void print_g_unused() const override
Set g_unused (conductance) for NRN_PRCELLSTATE feature.
-void visit_watch_statement(const ast::WatchStatement &node) override
TODO: Edit for NEURON.
+void print_g_unused() const override
Set g_unused (conductance) for NRN_PRCELLSTATE feature.
+void visit_watch_statement(const ast::WatchStatement &node) override
TODO: Edit for NEURON.
virtual bool is_procedure_block() const noexcept
Check if the ast node is an instance of ast::ProcedureBlock.
-void print_net_send_call(const ast::FunctionCall &node) override
Print call to net_send.
+void print_net_send_call(const ast::FunctionCall &node) override
Print call to net_send.
Check if variable is used in given block.
Implement string manipulation functions.
-void print_namespace_end() override
Print end of namespaces.
-void print_net_move_call(const ast::FunctionCall &node) override
Print call to net_move.
+void print_namespace_end() override
Print end of namespaces.
+void print_net_move_call(const ast::FunctionCall &node) override
Print call to net_move.
std::string thread_variable_name(const ThreadVariableInfo &var_info, bool use_instance=true) const
Determine the C++ string to print for thread variables.
static constexpr char NODE_AREA_VARIABLE[]
inbuilt neuron variable for area of the compartment
-void print_nrn_state() override
Print nrn_state / state update function definition.
+void print_nrn_state() override
Print nrn_state / state update function definition.
virtual bool is_function_block() const noexcept
Check if the ast node is an instance of ast::FunctionBlock.
static constexpr char NRN_ALLOC_METHOD[]
nrn_alloc method in generated code
-void print_initial_block(const ast::InitialBlock *node)
Print the initial block.
+void print_initial_block(const ast::InitialBlock *node)
Print the initial block.
bool is_integer
if this is an integer (e.g.
-void print_global_function_common_code(BlockType type, const std::string &function_name="") override
Print common code for global functions like nrn_init, nrn_cur and nrn_state.
+void print_global_function_common_code(BlockType type, const std::string &function_name="") override
Print common code for global functions like nrn_init, nrn_cur and nrn_state.
std::string float_variable_name(const SymbolType &symbol, bool use_instance) const override
Determine the name of a float variable given its symbol.
void print_function(const ast::FunctionBlock &node) override
Print NMODL function in target backend code.
std::shared_ptr< StatementBlock > get_statement_block() const noexcept override
Getter for member variable BreakpointBlock::statement_block.
void print_hoc_py_wrapper_function_definitions()
-void print_v_unused() const override
Set v_unused (voltage) for NRN_PRCELLSTATE feature.
-void print_ion_variable() override
+void print_v_unused() const override
Set v_unused (voltage) for NRN_PRCELLSTATE feature.
+void print_ion_variable() override
static constexpr char CONDUCTANCE_VARIABLE[]
range variable for conductance
ParamVector functor_params() override
The parameters of the Newton solver "functor".
Visitor for printing C++ code compatible with legacy api of CoreNEURON
@@ -2372,68 +2378,69 @@
@ Equation
breakpoint block
static constexpr char USE_TABLE_VARIABLE[]
global variable to indicate if table is used
Represent WATCH statement in NMODL.
-void print_neuron_global_variable_declarations()
Print extern declarations for neuron global variables.
+void print_neuron_global_variable_declarations()
Print extern declarations for neuron global variables.
Represents a BREAKPOINT block in NMODL.
-void print_nrn_cur_conductance_kernel(const ast::BreakpointBlock &node) override
Print the nrn_cur kernel with NMODL conductance keyword provisions.
+void print_nrn_cur_conductance_kernel(const ast::BreakpointBlock &node) override
Print the nrn_cur kernel with NMODL conductance keyword provisions.
std::string int_variable_name(const IndexVariableInfo &symbol, const std::string &name, bool use_instance) const override
Determine the name of an int variable given its symbol.
InterpreterWrapper
Enum to switch between HOC and Python wrappers for functions and procedures defined in mechanisms.
-void print_namespace_begin() override
Print start of namespaces.
+void print_namespace_begin() override
Print start of namespaces.
void print_global_variables_for_hoc() override
Print byte arrays that register scalar and vector variables for hoc interface.
void print_standard_includes() override
Print standard C/C++ includes.
-void print_mechanism_range_var_structure(bool print_initializers) override
Print the structure that wraps all range and int variables required for the NMODL.
+void print_mechanism_range_var_structure(bool print_initializers) override
Print the structure that wraps all range and int variables required for the NMODL.
void print_procedure(const ast::ProcedureBlock &node) override
Print NMODL procedure in target backend code.
void add_variable_tqitem(std::vector< IndexVariableInfo > &variables) override
Add the variable tqitem during get_int_variables.
std::string hoc_function_signature(const std::string &function_or_procedure_name) const
Get the signature of the hoc <func_or_proc_name> function.
void print_namespace_start() override
Prints the start of the neuron namespace.
-void print_thread_variables_structure(bool print_initializers)
Print the data structure used to access thread variables.
+void print_thread_variables_structure(bool print_initializers)
Print the data structure used to access thread variables.
std::string to_string(const T &obj)
-void print_compute_functions() override
Print all compute functions for every backend.
+void print_compute_functions() override
Print all compute functions for every backend.
static constexpr char NRN_INIT_METHOD[]
nrn_init method in generated code
const ExpressionVector & get_arguments() const noexcept
Getter for member variable FunctionCall::arguments.
-void print_thread_memory_callbacks()
Print thread variable (de-)initialization functions.
+void print_thread_memory_callbacks()
Print thread variable (de-)initialization functions.
static void rename_net_receive_arguments(const ast::NetReceiveBlock &net_receive_node, const ast::Node &node)
Rename arguments to NET_RECEIVE block with corresponding pointer variable.
-void print_nrn_cur_kernel(const ast::BreakpointBlock &node) override
Print main body of nrn_cur function.
+void print_nrn_cur_kernel(const ast::BreakpointBlock &node) override
Print main body of nrn_cur function.
Blindly rename given variable to new name
static constexpr char NRN_CUR_METHOD[]
nrn_cur method in generated code
std::string conc_write_statement(const std::string &ion_name, const std::string &concentration, int index) override
Generate Function call statement for nrn_wrote_conc.
void print_mechanism_register() override
Print the mechanism registration function.
Implement utility functions for codegen visitors.
static constexpr char TQITEM_VARIABLE[]
inbuilt neuron variable for tqitem process
-void print_nrn_jacob()
Print nrn_jacob function definition.
+void print_nrn_jacob()
Print nrn_jacob function definition.
-void print_fast_imem_calculation() override
Print fast membrane current calculation code.
-void print_data_structures(bool print_initializers) override
Print all classes.
+void print_fast_imem_calculation() override
Print fast membrane current calculation code.
+void print_data_structures(bool print_initializers) override
Print all classes.
std::string get_node_name() const override
Return name of the node.
void print_sdlists_init(bool print_initializers) override
const std::string external_method_arguments() noexcept override
Arguments for external functions called from generated code.
std::string py_function_name(const std::string &function_or_procedure_name) const
In non POINT_PROCESS mechanisms all functions and procedures need a py <func_or_proc_name> to be avai...
size_t offset
The global variables ahead of this one require offset doubles to store.
-void print_node_data_structure(bool print_initializers)
Print the structure that wraps all node variables required for the NMODL.
+void print_node_data_structure(bool print_initializers)
Print the structure that wraps all node variables required for the NMODL.
static constexpr char INST_GLOBAL_MEMBER[]
instance struct member pointing to the global variable structure
-void print_make_instance() const
Print make_*_instance.
+void print_make_instance() const
Print make_*_instance.
void print_atomic_reduction_pragma() override
Print atomic update pragma for reduction statements.
NmodlType
NMODL variable properties.
void print_namespace_stop() override
Prints the end of the neuron namespace.
void print_setdata_functions()
Print NEURON functions related to setting global variables of the mechanism.
Represents ion write statement during code generation.
-void print_mechanism_variables_macros()
Print mechanism variables' related macros.
-void print_nrn_constructor() override
Print nrn_constructor function definition.
+void print_mechanism_variables_macros()
Print mechanism variables' related macros.
+void print_nrn_constructor() override
Print nrn_constructor function definition.
void print_check_table_function_prototypes()
Print all check_* function declarations.
std::shared_ptr< StatementBlock > get_statement_block() const noexcept override
Getter for member variable FunctionBlock::statement_block.
BlockType
Helper to represent various block types.
-void print_headers_include() override
Print all includes.
+void print_headers_include() override
Print all includes.
const ParamVector external_method_parameters(bool table=false) noexcept override
Parameters for functions in generated code that are called back from external code.
void print_function_or_procedure(const ast::Block &node, const std::string &name, const std::unordered_set< CppObjectSpecifier > &specifiers={ CppObjectSpecifier::Inline}) override
Print nmodl function or procedure (common code)
static constexpr char NRN_STATE_METHOD[]
nrn_state method in generated code
const std::shared_ptr< symtab::Symbol > symbol
Version information and units file path.
-void print_nrn_current(const ast::BreakpointBlock &node) override
Print the nrn_current kernel.
+void print_nrn_current(const ast::BreakpointBlock &node) override
Print the nrn_current kernel.
int position_of_float_var(const std::string &name) const override
Determine the position in the data array for a given float variable.
std::string get_variable_name(const std::string &name, bool use_instance=true) const override
Determine variable name in the structure of mechanism properties.
-void print_make_node_data() const
Print make_*_node_data.
+static constexpr char AREA_VARIABLE[]
similar to node_area but user can explicitly declare it as area
+void print_make_node_data() const
Print make_*_node_data.
virtual std::shared_ptr< StatementBlock > get_statement_block() const
Return associated statement block for the AST node.
std::string simulator_name() override
Name of the simulator the code was generated for.
void print_function_procedure_helper(const ast::Block &node) override
Common helper function to help printing function or procedure blocks.
@@ -2442,21 +2449,22 @@
void add_variable_point_process(std::vector< IndexVariableInfo > &variables) override
Add the variable point_process during get_int_variables.
Blindly rename given variable to new name
+static constexpr char DIAM_VARIABLE[]
inbuilt neuron variable for diameter of the compartment
virtual const ArgumentVector & get_parameters() const
bool variable_used(const ast::Node &node, std::string name)
std::string nrn_thread_arguments() const override
Arguments for "_threadargs_" macro in neuron implementation.
static constexpr char CONDUCTANCE_UNUSED_VARIABLE[]
range variable when conductance is not used (for vectorized model)
-void print_codegen_routines() override
Print entry point to code generation.
+void print_codegen_routines() override
Print entry point to code generation.
static constexpr char NRN_POINTERINDEX[]
hoc_nrnpointerindex name
ParamVector internal_method_parameters() override
Parameters for internally defined functions.
virtual std::string get_node_name() const
Return name of of the node.
Auto generated AST classes declaration.
-void print_net_receive()
Print net_receive call-back.
+void print_net_receive()
Print net_receive call-back.
void print_function_prototypes() override
Print function and procedures prototype declaration.
void print_mechanism_global_var_structure(bool print_initializers) override
Print the structure that wraps all global variables used in the NMODL.
-void print_global_macros()
Print NEURON global variable macros.
+void print_global_macros()
Print NEURON global variable macros.
std::vector< std::tuple< std::string, std::string, std::string, std::string > > ParamVector
A vector of parameters represented by a 4-tuple of strings:
static constexpr char ION_VARNAME_PREFIX[]
prefix for ion variable
diff --git a/notebooks/nmodl-kinetic-schemes.ipynb b/notebooks/nmodl-kinetic-schemes.ipynb
index a3b84c640..9423ac0c3 100644
--- a/notebooks/nmodl-kinetic-schemes.ipynb
+++ b/notebooks/nmodl-kinetic-schemes.ipynb
@@ -152,10 +152,10 @@
"execution_count": 1,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:09.233551Z",
- "iopub.status.busy": "2024-07-05T14:21:09.233360Z",
- "iopub.status.idle": "2024-07-05T14:21:09.971964Z",
- "shell.execute_reply": "2024-07-05T14:21:09.971253Z"
+ "iopub.execute_input": "2024-07-08T14:19:11.343181Z",
+ "iopub.status.busy": "2024-07-08T14:19:11.342948Z",
+ "iopub.status.idle": "2024-07-08T14:19:12.142002Z",
+ "shell.execute_reply": "2024-07-08T14:19:12.141214Z"
}
},
"outputs": [],
@@ -169,10 +169,10 @@
"execution_count": 2,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:09.975041Z",
- "iopub.status.busy": "2024-07-05T14:21:09.974634Z",
- "iopub.status.idle": "2024-07-05T14:21:10.001923Z",
- "shell.execute_reply": "2024-07-05T14:21:10.001287Z"
+ "iopub.execute_input": "2024-07-08T14:19:12.145153Z",
+ "iopub.status.busy": "2024-07-08T14:19:12.144926Z",
+ "iopub.status.idle": "2024-07-08T14:19:12.173471Z",
+ "shell.execute_reply": "2024-07-08T14:19:12.172816Z"
}
},
"outputs": [],
@@ -277,10 +277,10 @@
"execution_count": 3,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:10.005002Z",
- "iopub.status.busy": "2024-07-05T14:21:10.004689Z",
- "iopub.status.idle": "2024-07-05T14:21:10.009712Z",
- "shell.execute_reply": "2024-07-05T14:21:10.009056Z"
+ "iopub.execute_input": "2024-07-08T14:19:12.176565Z",
+ "iopub.status.busy": "2024-07-08T14:19:12.176282Z",
+ "iopub.status.idle": "2024-07-08T14:19:12.181063Z",
+ "shell.execute_reply": "2024-07-08T14:19:12.180392Z"
}
},
"outputs": [
@@ -323,10 +323,10 @@
"execution_count": 4,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:10.038573Z",
- "iopub.status.busy": "2024-07-05T14:21:10.038045Z",
- "iopub.status.idle": "2024-07-05T14:21:10.041944Z",
- "shell.execute_reply": "2024-07-05T14:21:10.041310Z"
+ "iopub.execute_input": "2024-07-08T14:19:12.212484Z",
+ "iopub.status.busy": "2024-07-08T14:19:12.212210Z",
+ "iopub.status.idle": "2024-07-08T14:19:12.217225Z",
+ "shell.execute_reply": "2024-07-08T14:19:12.216517Z"
}
},
"outputs": [
@@ -367,10 +367,10 @@
"execution_count": 5,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:10.044424Z",
- "iopub.status.busy": "2024-07-05T14:21:10.044080Z",
- "iopub.status.idle": "2024-07-05T14:21:10.047715Z",
- "shell.execute_reply": "2024-07-05T14:21:10.047069Z"
+ "iopub.execute_input": "2024-07-08T14:19:12.219699Z",
+ "iopub.status.busy": "2024-07-08T14:19:12.219477Z",
+ "iopub.status.idle": "2024-07-08T14:19:12.223731Z",
+ "shell.execute_reply": "2024-07-08T14:19:12.223002Z"
},
"scrolled": true
},
@@ -412,10 +412,10 @@
"execution_count": 6,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:10.050110Z",
- "iopub.status.busy": "2024-07-05T14:21:10.049673Z",
- "iopub.status.idle": "2024-07-05T14:21:10.053448Z",
- "shell.execute_reply": "2024-07-05T14:21:10.052823Z"
+ "iopub.execute_input": "2024-07-08T14:19:12.226274Z",
+ "iopub.status.busy": "2024-07-08T14:19:12.226063Z",
+ "iopub.status.idle": "2024-07-08T14:19:12.230139Z",
+ "shell.execute_reply": "2024-07-08T14:19:12.229453Z"
},
"scrolled": true
},
@@ -459,10 +459,10 @@
"execution_count": 7,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:10.055917Z",
- "iopub.status.busy": "2024-07-05T14:21:10.055579Z",
- "iopub.status.idle": "2024-07-05T14:21:10.059677Z",
- "shell.execute_reply": "2024-07-05T14:21:10.059013Z"
+ "iopub.execute_input": "2024-07-08T14:19:12.233438Z",
+ "iopub.status.busy": "2024-07-08T14:19:12.232862Z",
+ "iopub.status.idle": "2024-07-08T14:19:12.238022Z",
+ "shell.execute_reply": "2024-07-08T14:19:12.237325Z"
}
},
"outputs": [
diff --git a/notebooks/nmodl-python-tutorial.ipynb b/notebooks/nmodl-python-tutorial.ipynb
index 41d803bba..6bbe2e92e 100644
--- a/notebooks/nmodl-python-tutorial.ipynb
+++ b/notebooks/nmodl-python-tutorial.ipynb
@@ -30,10 +30,10 @@
"execution_count": 1,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:14.945002Z",
- "iopub.status.busy": "2024-07-05T14:21:14.944804Z",
- "iopub.status.idle": "2024-07-05T14:21:15.691254Z",
- "shell.execute_reply": "2024-07-05T14:21:15.690532Z"
+ "iopub.execute_input": "2024-07-08T14:19:17.773745Z",
+ "iopub.status.busy": "2024-07-08T14:19:17.773508Z",
+ "iopub.status.idle": "2024-07-08T14:19:18.583317Z",
+ "shell.execute_reply": "2024-07-08T14:19:18.582499Z"
}
},
"outputs": [],
@@ -63,10 +63,10 @@
"execution_count": 2,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:15.694514Z",
- "iopub.status.busy": "2024-07-05T14:21:15.694056Z",
- "iopub.status.idle": "2024-07-05T14:21:15.718735Z",
- "shell.execute_reply": "2024-07-05T14:21:15.718124Z"
+ "iopub.execute_input": "2024-07-08T14:19:18.586574Z",
+ "iopub.status.busy": "2024-07-08T14:19:18.586304Z",
+ "iopub.status.idle": "2024-07-08T14:19:18.613678Z",
+ "shell.execute_reply": "2024-07-08T14:19:18.612926Z"
}
},
"outputs": [],
@@ -86,10 +86,10 @@
"execution_count": 3,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:15.721535Z",
- "iopub.status.busy": "2024-07-05T14:21:15.721147Z",
- "iopub.status.idle": "2024-07-05T14:21:15.724718Z",
- "shell.execute_reply": "2024-07-05T14:21:15.724167Z"
+ "iopub.execute_input": "2024-07-08T14:19:18.616835Z",
+ "iopub.status.busy": "2024-07-08T14:19:18.616603Z",
+ "iopub.status.idle": "2024-07-08T14:19:18.620503Z",
+ "shell.execute_reply": "2024-07-08T14:19:18.619909Z"
}
},
"outputs": [],
@@ -152,10 +152,10 @@
"execution_count": 4,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:15.727245Z",
- "iopub.status.busy": "2024-07-05T14:21:15.726869Z",
- "iopub.status.idle": "2024-07-05T14:21:15.731580Z",
- "shell.execute_reply": "2024-07-05T14:21:15.730940Z"
+ "iopub.execute_input": "2024-07-08T14:19:18.623065Z",
+ "iopub.status.busy": "2024-07-08T14:19:18.622848Z",
+ "iopub.status.idle": "2024-07-08T14:19:18.627437Z",
+ "shell.execute_reply": "2024-07-08T14:19:18.626783Z"
}
},
"outputs": [],
@@ -183,10 +183,10 @@
"execution_count": 5,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:15.733982Z",
- "iopub.status.busy": "2024-07-05T14:21:15.733638Z",
- "iopub.status.idle": "2024-07-05T14:21:15.737180Z",
- "shell.execute_reply": "2024-07-05T14:21:15.736567Z"
+ "iopub.execute_input": "2024-07-08T14:19:18.630025Z",
+ "iopub.status.busy": "2024-07-08T14:19:18.629756Z",
+ "iopub.status.idle": "2024-07-08T14:19:18.633773Z",
+ "shell.execute_reply": "2024-07-08T14:19:18.633051Z"
}
},
"outputs": [
@@ -235,10 +235,10 @@
"execution_count": 6,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:15.739589Z",
- "iopub.status.busy": "2024-07-05T14:21:15.739255Z",
- "iopub.status.idle": "2024-07-05T14:21:15.743109Z",
- "shell.execute_reply": "2024-07-05T14:21:15.742499Z"
+ "iopub.execute_input": "2024-07-08T14:19:18.636311Z",
+ "iopub.status.busy": "2024-07-08T14:19:18.636114Z",
+ "iopub.status.idle": "2024-07-08T14:19:18.640682Z",
+ "shell.execute_reply": "2024-07-08T14:19:18.640124Z"
}
},
"outputs": [],
@@ -260,10 +260,10 @@
"execution_count": 7,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:15.745584Z",
- "iopub.status.busy": "2024-07-05T14:21:15.745100Z",
- "iopub.status.idle": "2024-07-05T14:21:15.748776Z",
- "shell.execute_reply": "2024-07-05T14:21:15.748153Z"
+ "iopub.execute_input": "2024-07-08T14:19:18.643170Z",
+ "iopub.status.busy": "2024-07-08T14:19:18.642970Z",
+ "iopub.status.idle": "2024-07-08T14:19:18.646781Z",
+ "shell.execute_reply": "2024-07-08T14:19:18.646083Z"
}
},
"outputs": [
@@ -297,10 +297,10 @@
"execution_count": 8,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:15.751231Z",
- "iopub.status.busy": "2024-07-05T14:21:15.750748Z",
- "iopub.status.idle": "2024-07-05T14:21:15.758064Z",
- "shell.execute_reply": "2024-07-05T14:21:15.757435Z"
+ "iopub.execute_input": "2024-07-08T14:19:18.649463Z",
+ "iopub.status.busy": "2024-07-08T14:19:18.649062Z",
+ "iopub.status.idle": "2024-07-08T14:19:18.656877Z",
+ "shell.execute_reply": "2024-07-08T14:19:18.656192Z"
}
},
"outputs": [
@@ -365,10 +365,10 @@
"execution_count": 9,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:15.760443Z",
- "iopub.status.busy": "2024-07-05T14:21:15.760107Z",
- "iopub.status.idle": "2024-07-05T14:21:15.764246Z",
- "shell.execute_reply": "2024-07-05T14:21:15.763621Z"
+ "iopub.execute_input": "2024-07-08T14:19:18.659462Z",
+ "iopub.status.busy": "2024-07-08T14:19:18.659251Z",
+ "iopub.status.idle": "2024-07-08T14:19:18.663832Z",
+ "shell.execute_reply": "2024-07-08T14:19:18.663176Z"
}
},
"outputs": [
@@ -416,10 +416,10 @@
"execution_count": 10,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:15.766684Z",
- "iopub.status.busy": "2024-07-05T14:21:15.766443Z",
- "iopub.status.idle": "2024-07-05T14:21:15.769766Z",
- "shell.execute_reply": "2024-07-05T14:21:15.769138Z"
+ "iopub.execute_input": "2024-07-08T14:19:18.666269Z",
+ "iopub.status.busy": "2024-07-08T14:19:18.666074Z",
+ "iopub.status.idle": "2024-07-08T14:19:18.669857Z",
+ "shell.execute_reply": "2024-07-08T14:19:18.669188Z"
}
},
"outputs": [],
@@ -441,10 +441,10 @@
"execution_count": 11,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:15.772077Z",
- "iopub.status.busy": "2024-07-05T14:21:15.771878Z",
- "iopub.status.idle": "2024-07-05T14:21:15.775486Z",
- "shell.execute_reply": "2024-07-05T14:21:15.774822Z"
+ "iopub.execute_input": "2024-07-08T14:19:18.672469Z",
+ "iopub.status.busy": "2024-07-08T14:19:18.672262Z",
+ "iopub.status.idle": "2024-07-08T14:19:18.676241Z",
+ "shell.execute_reply": "2024-07-08T14:19:18.675532Z"
}
},
"outputs": [
@@ -510,10 +510,10 @@
"execution_count": 12,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:15.778089Z",
- "iopub.status.busy": "2024-07-05T14:21:15.777704Z",
- "iopub.status.idle": "2024-07-05T14:21:15.780991Z",
- "shell.execute_reply": "2024-07-05T14:21:15.780332Z"
+ "iopub.execute_input": "2024-07-08T14:19:18.678863Z",
+ "iopub.status.busy": "2024-07-08T14:19:18.678417Z",
+ "iopub.status.idle": "2024-07-08T14:19:18.682345Z",
+ "shell.execute_reply": "2024-07-08T14:19:18.681608Z"
}
},
"outputs": [
@@ -548,10 +548,10 @@
"execution_count": 13,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:15.783522Z",
- "iopub.status.busy": "2024-07-05T14:21:15.783156Z",
- "iopub.status.idle": "2024-07-05T14:21:15.786554Z",
- "shell.execute_reply": "2024-07-05T14:21:15.785874Z"
+ "iopub.execute_input": "2024-07-08T14:19:18.684840Z",
+ "iopub.status.busy": "2024-07-08T14:19:18.684633Z",
+ "iopub.status.idle": "2024-07-08T14:19:18.688452Z",
+ "shell.execute_reply": "2024-07-08T14:19:18.687745Z"
}
},
"outputs": [
@@ -584,10 +584,10 @@
"execution_count": 14,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:15.789101Z",
- "iopub.status.busy": "2024-07-05T14:21:15.788742Z",
- "iopub.status.idle": "2024-07-05T14:21:15.792205Z",
- "shell.execute_reply": "2024-07-05T14:21:15.791559Z"
+ "iopub.execute_input": "2024-07-08T14:19:18.690987Z",
+ "iopub.status.busy": "2024-07-08T14:19:18.690790Z",
+ "iopub.status.idle": "2024-07-08T14:19:18.694530Z",
+ "shell.execute_reply": "2024-07-08T14:19:18.693795Z"
}
},
"outputs": [
@@ -622,10 +622,10 @@
"execution_count": 15,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:15.794735Z",
- "iopub.status.busy": "2024-07-05T14:21:15.794357Z",
- "iopub.status.idle": "2024-07-05T14:21:15.798261Z",
- "shell.execute_reply": "2024-07-05T14:21:15.797605Z"
+ "iopub.execute_input": "2024-07-08T14:19:18.696897Z",
+ "iopub.status.busy": "2024-07-08T14:19:18.696703Z",
+ "iopub.status.idle": "2024-07-08T14:19:18.701003Z",
+ "shell.execute_reply": "2024-07-08T14:19:18.700285Z"
}
},
"outputs": [
@@ -669,10 +669,10 @@
"execution_count": 16,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:15.800806Z",
- "iopub.status.busy": "2024-07-05T14:21:15.800446Z",
- "iopub.status.idle": "2024-07-05T14:21:15.805642Z",
- "shell.execute_reply": "2024-07-05T14:21:15.804987Z"
+ "iopub.execute_input": "2024-07-08T14:19:18.703593Z",
+ "iopub.status.busy": "2024-07-08T14:19:18.703371Z",
+ "iopub.status.idle": "2024-07-08T14:19:18.709089Z",
+ "shell.execute_reply": "2024-07-08T14:19:18.708371Z"
}
},
"outputs": [
@@ -733,10 +733,10 @@
"execution_count": 17,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:15.808183Z",
- "iopub.status.busy": "2024-07-05T14:21:15.807809Z",
- "iopub.status.idle": "2024-07-05T14:21:15.811249Z",
- "shell.execute_reply": "2024-07-05T14:21:15.810663Z"
+ "iopub.execute_input": "2024-07-08T14:19:18.711847Z",
+ "iopub.status.busy": "2024-07-08T14:19:18.711608Z",
+ "iopub.status.idle": "2024-07-08T14:19:18.715630Z",
+ "shell.execute_reply": "2024-07-08T14:19:18.714908Z"
}
},
"outputs": [],
@@ -761,10 +761,10 @@
"execution_count": 18,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:15.813704Z",
- "iopub.status.busy": "2024-07-05T14:21:15.813344Z",
- "iopub.status.idle": "2024-07-05T14:21:15.823586Z",
- "shell.execute_reply": "2024-07-05T14:21:15.823016Z"
+ "iopub.execute_input": "2024-07-08T14:19:18.718205Z",
+ "iopub.status.busy": "2024-07-08T14:19:18.717990Z",
+ "iopub.status.idle": "2024-07-08T14:19:18.728725Z",
+ "shell.execute_reply": "2024-07-08T14:19:18.728117Z"
}
},
"outputs": [],
@@ -857,10 +857,10 @@
"execution_count": 19,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:15.826009Z",
- "iopub.status.busy": "2024-07-05T14:21:15.825647Z",
- "iopub.status.idle": "2024-07-05T14:21:15.829100Z",
- "shell.execute_reply": "2024-07-05T14:21:15.828448Z"
+ "iopub.execute_input": "2024-07-08T14:19:18.731260Z",
+ "iopub.status.busy": "2024-07-08T14:19:18.731026Z",
+ "iopub.status.idle": "2024-07-08T14:19:18.735329Z",
+ "shell.execute_reply": "2024-07-08T14:19:18.734631Z"
}
},
"outputs": [
@@ -897,10 +897,10 @@
"execution_count": 20,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:15.831705Z",
- "iopub.status.busy": "2024-07-05T14:21:15.831344Z",
- "iopub.status.idle": "2024-07-05T14:21:15.836721Z",
- "shell.execute_reply": "2024-07-05T14:21:15.836059Z"
+ "iopub.execute_input": "2024-07-08T14:19:18.737758Z",
+ "iopub.status.busy": "2024-07-08T14:19:18.737554Z",
+ "iopub.status.idle": "2024-07-08T14:19:18.743435Z",
+ "shell.execute_reply": "2024-07-08T14:19:18.742749Z"
}
},
"outputs": [
diff --git a/notebooks/nmodl-sympy-conductance.ipynb b/notebooks/nmodl-sympy-conductance.ipynb
index c67b5c06f..6e10fa6ad 100644
--- a/notebooks/nmodl-sympy-conductance.ipynb
+++ b/notebooks/nmodl-sympy-conductance.ipynb
@@ -86,10 +86,10 @@
"execution_count": 1,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:17.997610Z",
- "iopub.status.busy": "2024-07-05T14:21:17.997078Z",
- "iopub.status.idle": "2024-07-05T14:21:18.738526Z",
- "shell.execute_reply": "2024-07-05T14:21:18.737746Z"
+ "iopub.execute_input": "2024-07-08T14:19:21.317356Z",
+ "iopub.status.busy": "2024-07-08T14:19:21.316786Z",
+ "iopub.status.idle": "2024-07-08T14:19:22.121495Z",
+ "shell.execute_reply": "2024-07-08T14:19:22.120676Z"
}
},
"outputs": [],
@@ -103,10 +103,10 @@
"execution_count": 2,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:18.741634Z",
- "iopub.status.busy": "2024-07-05T14:21:18.741215Z",
- "iopub.status.idle": "2024-07-05T14:21:18.768427Z",
- "shell.execute_reply": "2024-07-05T14:21:18.767699Z"
+ "iopub.execute_input": "2024-07-08T14:19:22.125074Z",
+ "iopub.status.busy": "2024-07-08T14:19:22.124482Z",
+ "iopub.status.idle": "2024-07-08T14:19:22.153146Z",
+ "shell.execute_reply": "2024-07-08T14:19:22.152468Z"
}
},
"outputs": [],
@@ -149,10 +149,10 @@
"execution_count": 3,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:18.771220Z",
- "iopub.status.busy": "2024-07-05T14:21:18.770972Z",
- "iopub.status.idle": "2024-07-05T14:21:19.027232Z",
- "shell.execute_reply": "2024-07-05T14:21:19.026555Z"
+ "iopub.execute_input": "2024-07-08T14:19:22.156578Z",
+ "iopub.status.busy": "2024-07-08T14:19:22.156052Z",
+ "iopub.status.idle": "2024-07-08T14:19:22.440666Z",
+ "shell.execute_reply": "2024-07-08T14:19:22.439889Z"
}
},
"outputs": [
@@ -196,10 +196,10 @@
"execution_count": 4,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:19.029882Z",
- "iopub.status.busy": "2024-07-05T14:21:19.029540Z",
- "iopub.status.idle": "2024-07-05T14:21:19.176209Z",
- "shell.execute_reply": "2024-07-05T14:21:19.175391Z"
+ "iopub.execute_input": "2024-07-08T14:19:22.443723Z",
+ "iopub.status.busy": "2024-07-08T14:19:22.443084Z",
+ "iopub.status.idle": "2024-07-08T14:19:22.597116Z",
+ "shell.execute_reply": "2024-07-08T14:19:22.596399Z"
}
},
"outputs": [
@@ -243,10 +243,10 @@
"execution_count": 5,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:19.179397Z",
- "iopub.status.busy": "2024-07-05T14:21:19.178856Z",
- "iopub.status.idle": "2024-07-05T14:21:19.187019Z",
- "shell.execute_reply": "2024-07-05T14:21:19.186366Z"
+ "iopub.execute_input": "2024-07-08T14:19:22.599924Z",
+ "iopub.status.busy": "2024-07-08T14:19:22.599697Z",
+ "iopub.status.idle": "2024-07-08T14:19:22.608506Z",
+ "shell.execute_reply": "2024-07-08T14:19:22.607749Z"
}
},
"outputs": [
@@ -290,10 +290,10 @@
"execution_count": 6,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:19.189557Z",
- "iopub.status.busy": "2024-07-05T14:21:19.189065Z",
- "iopub.status.idle": "2024-07-05T14:21:19.206236Z",
- "shell.execute_reply": "2024-07-05T14:21:19.205688Z"
+ "iopub.execute_input": "2024-07-08T14:19:22.611253Z",
+ "iopub.status.busy": "2024-07-08T14:19:22.611025Z",
+ "iopub.status.idle": "2024-07-08T14:19:22.629729Z",
+ "shell.execute_reply": "2024-07-08T14:19:22.629073Z"
}
},
"outputs": [
@@ -337,10 +337,10 @@
"execution_count": 7,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:19.208598Z",
- "iopub.status.busy": "2024-07-05T14:21:19.208304Z",
- "iopub.status.idle": "2024-07-05T14:21:19.331870Z",
- "shell.execute_reply": "2024-07-05T14:21:19.331230Z"
+ "iopub.execute_input": "2024-07-08T14:19:22.632430Z",
+ "iopub.status.busy": "2024-07-08T14:19:22.632200Z",
+ "iopub.status.idle": "2024-07-08T14:19:22.762561Z",
+ "shell.execute_reply": "2024-07-08T14:19:22.761830Z"
}
},
"outputs": [
@@ -400,10 +400,10 @@
"execution_count": 8,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:19.334574Z",
- "iopub.status.busy": "2024-07-05T14:21:19.334335Z",
- "iopub.status.idle": "2024-07-05T14:21:19.433413Z",
- "shell.execute_reply": "2024-07-05T14:21:19.432838Z"
+ "iopub.execute_input": "2024-07-08T14:19:22.765393Z",
+ "iopub.status.busy": "2024-07-08T14:19:22.765161Z",
+ "iopub.status.idle": "2024-07-08T14:19:22.870422Z",
+ "shell.execute_reply": "2024-07-08T14:19:22.869740Z"
}
},
"outputs": [
@@ -456,10 +456,10 @@
"execution_count": 9,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:19.435928Z",
- "iopub.status.busy": "2024-07-05T14:21:19.435542Z",
- "iopub.status.idle": "2024-07-05T14:21:19.506862Z",
- "shell.execute_reply": "2024-07-05T14:21:19.506212Z"
+ "iopub.execute_input": "2024-07-08T14:19:22.873175Z",
+ "iopub.status.busy": "2024-07-08T14:19:22.872935Z",
+ "iopub.status.idle": "2024-07-08T14:19:22.948171Z",
+ "shell.execute_reply": "2024-07-08T14:19:22.947424Z"
}
},
"outputs": [
diff --git a/notebooks/nmodl-sympy-solver-cnexp.ipynb b/notebooks/nmodl-sympy-solver-cnexp.ipynb
index 746260b4d..012809611 100644
--- a/notebooks/nmodl-sympy-solver-cnexp.ipynb
+++ b/notebooks/nmodl-sympy-solver-cnexp.ipynb
@@ -62,10 +62,10 @@
"execution_count": 1,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:21.082557Z",
- "iopub.status.busy": "2024-07-05T14:21:21.081964Z",
- "iopub.status.idle": "2024-07-05T14:21:21.826924Z",
- "shell.execute_reply": "2024-07-05T14:21:21.826149Z"
+ "iopub.execute_input": "2024-07-08T14:19:24.812751Z",
+ "iopub.status.busy": "2024-07-08T14:19:24.812436Z",
+ "iopub.status.idle": "2024-07-08T14:19:25.623956Z",
+ "shell.execute_reply": "2024-07-08T14:19:25.623195Z"
}
},
"outputs": [],
@@ -79,10 +79,10 @@
"execution_count": 2,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:21.830127Z",
- "iopub.status.busy": "2024-07-05T14:21:21.829668Z",
- "iopub.status.idle": "2024-07-05T14:21:21.857147Z",
- "shell.execute_reply": "2024-07-05T14:21:21.856426Z"
+ "iopub.execute_input": "2024-07-08T14:19:25.627345Z",
+ "iopub.status.busy": "2024-07-08T14:19:25.627111Z",
+ "iopub.status.idle": "2024-07-08T14:19:25.658122Z",
+ "shell.execute_reply": "2024-07-08T14:19:25.657332Z"
}
},
"outputs": [],
@@ -123,10 +123,10 @@
"execution_count": 3,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:21.859819Z",
- "iopub.status.busy": "2024-07-05T14:21:21.859566Z",
- "iopub.status.idle": "2024-07-05T14:21:22.307680Z",
- "shell.execute_reply": "2024-07-05T14:21:22.306951Z"
+ "iopub.execute_input": "2024-07-08T14:19:25.661405Z",
+ "iopub.status.busy": "2024-07-08T14:19:25.661126Z",
+ "iopub.status.idle": "2024-07-08T14:19:26.125710Z",
+ "shell.execute_reply": "2024-07-08T14:19:26.124931Z"
}
},
"outputs": [
@@ -165,10 +165,10 @@
"execution_count": 4,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:22.310411Z",
- "iopub.status.busy": "2024-07-05T14:21:22.309967Z",
- "iopub.status.idle": "2024-07-05T14:21:22.445669Z",
- "shell.execute_reply": "2024-07-05T14:21:22.444989Z"
+ "iopub.execute_input": "2024-07-08T14:19:26.128804Z",
+ "iopub.status.busy": "2024-07-08T14:19:26.128316Z",
+ "iopub.status.idle": "2024-07-08T14:19:26.268524Z",
+ "shell.execute_reply": "2024-07-08T14:19:26.267745Z"
}
},
"outputs": [
@@ -207,10 +207,10 @@
"execution_count": 5,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:22.448469Z",
- "iopub.status.busy": "2024-07-05T14:21:22.448076Z",
- "iopub.status.idle": "2024-07-05T14:21:22.679259Z",
- "shell.execute_reply": "2024-07-05T14:21:22.678593Z"
+ "iopub.execute_input": "2024-07-08T14:19:26.271283Z",
+ "iopub.status.busy": "2024-07-08T14:19:26.271054Z",
+ "iopub.status.idle": "2024-07-08T14:19:26.510893Z",
+ "shell.execute_reply": "2024-07-08T14:19:26.510102Z"
}
},
"outputs": [
@@ -255,10 +255,10 @@
"execution_count": 6,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:22.682003Z",
- "iopub.status.busy": "2024-07-05T14:21:22.681602Z",
- "iopub.status.idle": "2024-07-05T14:21:22.873830Z",
- "shell.execute_reply": "2024-07-05T14:21:22.873103Z"
+ "iopub.execute_input": "2024-07-08T14:19:26.513860Z",
+ "iopub.status.busy": "2024-07-08T14:19:26.513445Z",
+ "iopub.status.idle": "2024-07-08T14:19:26.712459Z",
+ "shell.execute_reply": "2024-07-08T14:19:26.711798Z"
}
},
"outputs": [
@@ -297,10 +297,10 @@
"execution_count": 7,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:22.876732Z",
- "iopub.status.busy": "2024-07-05T14:21:22.876316Z",
- "iopub.status.idle": "2024-07-05T14:21:24.273155Z",
- "shell.execute_reply": "2024-07-05T14:21:24.272465Z"
+ "iopub.execute_input": "2024-07-08T14:19:26.715318Z",
+ "iopub.status.busy": "2024-07-08T14:19:26.714907Z",
+ "iopub.status.idle": "2024-07-08T14:19:28.190861Z",
+ "shell.execute_reply": "2024-07-08T14:19:28.190133Z"
}
},
"outputs": [
@@ -345,10 +345,10 @@
"execution_count": 8,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:24.276066Z",
- "iopub.status.busy": "2024-07-05T14:21:24.275553Z",
- "iopub.status.idle": "2024-07-05T14:21:26.074496Z",
- "shell.execute_reply": "2024-07-05T14:21:26.073756Z"
+ "iopub.execute_input": "2024-07-08T14:19:28.193841Z",
+ "iopub.status.busy": "2024-07-08T14:19:28.193380Z",
+ "iopub.status.idle": "2024-07-08T14:19:30.056617Z",
+ "shell.execute_reply": "2024-07-08T14:19:30.055913Z"
}
},
"outputs": [
diff --git a/notebooks/nmodl-sympy-solver-derivimplicit.ipynb b/notebooks/nmodl-sympy-solver-derivimplicit.ipynb
index 4c70d4e51..4a707599d 100644
--- a/notebooks/nmodl-sympy-solver-derivimplicit.ipynb
+++ b/notebooks/nmodl-sympy-solver-derivimplicit.ipynb
@@ -39,10 +39,10 @@
"execution_count": 1,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:27.681994Z",
- "iopub.status.busy": "2024-07-05T14:21:27.681793Z",
- "iopub.status.idle": "2024-07-05T14:21:28.433607Z",
- "shell.execute_reply": "2024-07-05T14:21:28.432876Z"
+ "iopub.execute_input": "2024-07-08T14:19:32.049185Z",
+ "iopub.status.busy": "2024-07-08T14:19:32.048967Z",
+ "iopub.status.idle": "2024-07-08T14:19:32.852052Z",
+ "shell.execute_reply": "2024-07-08T14:19:32.851318Z"
}
},
"outputs": [],
@@ -56,10 +56,10 @@
"execution_count": 2,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:28.436672Z",
- "iopub.status.busy": "2024-07-05T14:21:28.436418Z",
- "iopub.status.idle": "2024-07-05T14:21:28.463108Z",
- "shell.execute_reply": "2024-07-05T14:21:28.462516Z"
+ "iopub.execute_input": "2024-07-08T14:19:32.855192Z",
+ "iopub.status.busy": "2024-07-08T14:19:32.854969Z",
+ "iopub.status.idle": "2024-07-08T14:19:32.884763Z",
+ "shell.execute_reply": "2024-07-08T14:19:32.883964Z"
}
},
"outputs": [],
@@ -100,10 +100,10 @@
"execution_count": 3,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:28.465795Z",
- "iopub.status.busy": "2024-07-05T14:21:28.465409Z",
- "iopub.status.idle": "2024-07-05T14:21:28.939324Z",
- "shell.execute_reply": "2024-07-05T14:21:28.938604Z"
+ "iopub.execute_input": "2024-07-08T14:19:32.888300Z",
+ "iopub.status.busy": "2024-07-08T14:19:32.887833Z",
+ "iopub.status.idle": "2024-07-08T14:19:33.384183Z",
+ "shell.execute_reply": "2024-07-08T14:19:33.383395Z"
}
},
"outputs": [
@@ -165,10 +165,10 @@
"execution_count": 4,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:28.941963Z",
- "iopub.status.busy": "2024-07-05T14:21:28.941698Z",
- "iopub.status.idle": "2024-07-05T14:21:29.157304Z",
- "shell.execute_reply": "2024-07-05T14:21:29.156681Z"
+ "iopub.execute_input": "2024-07-08T14:19:33.387641Z",
+ "iopub.status.busy": "2024-07-08T14:19:33.387030Z",
+ "iopub.status.idle": "2024-07-08T14:19:33.615481Z",
+ "shell.execute_reply": "2024-07-08T14:19:33.614713Z"
}
},
"outputs": [
diff --git a/notebooks/nmodl-sympy-solver-sparse.ipynb b/notebooks/nmodl-sympy-solver-sparse.ipynb
index de9653d18..558fe9452 100644
--- a/notebooks/nmodl-sympy-solver-sparse.ipynb
+++ b/notebooks/nmodl-sympy-solver-sparse.ipynb
@@ -39,10 +39,10 @@
"execution_count": 1,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:30.423828Z",
- "iopub.status.busy": "2024-07-05T14:21:30.423267Z",
- "iopub.status.idle": "2024-07-05T14:21:31.165732Z",
- "shell.execute_reply": "2024-07-05T14:21:31.164876Z"
+ "iopub.execute_input": "2024-07-08T14:19:35.091365Z",
+ "iopub.status.busy": "2024-07-08T14:19:35.091139Z",
+ "iopub.status.idle": "2024-07-08T14:19:35.902205Z",
+ "shell.execute_reply": "2024-07-08T14:19:35.901295Z"
}
},
"outputs": [],
@@ -56,10 +56,10 @@
"execution_count": 2,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:31.169076Z",
- "iopub.status.busy": "2024-07-05T14:21:31.168671Z",
- "iopub.status.idle": "2024-07-05T14:21:31.195296Z",
- "shell.execute_reply": "2024-07-05T14:21:31.194695Z"
+ "iopub.execute_input": "2024-07-08T14:19:35.906761Z",
+ "iopub.status.busy": "2024-07-08T14:19:35.905989Z",
+ "iopub.status.idle": "2024-07-08T14:19:35.935381Z",
+ "shell.execute_reply": "2024-07-08T14:19:35.934578Z"
}
},
"outputs": [],
@@ -100,10 +100,10 @@
"execution_count": 3,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:31.197866Z",
- "iopub.status.busy": "2024-07-05T14:21:31.197551Z",
- "iopub.status.idle": "2024-07-05T14:21:31.655770Z",
- "shell.execute_reply": "2024-07-05T14:21:31.655040Z"
+ "iopub.execute_input": "2024-07-08T14:19:35.938636Z",
+ "iopub.status.busy": "2024-07-08T14:19:35.938316Z",
+ "iopub.status.idle": "2024-07-08T14:19:36.446881Z",
+ "shell.execute_reply": "2024-07-08T14:19:36.446144Z"
}
},
"outputs": [
@@ -165,10 +165,10 @@
"execution_count": 4,
"metadata": {
"execution": {
- "iopub.execute_input": "2024-07-05T14:21:31.658505Z",
- "iopub.status.busy": "2024-07-05T14:21:31.658062Z",
- "iopub.status.idle": "2024-07-05T14:21:31.876405Z",
- "shell.execute_reply": "2024-07-05T14:21:31.875701Z"
+ "iopub.execute_input": "2024-07-08T14:19:36.449568Z",
+ "iopub.status.busy": "2024-07-08T14:19:36.449291Z",
+ "iopub.status.idle": "2024-07-08T14:19:36.672354Z",
+ "shell.execute_reply": "2024-07-08T14:19:36.671576Z"
}
},
"outputs": [