References for 'BlueBrain/nmodl#1344'.

at_time/neuron/example.cpp

@@ -83,6 +83,8 @@ namespace neuron {
     static_assert(std::is_trivially_move_assignable_v<example_Store>);
     static_assert(std::is_trivially_destructible_v<example_Store>);
     example_Store example_global;
+    static std::vector<double> _parameter_defaults = {
+    };
 
 
     /** all mechanism instance variables and global variables */
@@ -245,6 +247,7 @@ namespace neuron {
         register_mech(mechanism_info, nrn_alloc_example, nullptr, nullptr, nullptr, nrn_init_example, hoc_nrnpointerindex, 1);
 
         mech_type = nrn_get_mechtype(mechanism_info[1]);
+        hoc_register_parm_default(mech_type, &_parameter_defaults);
         _nrn_mechanism_register_data_fields(mech_type,
             _nrn_mechanism_field<double>{"v_unused"} /* 0 */
         );

cnexp/neuron/cnexp_array.cpp

@@ -89,6 +89,8 @@ namespace neuron {
     static_assert(std::is_trivially_move_assignable_v<cnexp_array_Store>);
     static_assert(std::is_trivially_destructible_v<cnexp_array_Store>);
     cnexp_array_Store cnexp_array_global;
+    static std::vector<double> _parameter_defaults = {
+    };
 
 
     /** all mechanism instance variables and global variables */
@@ -248,6 +250,7 @@ namespace neuron {
         register_mech(mechanism_info, nrn_alloc_cnexp_array, nullptr, nrn_jacob_cnexp_array, nrn_state_cnexp_array, nrn_init_cnexp_array, hoc_nrnpointerindex, 1);
 
         mech_type = nrn_get_mechtype(mechanism_info[1]);
+        hoc_register_parm_default(mech_type, &_parameter_defaults);
         _nrn_mechanism_register_data_fields(mech_type,
             _nrn_mechanism_field<double>{"z", 3} /* 0 */,
             _nrn_mechanism_field<double>{"x"} /* 1 */,

cnexp/neuron/cnexp_scalar.cpp

@@ -86,6 +86,8 @@ namespace neuron {
     static_assert(std::is_trivially_move_assignable_v<cnexp_scalar_Store>);
     static_assert(std::is_trivially_destructible_v<cnexp_scalar_Store>);
     cnexp_scalar_Store cnexp_scalar_global;
+    static std::vector<double> _parameter_defaults = {
+    };
 
 
     /** all mechanism instance variables and global variables */
@@ -234,6 +236,7 @@ namespace neuron {
         register_mech(mechanism_info, nrn_alloc_cnexp_scalar, nullptr, nrn_jacob_cnexp_scalar, nrn_state_cnexp_scalar, nrn_init_cnexp_scalar, hoc_nrnpointerindex, 1);
 
         mech_type = nrn_get_mechtype(mechanism_info[1]);
+        hoc_register_parm_default(mech_type, &_parameter_defaults);
         _nrn_mechanism_register_data_fields(mech_type,
             _nrn_mechanism_field<double>{"x"} /* 0 */,
             _nrn_mechanism_field<double>{"Dx"} /* 1 */,

constant/neuron/constant.cpp

@@ -84,6 +84,8 @@ namespace neuron {
     static_assert(std::is_trivially_move_assignable_v<constant_mod_Store>);
     static_assert(std::is_trivially_destructible_v<constant_mod_Store>);
     constant_mod_Store constant_mod_global;
+    static std::vector<double> _parameter_defaults = {
+    };
 
 
     /** all mechanism instance variables and global variables */
@@ -246,6 +248,7 @@ namespace neuron {
         register_mech(mechanism_info, nrn_alloc_constant_mod, nullptr, nullptr, nullptr, nrn_init_constant_mod, hoc_nrnpointerindex, 1);
 
         mech_type = nrn_get_mechtype(mechanism_info[1]);
+        hoc_register_parm_default(mech_type, &_parameter_defaults);
         _nrn_mechanism_register_data_fields(mech_type,
             _nrn_mechanism_field<double>{"v_unused"} /* 0 */
         );

function/neuron/compile_only.cpp

@@ -85,6 +85,8 @@ namespace neuron {
     static_assert(std::is_trivially_move_assignable_v<func_in_breakpoint_Store>);
     static_assert(std::is_trivially_destructible_v<func_in_breakpoint_Store>);
     func_in_breakpoint_Store func_in_breakpoint_global;
+    static std::vector<double> _parameter_defaults = {
+    };
 
 
     /** all mechanism instance variables and global variables */
@@ -385,6 +387,7 @@ namespace neuron {
         register_mech(mechanism_info, nrn_alloc_func_in_breakpoint, nrn_cur_func_in_breakpoint, nrn_jacob_func_in_breakpoint, nrn_state_func_in_breakpoint, nrn_init_func_in_breakpoint, hoc_nrnpointerindex, 1);
 
         mech_type = nrn_get_mechtype(mechanism_info[1]);
+        hoc_register_parm_default(mech_type, &_parameter_defaults);
         _nrn_mechanism_register_data_fields(mech_type,
             _nrn_mechanism_field<double>{"il"} /* 0 */,
             _nrn_mechanism_field<double>{"v_unused"} /* 1 */,

function/neuron/functions.cpp

@@ -84,6 +84,8 @@ namespace neuron {
     static_assert(std::is_trivially_move_assignable_v<functions_Store>);
     static_assert(std::is_trivially_destructible_v<functions_Store>);
     functions_Store functions_global;
+    static std::vector<double> _parameter_defaults = {
+    };
 
 
     /** all mechanism instance variables and global variables */
@@ -335,6 +337,7 @@ namespace neuron {
         register_mech(mechanism_info, nrn_alloc_functions, nullptr, nullptr, nullptr, nrn_init_functions, hoc_nrnpointerindex, 1);
 
         mech_type = nrn_get_mechtype(mechanism_info[1]);
+        hoc_register_parm_default(mech_type, &_parameter_defaults);
         _nrn_mechanism_register_data_fields(mech_type,
             _nrn_mechanism_field<double>{"x"} /* 0 */,
             _nrn_mechanism_field<double>{"v_unused"} /* 1 */

function/neuron/point_functions.cpp

@@ -82,6 +82,8 @@ namespace neuron {
     static_assert(std::is_trivially_move_assignable_v<point_functions_Store>);
     static_assert(std::is_trivially_destructible_v<point_functions_Store>);
     point_functions_Store point_functions_global;
+    static std::vector<double> _parameter_defaults = {
+    };
 
 
     /** all mechanism instance variables and global variables */
@@ -320,6 +322,7 @@ namespace neuron {
         _pointtype = point_register_mech(mechanism_info, nrn_alloc_point_functions, nullptr, nullptr, nullptr, nrn_init_point_functions, hoc_nrnpointerindex, 1, _hoc_create_pnt, _hoc_destroy_pnt, _member_func);
 
         mech_type = nrn_get_mechtype(mechanism_info[1]);
+        hoc_register_parm_default(mech_type, &_parameter_defaults);
         _nrn_mechanism_register_data_fields(mech_type,
             _nrn_mechanism_field<double>{"x"} /* 0 */,
             _nrn_mechanism_field<double>{"v_unused"} /* 1 */,

function/neuron/recursion.cpp

@@ -83,6 +83,8 @@ namespace neuron {
     static_assert(std::is_trivially_move_assignable_v<recursion_Store>);
     static_assert(std::is_trivially_destructible_v<recursion_Store>);
     recursion_Store recursion_global;
+    static std::vector<double> _parameter_defaults = {
+    };
 
 
     /** all mechanism instance variables and global variables */
@@ -249,6 +251,7 @@ namespace neuron {
         register_mech(mechanism_info, nrn_alloc_recursion, nullptr, nullptr, nullptr, nrn_init_recursion, hoc_nrnpointerindex, 1);
 
         mech_type = nrn_get_mechtype(mechanism_info[1]);
+        hoc_register_parm_default(mech_type, &_parameter_defaults);
         _nrn_mechanism_register_data_fields(mech_type,
             _nrn_mechanism_field<double>{"v_unused"} /* 0 */
         );

global/neuron/read_only.cpp

@@ -86,6 +86,8 @@ namespace neuron {
     static_assert(std::is_trivially_move_assignable_v<read_only_Store>);
     static_assert(std::is_trivially_destructible_v<read_only_Store>);
     read_only_Store read_only_global;
+    static std::vector<double> _parameter_defaults = {
+    };
 
 
     /** all mechanism instance variables and global variables */
@@ -231,6 +233,7 @@ namespace neuron {
         register_mech(mechanism_info, nrn_alloc_read_only, nullptr, nrn_jacob_read_only, nrn_state_read_only, nrn_init_read_only, hoc_nrnpointerindex, 1);
 
         mech_type = nrn_get_mechtype(mechanism_info[1]);
+        hoc_register_parm_default(mech_type, &_parameter_defaults);
         _nrn_mechanism_register_data_fields(mech_type,
             _nrn_mechanism_field<double>{"x"} /* 0 */,
             _nrn_mechanism_field<double>{"Dx"} /* 1 */,

global/neuron/thread_newton.cpp

@@ -91,6 +91,8 @@ namespace neuron {
     static_assert(std::is_trivially_move_assignable_v<thread_newton_Store>);
     static_assert(std::is_trivially_destructible_v<thread_newton_Store>);
     thread_newton_Store thread_newton_global;
+    static std::vector<double> _parameter_defaults = {
+    };
 
 
     /** all mechanism instance variables and global variables */
@@ -324,6 +326,7 @@ namespace neuron {
         register_mech(mechanism_info, nrn_alloc_thread_newton, nullptr, nrn_jacob_thread_newton, nrn_state_thread_newton, nrn_init_thread_newton, hoc_nrnpointerindex, 2);
 
         mech_type = nrn_get_mechtype(mechanism_info[1]);
+        hoc_register_parm_default(mech_type, &_parameter_defaults);
         _nrn_mechanism_register_data_fields(mech_type,
             _nrn_mechanism_field<double>{"x"} /* 0 */,
             _nrn_mechanism_field<double>{"X"} /* 1 */,

global/neuron/thread_variable.cpp

@@ -94,6 +94,8 @@ namespace neuron {
     static_assert(std::is_trivially_move_assignable_v<shared_global_Store>);
     static_assert(std::is_trivially_destructible_v<shared_global_Store>);
     shared_global_Store shared_global_global;
+    static std::vector<double> _parameter_defaults = {
+    };
 
 
     /** all mechanism instance variables and global variables */
@@ -522,6 +524,7 @@ namespace neuron {
         register_mech(mechanism_info, nrn_alloc_shared_global, nrn_cur_shared_global, nrn_jacob_shared_global, nrn_state_shared_global, nrn_init_shared_global, hoc_nrnpointerindex, 2);
 
         mech_type = nrn_get_mechtype(mechanism_info[1]);
+        hoc_register_parm_default(mech_type, &_parameter_defaults);
         _nrn_thread_table_reg(mech_type, _check_table_thread);
         _nrn_mechanism_register_data_fields(mech_type,
             _nrn_mechanism_field<double>{"y"} /* 0 */,

global/neuron/top_local.cpp

@@ -88,6 +88,8 @@ namespace neuron {
     static_assert(std::is_trivially_move_assignable_v<top_local_Store>);
     static_assert(std::is_trivially_destructible_v<top_local_Store>);
     top_local_Store top_local_global;
+    static std::vector<double> _parameter_defaults = {
+    };
 
 
     /** all mechanism instance variables and global variables */
@@ -301,6 +303,7 @@ namespace neuron {
         register_mech(mechanism_info, nrn_alloc_top_local, nrn_cur_top_local, nrn_jacob_top_local, nrn_state_top_local, nrn_init_top_local, hoc_nrnpointerindex, 2);
 
         mech_type = nrn_get_mechtype(mechanism_info[1]);
+        hoc_register_parm_default(mech_type, &_parameter_defaults);
         _nrn_mechanism_register_data_fields(mech_type,
             _nrn_mechanism_field<double>{"y"} /* 0 */,
             _nrn_mechanism_field<double>{"il"} /* 1 */,

hodgkin_huxley/neuron/hodhux.cpp

@@ -103,6 +103,12 @@ namespace neuron {
     static_assert(std::is_trivially_move_assignable_v<hodhux_Store>);
     static_assert(std::is_trivially_destructible_v<hodhux_Store>);
     hodhux_Store hodhux_global;
+    static std::vector<double> _parameter_defaults = {
+        0.12 /* gnabar */,
+        0.036 /* gkbar */,
+        0.0003 /* gl */,
+        -54.3 /* el */
+    };
 
 
     /** all mechanism instance variables and global variables */
@@ -205,10 +211,10 @@ namespace neuron {
         size_t const _iml = 0;
         assert(_nrn_mechanism_get_num_vars(_prop) == 23);
         /*initialize range parameters*/
-        _lmc.template fpfield<0>(_iml) = 0.12; /* gnabar */
-        _lmc.template fpfield<1>(_iml) = 0.036; /* gkbar */
-        _lmc.template fpfield<2>(_iml) = 0.0003; /* gl */
-        _lmc.template fpfield<3>(_iml) = -54.3; /* el */
+        _lmc.template fpfield<0>(_iml) = _parameter_defaults[0]; /* gnabar */
+        _lmc.template fpfield<1>(_iml) = _parameter_defaults[1]; /* gkbar */
+        _lmc.template fpfield<2>(_iml) = _parameter_defaults[2]; /* gl */
+        _lmc.template fpfield<3>(_iml) = _parameter_defaults[3]; /* el */
         _nrn_mechanism_access_dparam(_prop) = _ppvar;
         Symbol * na_sym = hoc_lookup("na_ion");
         Prop * na_prop = need_memb(na_sym);
@@ -534,6 +540,7 @@ namespace neuron {
         register_mech(mechanism_info, nrn_alloc_hodhux, nrn_cur_hodhux, nrn_jacob_hodhux, nrn_state_hodhux, nrn_init_hodhux, hoc_nrnpointerindex, 1);
 
         mech_type = nrn_get_mechtype(mechanism_info[1]);
+        hoc_register_parm_default(mech_type, &_parameter_defaults);
         _nrn_mechanism_register_data_fields(mech_type,
             _nrn_mechanism_field<double>{"gnabar"} /* 0 */,
             _nrn_mechanism_field<double>{"gkbar"} /* 1 */,

kinetic/neuron/X2Y.cpp

@@ -92,6 +92,8 @@ namespace neuron {
     static_assert(std::is_trivially_move_assignable_v<X2Y_Store>);
     static_assert(std::is_trivially_destructible_v<X2Y_Store>);
     X2Y_Store X2Y_global;
+    static std::vector<double> _parameter_defaults = {
+    };
 
 
     /** all mechanism instance variables and global variables */
@@ -388,6 +390,7 @@ namespace neuron {
         register_mech(mechanism_info, nrn_alloc_X2Y, nrn_cur_X2Y, nrn_jacob_X2Y, nrn_state_X2Y, nrn_init_X2Y, hoc_nrnpointerindex, 1);
 
         mech_type = nrn_get_mechtype(mechanism_info[1]);
+        hoc_register_parm_default(mech_type, &_parameter_defaults);
         _nrn_mechanism_register_data_fields(mech_type,
             _nrn_mechanism_field<double>{"il"} /* 0 */,
             _nrn_mechanism_field<double>{"c1"} /* 1 */,

morphology/neuron/two_radii.cpp

@@ -85,6 +85,8 @@ namespace neuron {
     static_assert(std::is_trivially_move_assignable_v<two_radii_Store>);
     static_assert(std::is_trivially_destructible_v<two_radii_Store>);
     two_radii_Store two_radii_global;
+    static std::vector<double> _parameter_defaults = {
+    };
 
 
     /** all mechanism instance variables and global variables */
@@ -352,6 +354,7 @@ namespace neuron {
         register_mech(mechanism_info, nrn_alloc_two_radii, nrn_cur_two_radii, nrn_jacob_two_radii, nrn_state_two_radii, nrn_init_two_radii, hoc_nrnpointerindex, 1);
 
         mech_type = nrn_get_mechtype(mechanism_info[1]);
+        hoc_register_parm_default(mech_type, &_parameter_defaults);
         _nrn_mechanism_register_data_fields(mech_type,
             _nrn_mechanism_field<double>{"il"} /* 0 */,
             _nrn_mechanism_field<double>{"inv"} /* 1 */,

net_event/neuron/receiver.cpp

@@ -82,6 +82,8 @@ namespace neuron {
     static_assert(std::is_trivially_move_assignable_v<receiver_Store>);
     static_assert(std::is_trivially_destructible_v<receiver_Store>);
     receiver_Store receiver_global;
+    static std::vector<double> _parameter_defaults = {
+    };
 
 
     /** all mechanism instance variables and global variables */
@@ -247,6 +249,7 @@ namespace neuron {
         _pointtype = point_register_mech(mechanism_info, nrn_alloc_receiver, nullptr, nullptr, nullptr, nrn_init_receiver, hoc_nrnpointerindex, 1, _hoc_create_pnt, _hoc_destroy_pnt, _member_func);
 
         mech_type = nrn_get_mechtype(mechanism_info[1]);
+        hoc_register_parm_default(mech_type, &_parameter_defaults);
         _nrn_mechanism_register_data_fields(mech_type,
             _nrn_mechanism_field<double>{"y"} /* 0 */,
             _nrn_mechanism_field<double>{"v_unused"} /* 1 */,

net_event/neuron/spiker.cpp

@@ -82,6 +82,8 @@ namespace neuron {
     static_assert(std::is_trivially_move_assignable_v<spiker_Store>);
     static_assert(std::is_trivially_destructible_v<spiker_Store>);
     spiker_Store spiker_global;
+    static std::vector<double> _parameter_defaults = {
+    };
 
 
     /** all mechanism instance variables and global variables */
@@ -252,6 +254,7 @@ namespace neuron {
         _pointtype = point_register_mech(mechanism_info, nrn_alloc_spiker, nullptr, nullptr, nullptr, nrn_init_spiker, hoc_nrnpointerindex, 1, _hoc_create_pnt, _hoc_destroy_pnt, _member_func);
 
         mech_type = nrn_get_mechtype(mechanism_info[1]);
+        hoc_register_parm_default(mech_type, &_parameter_defaults);
         _nrn_mechanism_register_data_fields(mech_type,
             _nrn_mechanism_field<double>{"tnext"} /* 0 */,
             _nrn_mechanism_field<double>{"v_unused"} /* 1 */,

net_move/neuron/art_spiker.cpp

@@ -83,6 +83,8 @@ namespace neuron {
     static_assert(std::is_trivially_move_assignable_v<art_spiker_Store>);
     static_assert(std::is_trivially_destructible_v<art_spiker_Store>);
     art_spiker_Store art_spiker_global;
+    static std::vector<double> _parameter_defaults = {
+    };
 
 
     /** all mechanism instance variables and global variables */
@@ -255,6 +257,7 @@ namespace neuron {
         _pointtype = point_register_mech(mechanism_info, nrn_alloc_art_spiker, nullptr, nullptr, nullptr, nrn_init_art_spiker, hoc_nrnpointerindex, 1, _hoc_create_pnt, _hoc_destroy_pnt, _member_func);
 
         mech_type = nrn_get_mechtype(mechanism_info[1]);
+        hoc_register_parm_default(mech_type, &_parameter_defaults);
         _nrn_mechanism_register_data_fields(mech_type,
             _nrn_mechanism_field<double>{"y"} /* 0 */,
             _nrn_mechanism_field<double>{"z"} /* 1 */,

net_move/neuron/spiker.cpp

@@ -83,6 +83,8 @@ namespace neuron {
     static_assert(std::is_trivially_move_assignable_v<spiker_Store>);
     static_assert(std::is_trivially_destructible_v<spiker_Store>);
     spiker_Store spiker_global;
+    static std::vector<double> _parameter_defaults = {
+    };
 
 
     /** all mechanism instance variables and global variables */
@@ -258,6 +260,7 @@ namespace neuron {
         _pointtype = point_register_mech(mechanism_info, nrn_alloc_spiker, nullptr, nullptr, nullptr, nrn_init_spiker, hoc_nrnpointerindex, 1, _hoc_create_pnt, _hoc_destroy_pnt, _member_func);
 
         mech_type = nrn_get_mechtype(mechanism_info[1]);
+        hoc_register_parm_default(mech_type, &_parameter_defaults);
         _nrn_mechanism_register_data_fields(mech_type,
             _nrn_mechanism_field<double>{"y"} /* 0 */,
             _nrn_mechanism_field<double>{"z"} /* 1 */,

net_receive/neuron/NetReceiveCalls.cpp

@@ -83,6 +83,8 @@ namespace neuron {
     static_assert(std::is_trivially_move_assignable_v<NetReceiveCalls_Store>);
     static_assert(std::is_trivially_destructible_v<NetReceiveCalls_Store>);
     NetReceiveCalls_Store NetReceiveCalls_global;
+    static std::vector<double> _parameter_defaults = {
+    };
 
 
     /** all mechanism instance variables and global variables */
@@ -313,6 +315,7 @@ namespace neuron {
         _pointtype = point_register_mech(mechanism_info, nrn_alloc_NetReceiveCalls, nullptr, nullptr, nullptr, nrn_init_NetReceiveCalls, hoc_nrnpointerindex, 1, _hoc_create_pnt, _hoc_destroy_pnt, _member_func);
 
         mech_type = nrn_get_mechtype(mechanism_info[1]);
+        hoc_register_parm_default(mech_type, &_parameter_defaults);
         _nrn_mechanism_register_data_fields(mech_type,
             _nrn_mechanism_field<double>{"c1"} /* 0 */,
             _nrn_mechanism_field<double>{"c2"} /* 1 */,

net_receive/neuron/snapsyn.cpp

@@ -83,6 +83,9 @@ namespace neuron {
     static_assert(std::is_trivially_move_assignable_v<SnapSyn_Store>);
     static_assert(std::is_trivially_destructible_v<SnapSyn_Store>);
     SnapSyn_Store SnapSyn_global;
+    static std::vector<double> _parameter_defaults = {
+        10 /* e */
+    };
 
 
     /** all mechanism instance variables and global variables */
@@ -143,7 +146,7 @@ namespace neuron {
             size_t const _iml = 0;
             assert(_nrn_mechanism_get_num_vars(_prop) == 6);
             /*initialize range parameters*/
-            _lmc.template fpfield<0>(_iml) = 10; /* e */
+            _lmc.template fpfield<0>(_iml) = _parameter_defaults[0]; /* e */
         }
         _nrn_mechanism_access_dparam(_prop) = _ppvar;
     }
@@ -303,6 +306,7 @@ namespace neuron {
         _pointtype = point_register_mech(mechanism_info, nrn_alloc_SnapSyn, nrn_cur_SnapSyn, nrn_jacob_SnapSyn, nrn_state_SnapSyn, nrn_init_SnapSyn, hoc_nrnpointerindex, 1, _hoc_create_pnt, _hoc_destroy_pnt, _member_func);
 
         mech_type = nrn_get_mechtype(mechanism_info[1]);
+        hoc_register_parm_default(mech_type, &_parameter_defaults);
         _nrn_mechanism_register_data_fields(mech_type,
             _nrn_mechanism_field<double>{"e"} /* 0 */,
             _nrn_mechanism_field<double>{"i"} /* 1 */,