tyromaniac/neurenv
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
neurenv/mech/x86_64/SK_E2_soma.cpp
Connell Paxton a0a907245a Added additional files
2026-07-11 18:20:01 -04:00

616 lines
21 KiB
C++
Raw Blame History

/* Created by Language version: 7.7.0 */
/* VECTORIZED */
#define NRN_VECTORIZED 1
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "mech_api.h"
#undef PI
#define nil 0
#define _pval pval
// clang-format off
#include "md1redef.h"
#include "section_fwd.hpp"
#include "nrniv_mf.h"
#include "md2redef.h"
#include "nrnconf.h"
// clang-format on
#include "neuron/cache/mechanism_range.hpp"
static constexpr auto number_of_datum_variables = 5;
static constexpr auto number_of_floating_point_variables = 10;
namespace {
template <typename T>
using _nrn_mechanism_std_vector = std::vector<T>;
using _nrn_model_sorted_token = neuron::model_sorted_token;
using _nrn_mechanism_cache_range = neuron::cache::MechanismRange<number_of_floating_point_variables, number_of_datum_variables>;
using _nrn_mechanism_cache_instance = neuron::cache::MechanismInstance<number_of_floating_point_variables, number_of_datum_variables>;
using _nrn_non_owning_id_without_container = neuron::container::non_owning_identifier_without_container;
template <typename T>
using _nrn_mechanism_field = neuron::mechanism::field<T>;
template <typename... Args>
void _nrn_mechanism_register_data_fields(Args&&... args) {
neuron::mechanism::register_data_fields(std::forward<Args>(args)...);
}
}
#if !NRNGPU
#undef exp
#define exp hoc_Exp
#if NRN_ENABLE_ARCH_INDEP_EXP_POW
#undef pow
#define pow hoc_pow
#endif
#endif
#define nrn_init _nrn_init__SK_E2_soma
#define _nrn_initial _nrn_initial__SK_E2_soma
#define nrn_cur _nrn_cur__SK_E2_soma
#define _nrn_current _nrn_current__SK_E2_soma
#define nrn_jacob _nrn_jacob__SK_E2_soma
#define nrn_state _nrn_state__SK_E2_soma
#define _net_receive _net_receive__SK_E2_soma
#define rates rates__SK_E2_soma
#define states states__SK_E2_soma
#define _threadargscomma_ _ml, _iml, _ppvar, _thread, _globals, _nt,
#define _threadargsprotocomma_ Memb_list* _ml, size_t _iml, Datum* _ppvar, Datum* _thread, double* _globals, NrnThread* _nt,
#define _internalthreadargsprotocomma_ _nrn_mechanism_cache_range* _ml, size_t _iml, Datum* _ppvar, Datum* _thread, double* _globals, NrnThread* _nt,
#define _threadargs_ _ml, _iml, _ppvar, _thread, _globals, _nt
#define _threadargsproto_ Memb_list* _ml, size_t _iml, Datum* _ppvar, Datum* _thread, double* _globals, NrnThread* _nt
#define _internalthreadargsproto_ _nrn_mechanism_cache_range* _ml, size_t _iml, Datum* _ppvar, Datum* _thread, double* _globals, NrnThread* _nt
/*SUPPRESS 761*/
/*SUPPRESS 762*/
/*SUPPRESS 763*/
/*SUPPRESS 765*/
extern double *hoc_getarg(int);
#define t _nt->_t
#define dt _nt->_dt
#define gSK_E2bar _ml->template fpfield<0>(_iml)
#define gSK_E2bar_columnindex 0
#define ik _ml->template fpfield<1>(_iml)
#define ik_columnindex 1
#define gSK_E2 _ml->template fpfield<2>(_iml)
#define gSK_E2_columnindex 2
#define z _ml->template fpfield<3>(_iml)
#define z_columnindex 3
#define ek _ml->template fpfield<4>(_iml)
#define ek_columnindex 4
#define cai _ml->template fpfield<5>(_iml)
#define cai_columnindex 5
#define zInf _ml->template fpfield<6>(_iml)
#define zInf_columnindex 6
#define Dz _ml->template fpfield<7>(_iml)
#define Dz_columnindex 7
#define v _ml->template fpfield<8>(_iml)
#define v_columnindex 8
#define _g _ml->template fpfield<9>(_iml)
#define _g_columnindex 9
#define _ion_ek *(_ml->dptr_field<0>(_iml))
#define _p_ion_ek static_cast<neuron::container::data_handle<double>>(_ppvar[0])
#define _ion_ik *(_ml->dptr_field<1>(_iml))
#define _p_ion_ik static_cast<neuron::container::data_handle<double>>(_ppvar[1])
#define _ion_dikdv *(_ml->dptr_field<2>(_iml))
#define _ion_cai *(_ml->dptr_field<3>(_iml))
#define _p_ion_cai static_cast<neuron::container::data_handle<double>>(_ppvar[3])
#define _ion_cao *(_ml->dptr_field<4>(_iml))
#define _p_ion_cao static_cast<neuron::container::data_handle<double>>(_ppvar[4])
/* Thread safe. No static _ml, _iml or _ppvar. */
static int hoc_nrnpointerindex = -1;
static _nrn_mechanism_std_vector<Datum> _extcall_thread;
static Prop* _extcall_prop;
/* _prop_id kind of shadows _extcall_prop to allow validity checking. */
static _nrn_non_owning_id_without_container _prop_id{};
/* external NEURON variables */
extern double celsius;
/* declaration of user functions */
static void _hoc_rates(void);
static int _mechtype;
extern void _nrn_cacheloop_reg(int, int);
extern void hoc_register_limits(int, HocParmLimits*);
extern void hoc_register_units(int, HocParmUnits*);
extern void nrn_promote(Prop*, int, int);
#define NMODL_TEXT 1
#if NMODL_TEXT
static void register_nmodl_text_and_filename(int mechtype);
#endif
static void _hoc_setdata();
/* connect user functions to hoc names */
static VoidFunc hoc_intfunc[] = {
{"setdata_SK_E2_soma", _hoc_setdata},
{"rates_SK_E2_soma", _hoc_rates},
{0, 0}
};
/* Direct Python call wrappers to density mechanism functions.*/
static double _npy_rates(Prop*);
static NPyDirectMechFunc npy_direct_func_proc[] = {
{"rates", _npy_rates},
{0, 0}
};
/* declare global and static user variables */
#define gind 0
#define _gth 0
#define zTau zTau_SK_E2_soma
double zTau = 1;
/* some parameters have upper and lower limits */
static HocParmLimits _hoc_parm_limits[] = {
{0, 0, 0}
};
static HocParmUnits _hoc_parm_units[] = {
{"zTau_SK_E2_soma", "ms"},
{"gSK_E2bar_SK_E2_soma", "mho/cm2"},
{"ik_SK_E2_soma", "mA/cm2"},
{"gSK_E2_SK_E2_soma", "S/cm2"},
{0, 0}
};
static double delta_t = 0.01;
static double z0 = 0;
/* connect global user variables to hoc */
static DoubScal hoc_scdoub[] = {
{"zTau_SK_E2_soma", &zTau_SK_E2_soma},
{0, 0}
};
static DoubVec hoc_vdoub[] = {
{0, 0, 0}
};
static double _sav_indep;
extern void _nrn_setdata_reg(int, void(*)(Prop*));
static void _setdata(Prop* _prop) {
_extcall_prop = _prop;
_prop_id = _nrn_get_prop_id(_prop);
}
static void _hoc_setdata() {
Prop *_prop, *hoc_getdata_range(int);
_prop = hoc_getdata_range(_mechtype);
_setdata(_prop);
hoc_retpushx(1.);
}
static void nrn_alloc(Prop*);
static void nrn_init(_nrn_model_sorted_token const&, NrnThread*, Memb_list*, int);
static void nrn_state(_nrn_model_sorted_token const&, NrnThread*, Memb_list*, int);
static void nrn_cur(_nrn_model_sorted_token const&, NrnThread*, Memb_list*, int);
static void nrn_jacob(_nrn_model_sorted_token const&, NrnThread*, Memb_list*, int);
static int _ode_count(int);
static void _ode_map(Prop*, int, neuron::container::data_handle<double>*, neuron::container::data_handle<double>*, double*, int);
static void _ode_spec(_nrn_model_sorted_token const&, NrnThread*, Memb_list*, int);
static void _ode_matsol(_nrn_model_sorted_token const&, NrnThread*, Memb_list*, int);
#define _cvode_ieq _ppvar[5].literal_value<int>()
static void _ode_matsol_instance1(_internalthreadargsproto_);
/* connect range variables in _p that hoc is supposed to know about */
static const char *_mechanism[] = {
"7.7.0",
"SK_E2_soma",
"gSK_E2bar_SK_E2_soma",
0,
"ik_SK_E2_soma",
"gSK_E2_SK_E2_soma",
0,
"z_SK_E2_soma",
0,
0};
static Symbol* _k_sym;
static Symbol* _ca_sym;
/* Used by NrnProperty */
static _nrn_mechanism_std_vector<double> _parm_default{
0.003869, /* gSK_E2bar */
};
extern Prop* need_memb(Symbol*);
static void nrn_alloc(Prop* _prop) {
Prop *prop_ion{};
Datum *_ppvar{};
_ppvar = nrn_prop_datum_alloc(_mechtype, 6, _prop);
_nrn_mechanism_access_dparam(_prop) = _ppvar;
_nrn_mechanism_cache_instance _ml_real{_prop};
auto* const _ml = &_ml_real;
size_t const _iml{};
assert(_nrn_mechanism_get_num_vars(_prop) == 10);
/*initialize range parameters*/
gSK_E2bar = _parm_default[0]; /* 0.003869 */
assert(_nrn_mechanism_get_num_vars(_prop) == 10);
_nrn_mechanism_access_dparam(_prop) = _ppvar;
/*connect ionic variables to this model*/
prop_ion = need_memb(_k_sym);
nrn_promote(prop_ion, 0, 1);
_ppvar[0] = _nrn_mechanism_get_param_handle(prop_ion, 0); /* ek */
_ppvar[1] = _nrn_mechanism_get_param_handle(prop_ion, 3); /* ik */
_ppvar[2] = _nrn_mechanism_get_param_handle(prop_ion, 4); /* _ion_dikdv */
prop_ion = need_memb(_ca_sym);
nrn_promote(prop_ion, 1, 0);
_ppvar[3] = _nrn_mechanism_get_param_handle(prop_ion, 1); /* cai */
_ppvar[4] = _nrn_mechanism_get_param_handle(prop_ion, 2); /* cao */
}
static void _initlists();
/* some states have an absolute tolerance */
static Symbol** _atollist;
static HocStateTolerance _hoc_state_tol[] = {
{0, 0}
};
extern Symbol* hoc_lookup(const char*);
extern void _nrn_thread_reg(int, int, void(*)(Datum*));
void _nrn_thread_table_reg(int, nrn_thread_table_check_t);
extern void hoc_register_tolerance(int, HocStateTolerance*, Symbol***);
extern void _cvode_abstol( Symbol**, double*, int);
extern "C" void _SK_E2_soma_reg() {
int _vectorized = 1;
_initlists();
ion_reg("k", -10000.);
ion_reg("ca", -10000.);
_k_sym = hoc_lookup("k_ion");
_ca_sym = hoc_lookup("ca_ion");
register_mech(_mechanism, nrn_alloc,nrn_cur, nrn_jacob, nrn_state, nrn_init, hoc_nrnpointerindex, 1);
_mechtype = nrn_get_mechtype(_mechanism[1]);
hoc_register_parm_default(_mechtype, &_parm_default);
hoc_register_npy_direct(_mechtype, npy_direct_func_proc);
_nrn_setdata_reg(_mechtype, _setdata);
#if NMODL_TEXT
register_nmodl_text_and_filename(_mechtype);
#endif
_nrn_mechanism_register_data_fields(_mechtype,
_nrn_mechanism_field<double>{"gSK_E2bar"} /* 0 */,
_nrn_mechanism_field<double>{"ik"} /* 1 */,
_nrn_mechanism_field<double>{"gSK_E2"} /* 2 */,
_nrn_mechanism_field<double>{"z"} /* 3 */,
_nrn_mechanism_field<double>{"ek"} /* 4 */,
_nrn_mechanism_field<double>{"cai"} /* 5 */,
_nrn_mechanism_field<double>{"zInf"} /* 6 */,
_nrn_mechanism_field<double>{"Dz"} /* 7 */,
_nrn_mechanism_field<double>{"v"} /* 8 */,
_nrn_mechanism_field<double>{"_g"} /* 9 */,
_nrn_mechanism_field<double*>{"_ion_ek", "k_ion"} /* 0 */,
_nrn_mechanism_field<double*>{"_ion_ik", "k_ion"} /* 1 */,
_nrn_mechanism_field<double*>{"_ion_dikdv", "k_ion"} /* 2 */,
_nrn_mechanism_field<double*>{"_ion_cai", "ca_ion"} /* 3 */,
_nrn_mechanism_field<double*>{"_ion_cao", "ca_ion"} /* 4 */,
_nrn_mechanism_field<int>{"_cvode_ieq", "cvodeieq"} /* 5 */);
hoc_register_prop_size(_mechtype, 10, 6);
hoc_register_dparam_semantics(_mechtype, 0, "k_ion");
hoc_register_dparam_semantics(_mechtype, 1, "k_ion");
hoc_register_dparam_semantics(_mechtype, 2, "k_ion");
hoc_register_dparam_semantics(_mechtype, 3, "ca_ion");
hoc_register_dparam_semantics(_mechtype, 4, "ca_ion");
hoc_register_dparam_semantics(_mechtype, 5, "cvodeieq");
hoc_register_cvode(_mechtype, _ode_count, _ode_map, _ode_spec, _ode_matsol);
hoc_register_tolerance(_mechtype, _hoc_state_tol, &_atollist);
hoc_register_var(hoc_scdoub, hoc_vdoub, hoc_intfunc);
ivoc_help("help ?1 SK_E2_soma /home/qh4os/neurenv/mech/SK_E2_soma.mod\n");
hoc_register_limits(_mechtype, _hoc_parm_limits);
hoc_register_units(_mechtype, _hoc_parm_units);
}
static int _reset;
static const char *modelname = "";
static int error;
static int _ninits = 0;
static int _match_recurse=1;
static void _modl_cleanup(){ _match_recurse=1;}
static int rates(_internalthreadargsprotocomma_ double);
static int _ode_spec1(_internalthreadargsproto_);
/*static int _ode_matsol1(_internalthreadargsproto_);*/
static neuron::container::field_index _slist1[1], _dlist1[1];
static int states(_internalthreadargsproto_);
/*CVODE*/
static int _ode_spec1 (_internalthreadargsproto_) {int _reset = 0; {
rates ( _threadargscomma_ cai ) ;
Dz = ( zInf - z ) / zTau ;
}
return _reset;
}
static int _ode_matsol1 (_internalthreadargsproto_) {
rates ( _threadargscomma_ cai ) ;
Dz = Dz / (1. - dt*( ( ( ( - 1.0 ) ) ) / zTau )) ;
return 0;
}
/*END CVODE*/
static int states (_internalthreadargsproto_) { {
rates ( _threadargscomma_ cai ) ;
z = z + (1. - exp(dt*(( ( ( - 1.0 ) ) ) / zTau)))*(- ( ( ( zInf ) ) / zTau ) / ( ( ( ( - 1.0 ) ) ) / zTau ) - z) ;
}
return 0;
}
static int rates ( _internalthreadargsprotocomma_ double _lca ) {
if ( _lca < 1e-7 ) {
_lca = _lca + 1e-07 ;
}
zInf = 1.0 / ( 1.0 + pow( ( 0.00043 / _lca ) , 4.8 ) ) ;
return 0; }
static void _hoc_rates(void) {
double _r;
Datum* _ppvar; Datum* _thread; NrnThread* _nt;
Prop* _local_prop = _prop_id ? _extcall_prop : nullptr;
_nrn_mechanism_cache_instance _ml_real{_local_prop};
auto* const _ml = &_ml_real;
size_t const _iml{};
_ppvar = _local_prop ? _nrn_mechanism_access_dparam(_local_prop) : nullptr;
_thread = _extcall_thread.data();
double* _globals = nullptr;
if (gind != 0 && _thread != nullptr) { _globals = _thread[_gth].get<double*>(); }
_nt = nrn_threads;
_r = 1.;
rates ( _threadargscomma_ *getarg(1) );
hoc_retpushx(_r);
}
static double _npy_rates(Prop* _prop) {
double _r{0.0};
Datum* _ppvar; Datum* _thread; NrnThread* _nt;
_nrn_mechanism_cache_instance _ml_real{_prop};
auto* const _ml = &_ml_real;
size_t const _iml{};
_ppvar = _nrn_mechanism_access_dparam(_prop);
_thread = _extcall_thread.data();
double* _globals = nullptr;
if (gind != 0 && _thread != nullptr) { _globals = _thread[_gth].get<double*>(); }
_nt = nrn_threads;
_r = 1.;
rates ( _threadargscomma_ *getarg(1) );
return(_r);
}
static int _ode_count(int _type){ return 1;}
static void _ode_spec(_nrn_model_sorted_token const& _sorted_token, NrnThread* _nt, Memb_list* _ml_arg, int _type) {
Datum* _ppvar;
size_t _iml; _nrn_mechanism_cache_range* _ml; Node* _nd{};
double _v{};
int _cntml;
_nrn_mechanism_cache_range _lmr{_sorted_token, *_nt, *_ml_arg, _type};
_ml = &_lmr;
_cntml = _ml_arg->_nodecount;
Datum *_thread{_ml_arg->_thread};
double* _globals = nullptr;
if (gind != 0 && _thread != nullptr) { _globals = _thread[_gth].get<double*>(); }
for (_iml = 0; _iml < _cntml; ++_iml) {
_ppvar = _ml_arg->_pdata[_iml];
_nd = _ml_arg->_nodelist[_iml];
v = NODEV(_nd);
ek = _ion_ek;
cai = _ion_cai;
_ode_spec1 (_threadargs_);
}}
static void _ode_map(Prop* _prop, int _ieq, neuron::container::data_handle<double>* _pv, neuron::container::data_handle<double>* _pvdot, double* _atol, int _type) {
Datum* _ppvar;
_ppvar = _nrn_mechanism_access_dparam(_prop);
_cvode_ieq = _ieq;
for (int _i=0; _i < 1; ++_i) {
_pv[_i] = _nrn_mechanism_get_param_handle(_prop, _slist1[_i]);
_pvdot[_i] = _nrn_mechanism_get_param_handle(_prop, _dlist1[_i]);
_cvode_abstol(_atollist, _atol, _i);
}
}
static void _ode_matsol_instance1(_internalthreadargsproto_) {
_ode_matsol1 (_threadargs_);
}
static void _ode_matsol(_nrn_model_sorted_token const& _sorted_token, NrnThread* _nt, Memb_list* _ml_arg, int _type) {
Datum* _ppvar;
size_t _iml; _nrn_mechanism_cache_range* _ml; Node* _nd{};
double _v{};
int _cntml;
_nrn_mechanism_cache_range _lmr{_sorted_token, *_nt, *_ml_arg, _type};
_ml = &_lmr;
_cntml = _ml_arg->_nodecount;
Datum *_thread{_ml_arg->_thread};
double* _globals = nullptr;
if (gind != 0 && _thread != nullptr) { _globals = _thread[_gth].get<double*>(); }
for (_iml = 0; _iml < _cntml; ++_iml) {
_ppvar = _ml_arg->_pdata[_iml];
_nd = _ml_arg->_nodelist[_iml];
v = NODEV(_nd);
ek = _ion_ek;
cai = _ion_cai;
_ode_matsol_instance1(_threadargs_);
}}
static void initmodel(_internalthreadargsproto_) {
int _i; double _save;{
z = z0;
{
rates ( _threadargscomma_ cai ) ;
z = zInf ;
}
}
}
static void nrn_init(_nrn_model_sorted_token const& _sorted_token, NrnThread* _nt, Memb_list* _ml_arg, int _type){
_nrn_mechanism_cache_range _lmr{_sorted_token, *_nt, *_ml_arg, _type};
auto* const _vec_v = _nt->node_voltage_storage();
auto* const _ml = &_lmr;
Datum* _ppvar; Datum* _thread;
Node *_nd; double _v; int* _ni; int _iml, _cntml;
_ni = _ml_arg->_nodeindices;
_cntml = _ml_arg->_nodecount;
_thread = _ml_arg->_thread;
double* _globals = nullptr;
if (gind != 0 && _thread != nullptr) { _globals = _thread[_gth].get<double*>(); }
for (_iml = 0; _iml < _cntml; ++_iml) {
_ppvar = _ml_arg->_pdata[_iml];
_v = _vec_v[_ni[_iml]];
v = _v;
ek = _ion_ek;
cai = _ion_cai;
initmodel(_threadargs_);
}
}
static double _nrn_current(_internalthreadargsprotocomma_ double _v) {
double _current=0.; v=_v;
{ {
gSK_E2 = gSK_E2bar * z ;
ik = gSK_E2 * ( v - ek ) ;
}
_current += ik;
} return _current;
}
static void nrn_cur(_nrn_model_sorted_token const& _sorted_token, NrnThread* _nt, Memb_list* _ml_arg, int _type) {
_nrn_mechanism_cache_range _lmr{_sorted_token, *_nt, *_ml_arg, _type};
auto const _vec_rhs = _nt->node_rhs_storage();
auto const _vec_sav_rhs = _nt->node_sav_rhs_storage();
auto const _vec_v = _nt->node_voltage_storage();
auto* const _ml = &_lmr;
Datum* _ppvar; Datum* _thread;
Node *_nd; int* _ni; double _rhs, _v; int _iml, _cntml;
_ni = _ml_arg->_nodeindices;
_cntml = _ml_arg->_nodecount;
_thread = _ml_arg->_thread;
double* _globals = nullptr;
if (gind != 0 && _thread != nullptr) { _globals = _thread[_gth].get<double*>(); }
for (_iml = 0; _iml < _cntml; ++_iml) {
_ppvar = _ml_arg->_pdata[_iml];
_v = _vec_v[_ni[_iml]];
ek = _ion_ek;
cai = _ion_cai;
auto const _g_local = _nrn_current(_threadargscomma_ _v + .001);
{ double _dik;
_dik = ik;
_rhs = _nrn_current(_threadargscomma_ _v);
_ion_dikdv += (_dik - ik)/.001 ;
}
_g = (_g_local - _rhs)/.001;
_ion_ik += ik ;
_vec_rhs[_ni[_iml]] -= _rhs;
}
}
static void nrn_jacob(_nrn_model_sorted_token const& _sorted_token, NrnThread* _nt, Memb_list* _ml_arg, int _type) {
_nrn_mechanism_cache_range _lmr{_sorted_token, *_nt, *_ml_arg, _type};
auto const _vec_d = _nt->node_d_storage();
auto const _vec_sav_d = _nt->node_sav_d_storage();
auto* const _ml = &_lmr;
Datum* _ppvar; Datum* _thread;
Node *_nd; int* _ni; int _iml, _cntml;
_ni = _ml_arg->_nodeindices;
_cntml = _ml_arg->_nodecount;
_thread = _ml_arg->_thread;
double* _globals = nullptr;
if (gind != 0 && _thread != nullptr) { _globals = _thread[_gth].get<double*>(); }
for (_iml = 0; _iml < _cntml; ++_iml) {
_vec_d[_ni[_iml]] += _g;
}
}
static void nrn_state(_nrn_model_sorted_token const& _sorted_token, NrnThread* _nt, Memb_list* _ml_arg, int _type) {
_nrn_mechanism_cache_range _lmr{_sorted_token, *_nt, *_ml_arg, _type};
auto* const _vec_v = _nt->node_voltage_storage();
auto* const _ml = &_lmr;
Datum* _ppvar; Datum* _thread;
Node *_nd; double _v = 0.0; int* _ni;
_ni = _ml_arg->_nodeindices;
size_t _cntml = _ml_arg->_nodecount;
_thread = _ml_arg->_thread;
double* _globals = nullptr;
if (gind != 0 && _thread != nullptr) { _globals = _thread[_gth].get<double*>(); }
for (size_t _iml = 0; _iml < _cntml; ++_iml) {
_ppvar = _ml_arg->_pdata[_iml];
_nd = _ml_arg->_nodelist[_iml];
_v = _vec_v[_ni[_iml]];
v=_v;
{
ek = _ion_ek;
cai = _ion_cai;
{ states(_threadargs_);
} }}
}
static void terminal(){}
static void _initlists(){
int _i; static int _first = 1;
if (!_first) return;
_slist1[0] = {z_columnindex, 0}; _dlist1[0] = {Dz_columnindex, 0};
_first = 0;
}
#if NMODL_TEXT
static void register_nmodl_text_and_filename(int mech_type) {
const char* nmodl_filename = "/home/qh4os/neurenv/mech/SK_E2_soma.mod";
const char* nmodl_file_text =
":Comment : L6\n"
": SK-type calcium-activated potassium current\n"
": Reference : Kohler et al. 1996\n"
"\n"
"NEURON {\n"
" SUFFIX SK_E2_soma\n"
" USEION k READ ek WRITE ik\n"
" USEION ca READ cai\n"
" RANGE gSK_E2bar, gSK_E2, ik\n"
"}\n"
"\n"
"UNITS {\n"
" (mV) = (millivolt)\n"
" (mA) = (milliamp)\n"
" (mM) = (milli/liter)\n"
"}\n"
"\n"
"PARAMETER {\n"
" v (mV)\n"
" gSK_E2bar = 0.003869 (mho/cm2)\n"
" zTau = 1 (ms)\n"
" ek (mV)\n"
" cai (mM)\n"
"}\n"
"\n"
"ASSIGNED {\n"
" zInf\n"
" ik (mA/cm2)\n"
" gSK_E2 (S/cm2)\n"
" celsius (degC)\n"
"}\n"
"\n"
"STATE {\n"
" z FROM 0 TO 1\n"
"}\n"
"\n"
"BREAKPOINT {\n"
" SOLVE states METHOD cnexp\n"
" gSK_E2 = gSK_E2bar * z\n"
" ik = gSK_E2 * (v - ek)\n"
"}\n"
"\n"
"DERIVATIVE states {\n"
" rates(cai)\n"
" z' = (zInf - z) / zTau\n"
"}\n"
"\n"
"PROCEDURE rates(ca(mM)) {\n"
" if(ca < 1e-7){\n"
" ca = ca + 1e-07\n"
" }\n"
" zInf = 1/(1 + (0.00043 / ca)^4.8)\n"
"}\n"
"\n"
"INITIAL {\n"
" rates(cai)\n"
" z = zInf\n"
"}\n"
;
hoc_reg_nmodl_filename(mech_type, nmodl_filename);
hoc_reg_nmodl_text(mech_type, nmodl_file_text);
}
#endif
Reference in New Issue View Git Blame Copy Permalink