def build_Mod(cls, leakChl, modFileSet): baseWriter = MM_ModFileWriterBase(suffix=leakChl.getNeuronSuffix()) gbarName = "gLk" eRevName = "eLk" gScaleName = "gScale" gbarUnits = MM_WriterLeak.Units[gbarName] eRevUnits = MM_WriterLeak.Units[eRevName] # Parameters: # {name: (value, unit,range)} baseWriter.parameters = { gbarName: (leakChl.conductance.rescale( gbarUnits ).magnitude, (gbarUnits), None), eRevName: (leakChl.reversalpotential.rescale(eRevUnits).magnitude, (eRevUnits), None), gScaleName: (1.0, None, None) } baseWriter.currentequation = "(v-%s) * %s * %s" % (eRevName, gbarName, gScaleName) baseWriter.conductanceequation = "%s * %s" % (gbarName, gScaleName) modtxt = baseWriter.GenerateModFile() modFile = ModFile(name=leakChl.name, modtxt=modtxt) modFileSet.append(modFile)
def build_mod(cls, leak_chl, modfile_set): base_writer = MM_ModFileWriterBase(suffix=leak_chl.get_neuron_suffix()) gbar_name = 'gLk' e_rev_name = 'eLk' g_scale_name = 'gScale' gbar_units = NEURONChlWriterLeak.Units[gbar_name] e_rev_units = NEURONChlWriterLeak.Units[e_rev_name] # Parameters: # {name: (value, unit, range)} base_writer.parameters = { gbar_name: (leak_chl.conductance.rescale(gbar_units).magnitude, (gbar_units), None), e_rev_name: (leak_chl.reversalpotential.rescale(e_rev_units).magnitude, (e_rev_units), None), g_scale_name: (1.0, None, None) } base_writer.currentequation = '(v-%s) * %s * %s' % (e_rev_name, gbar_name, g_scale_name) base_writer.conductanceequation = '%s * %s' % (gbar_name, g_scale_name) modtxt = base_writer.generate_modfile() mod_file = ModFile(name=leak_chl.name, modtxt=modtxt) modfile_set.append(mod_file)
def build_mod(cls, alphabeta_beta_chl, modfile_set): gbar_name = 'gBar' e_rev_name = 'eLk' g_scale_name = 'gScale' base_writer = MM_ModFileWriterBase(suffix=alphabeta_beta_chl.get_neuron_suffix()) # Naming Conventions: state_tau = lambda s: '%stau' % s state_inf = lambda s: '%sinf' % s state_alpha = lambda s: '%s_alpha' % s state_beta = lambda s: '%s_beta' % s # State Equations and initial values: for s in alphabeta_beta_chl.statevars: base_writer.internalstates[s] = "%s" % state_inf(s) , "%s'=(%s-%s)/%s" % (s, state_inf(s), s, state_tau(s)) # Parameters: # {name: (value, unit, range)} base_writer.parameters = { #gbar_name: (alphabeta_beta_chl.conductance.toval(ounit="S/cm2"), ("S/cm2"), None), #e_rev_name: (alphabeta_beta_chl.reversalpotential.toval("mV"), ("mV"), None) gbar_name: (alphabeta_beta_chl.conductance.rescale("S/cm2").magnitude, ("S/cm2"), None), e_rev_name: (alphabeta_beta_chl.reversalpotential.rescale("mV").magnitude, ("mV"), None), g_scale_name: (1.0, None, None) } # Rates: # name : (locals, code), unit for s in alphabeta_beta_chl.statevars: base_writer.rates[state_alpha(s)] = (("", state_alpha(s) + "= StdAlphaBeta(%f, %f, %f, %f, %f, v)" % tuple(alphabeta_beta_chl.statevars[s][0]))), None #base_writer.rates[state_beta(s)] = (("", state_beta(s) + "= StdBetaBeta(%f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, v)" % tuple(alphabeta_beta_chl.statevars[s][1] + alphabeta_beta_chl.statevars[s][2] + [alphabeta_beta_chl.beta2threshold.toval(ounit="mV")]))), None base_writer.rates[state_beta(s)] = (("", state_beta(s) + "= StdBetaBeta(%f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, v)" % tuple(alphabeta_beta_chl.statevars[s][1] + alphabeta_beta_chl.statevars[s][2] + [alphabeta_beta_chl.beta2threshold.rescale("mV").magnitude]))), None base_writer.rates[state_inf(s)] = (("", state_inf(s) + "= %s/(%s+%s)" % (state_alpha(s), state_alpha(s), state_beta(s))), None) base_writer.rates[state_tau(s)] = (("", state_tau(s) + "= 1.0/(%s+%s)" % (state_alpha(s), state_beta(s))), "ms") base_writer.ratecalcorder.extend([state_alpha(s), state_beta(s), state_inf(s), state_tau(s)]) base_writer.currentequation = "(v-%s) * %s * %s * %s" % (e_rev_name, gbar_name, alphabeta_beta_chl.eqn, g_scale_name) base_writer.conductanceequation = "%s * %s * %s" % (gbar_name, alphabeta_beta_chl.eqn, g_scale_name) #base_writer.currentequation = "(v-%s) * %s * %s" % (e_rev_name, gbar_name, alphabeta_beta_chl.eqn) base_writer.functions = """ FUNCTION StdAlphaBeta(A, B, C, D, E, V){ StdAlphaBeta = (A + B*V) / (C + exp((D+V)/E)) } FUNCTION StdBetaBeta(A, B, C, D, E, A2, B2, C2, D2, E2, beta2Threshold, V) { if(V < beta2Threshold) { StdBetaBeta = (A + B*V) / (C + exp((D+V)/E)) } else { StdBetaBeta = (A2 + B2*V) / (C2 + exp((D2+V)/E2)) } } """ txt = base_writer.generate_modfile() mod_file = ModFile(name=alphabeta_beta_chl.name, modtxt=txt) modfile_set.append(mod_file)
def build_Mod(cls, alphaBetaChl, modFileSet): gbarName = "gBar" eRevName = "eRev" gScaleName = "gScale" #gbarUnits = MM_WriterAlphaBeta.Units[gbarName] #eRevUnits = MM_WriterAlphaBeta.Units[eRevName] baseWriter = MM_ModFileWriterBase(suffix=alphaBetaChl.getNeuronSuffix()) # Naming Conventions: stateTau = lambda s: "%stau" % s stateInf = lambda s: "%sinf" % s stateAlpha = lambda s: "%s_alpha" % s stateBeta = lambda s: "%s_beta" % s #gbarName = "g%sbar" % alphaBetaChl.ion #eRevName = "e%s" % alphaBetaChl.ion # State Equations and initial values: for s in alphaBetaChl.statevars: baseWriter.internalstates[s] = "%s" % stateInf(s) , "%s'=(%s-%s)/%s" % (s, stateInf(s), s, stateTau(s)) # Parameters: # {name: (value, unit,range)} baseWriter.parameters = { gbarName: (alphaBetaChl.conductance.rescale("S/cm2").magnitude, ("S/cm2"), None), eRevName: (alphaBetaChl.reversalpotential.rescale("mV").magnitude, ("mV"), None), gScaleName: (1.0, None, None) } # Rates: # name : (locals, code), unit for s in alphaBetaChl.statevars: baseWriter.rates[ stateAlpha(s) ] = (("", stateAlpha(s) + "= StdAlphaBeta( %f,%f,%f,%f,%f, v)" % tuple(alphaBetaChl.statevars[s][0]))), None baseWriter.rates[ stateBeta(s) ] = (("", stateBeta(s) + "= StdAlphaBeta( %f,%f,%f,%f,%f, v)" % tuple(alphaBetaChl.statevars[s][1]))), None baseWriter.rates[ stateInf(s) ] = (("", stateInf(s) + "= %s/(%s+%s)" % (stateAlpha(s), stateAlpha(s), stateBeta(s))), None) baseWriter.rates[ stateTau(s) ] = (("", stateTau(s) + "= 1.0/(%s+%s)" % (stateAlpha(s), stateBeta(s))), "ms") baseWriter.ratecalcorder.extend([stateAlpha(s), stateBeta(s), stateInf(s), stateTau(s)]) baseWriter.currentequation = "(v-%s) * %s * %s * %s" % (eRevName, gbarName, alphaBetaChl.eqn, gScaleName) baseWriter.conductanceequation = " %s * %s * %s" % (gbarName, alphaBetaChl.eqn, gScaleName) baseWriter.functions = """FUNCTION StdAlphaBeta(A,B,C,D,E,V){ StdAlphaBeta = (A + B*V) / (C + exp((D+V)/E)) } """ txt = baseWriter.GenerateModFile() modFile = ModFile(name=alphaBetaChl.name, modtxt=txt ) modFileSet.append(modFile)
def build_mod(cls, alphabeta_chl, modfile_set): gbar_name = 'gBar' e_rev_name = 'e_rev' g_scale_name = 'gScale' # gbarUnits = NEURONChlWriterAlphaBeta.Units[gbar_name] # eRevUnits = NEURONChlWriterAlphaBeta.Units[e_rev_name] base_writer = MM_ModFileWriterBase(suffix=alphabeta_chl.get_neuron_suffix()) # Naming Conventions: state_tau = lambda s: '%stau' % s state_inf = lambda s: '%sinf' % s state_alpha = lambda s: '%s_alpha' % s state_beta = lambda s: '%s_beta' % s # State Equations and initial values: for s in alphabeta_chl.statevars: base_writer.internalstates[s] = "%s" % state_inf(s) , "%s'=(%s-%s)/%s" % (s, state_inf(s), s, state_tau(s)) # Parameters: # {name: (value, unit, range)} base_writer.parameters = { gbar_name: (alphabeta_chl.conductance.rescale("S/cm2").magnitude, ("S/cm2"), None), e_rev_name: (alphabeta_chl.reversalpotential.rescale("mV").magnitude, ("mV"), None), g_scale_name: (1.0, None, None) } # Rates: # name : (locals, code), unit for s in alphabeta_chl.statevars: base_writer.rates[state_alpha(s)] = (("", state_alpha(s) + "= StdAlphaBeta(%f, %f, %f, %f, %f, v)" % tuple(alphabeta_chl.statevars[s][0]))), None base_writer.rates[state_beta(s)] = (("", state_beta(s) + "= StdAlphaBeta(%f, %f, %f, %f, %f, v)" % tuple(alphabeta_chl.statevars[s][1]))), None base_writer.rates[state_inf(s)] = (("", state_inf(s) + "= %s/(%s+%s)" % (state_alpha(s), state_alpha(s), state_beta(s))), None) base_writer.rates[state_tau(s)] = (("", state_tau(s) + "= 1.0/(%s+%s)" % (state_alpha(s), state_beta(s))), "ms") base_writer.ratecalcorder.extend([state_alpha(s), state_beta(s), state_inf(s), state_tau(s)]) base_writer.currentequation = "(v-%s) * %s * %s * %s" % (e_rev_name, gbar_name, alphabeta_chl.eqn, g_scale_name) base_writer.conductanceequation = "%s * %s * %s" % (gbar_name, alphabeta_chl.eqn, g_scale_name) base_writer.functions = """FUNCTION StdAlphaBeta(A, B, C, D, E, V){ StdAlphaBeta = (A + B*V) / (C + exp((D+V)/E)) } """ txt = base_writer.generate_modfile() mod_file = ModFile(name=alphabeta_chl.name, modtxt=txt, strict_modlunit=True) modfile_set.append(mod_file)
def build_mod(cls, alphabeta_chl, modfile_set): gbar_name = 'gBar' e_rev_name = 'e_rev' g_scale_name = 'gScale' # gbarUnits = NEURONChlWriterAlphaBeta.Units[gbar_name] # eRevUnits = NEURONChlWriterAlphaBeta.Units[e_rev_name] base_writer = MM_ModFileWriterBase( suffix=alphabeta_chl.get_neuron_suffix()) # Naming Conventions: state_tau = lambda s: '%stau' % s state_inf = lambda s: '%sinf' % s state_alpha = lambda s: '%s_alpha' % s state_beta = lambda s: '%s_beta' % s # State Equations and initial values: for s in alphabeta_chl.statevars: base_writer.internalstates[s] = "%s" % state_inf( s), "%s'=(%s-%s)/%s" % (s, state_inf(s), s, state_tau(s)) # Parameters: # {name: (value, unit, range)} base_writer.parameters = { gbar_name: (alphabeta_chl.conductance.rescale("S/cm2").magnitude, ("S/cm2"), None), e_rev_name: (alphabeta_chl.reversalpotential.rescale("mV").magnitude, ("mV"), None), g_scale_name: (1.0, None, None) } # Rates: # name : (locals, code), unit for s in alphabeta_chl.statevars: base_writer.rates[state_alpha(s)] = ( ("", state_alpha(s) + "= StdAlphaBeta(%f, %f, %f, %f, %f, v)" % tuple(alphabeta_chl.statevars[s][0]))), None base_writer.rates[state_beta(s)] = ( ("", state_beta(s) + "= StdAlphaBeta(%f, %f, %f, %f, %f, v)" % tuple(alphabeta_chl.statevars[s][1]))), None base_writer.rates[state_inf(s)] = ( ("", state_inf(s) + "= %s/(%s+%s)" % (state_alpha(s), state_alpha(s), state_beta(s))), None) base_writer.rates[state_tau(s)] = ( ("", state_tau(s) + "= 1.0/(%s+%s)" % (state_alpha(s), state_beta(s))), "ms") base_writer.ratecalcorder.extend( [state_alpha(s), state_beta(s), state_inf(s), state_tau(s)]) base_writer.currentequation = "(v-%s) * %s * %s * %s" % ( e_rev_name, gbar_name, alphabeta_chl.eqn, g_scale_name) base_writer.conductanceequation = "%s * %s * %s" % ( gbar_name, alphabeta_chl.eqn, g_scale_name) base_writer.functions = """FUNCTION StdAlphaBeta(A, B, C, D, E, V){ StdAlphaBeta = (A + B*V) / (C + exp((D+V)/E)) } """ txt = base_writer.generate_modfile() mod_file = ModFile(name=alphabeta_chl.name, modtxt=txt) modfile_set.append(mod_file)
def build_mod(cls, alphabeta_chl, modfile_set): gbar_name = 'gBar' e_rev_name = 'e_rev' g_scale_name = 'gScale' base_writer = \ MM_ModFileWriterBase(suffix=alphabeta_chl.get_neuron_suffix()) # Naming Conventions: state_tau = lambda s: '%stau' % s state_inf = lambda s: '%sinf' % s # State Equations and initial values: for s in alphabeta_chl.statevars_new: base_writer.internalstates[s] = '%s' % state_inf(s), "%s'=(%s-%s)/%s" % (s, state_inf(s), s, state_tau(s)) # Parameters: # {name: (value, unit, range)} base_writer.parameters = { gbar_name: (alphabeta_chl.conductance.rescale("S/cm2").magnitude, ("S/cm2"), None), e_rev_name: (alphabeta_chl.reversalpotential.rescale("mV").magnitude, ("mV"), None), g_scale_name: (1.0, None, None) } # Rates: # name : (locals, code), unit for s in alphabeta_chl.statevars_new: base_writer.rates[state_inf(s)] = (('', state_inf(s) + "= %sInf(v)" % state_inf(s)), None) base_writer.rates[state_tau(s)] = (('', state_tau(s) + "= %sTau(v)" % state_tau(s)), "ms") base_writer.ratecalcorder.extend([state_inf(s), state_tau(s)]) base_writer.currentequation = '(v-%s) * %s * %s * %s' % (e_rev_name, gbar_name, alphabeta_chl.eqn, g_scale_name) base_writer.conductanceequation = '%s * %s * %s' % (gbar_name, alphabeta_chl.eqn, g_scale_name) base_writer.functions = """ VERBATIM #include <gsl_wrapper.h> ENDVERBATIM""" def buildInterpolatorFunc(state, inftau, funcname): if inftau == 'inf': interp_str_x = ','.join(['%2.2f' % x for x in alphabeta_chl.statevars_new[s].V]) interp_str_y = ','.join(['%2.2f' % x for x in alphabeta_chl.statevars_new[s].inf]) elif inftau == 'tau': interp_str_x = ','.join(['%2.2f' % x for x in alphabeta_chl.statevars_new[s].V]) interp_str_y = ','.join(['%2.2f' % x for x in alphabeta_chl.statevars_new[s].tau]) else: assert False variables = {'chlname':state_tau(s), 'nPts':len(alphabeta_chl.statevars_new[s].V), 'x0':interp_str_x, 'y0':interp_str_y, 'funcname':funcname } f = """ FUNCTION %(funcname)s(V) { VERBATIM { static void* pInterpolator = NULL; if(!pInterpolator) { double x[%(nPts)s] = { %(x0)s }; double y[%(nPts)s] = { %(y0)s }; int nPts = %(nPts)d; pInterpolator = makeIntWrapper(x, y, nPts); } _l%(funcname)s= interpolate2(_lV, pInterpolator); } ENDVERBATIM } \n\n""" % variables return f for s in alphabeta_chl.statevars_new: base_writer.functions += buildInterpolatorFunc(state=s, inftau='inf', funcname='%sinfInf' % s) base_writer.functions += buildInterpolatorFunc(state=s, inftau='tau', funcname='%stauTau' % s) txt = base_writer.generate_modfile() # TODO: Remove hard dependancy here from morphforge.stdimports import RCMgr additional_compile_flags = RCMgr.get('Neuron','additional_compile_flags') #"-I/home/michael/hw_to_come/morphforge/src/morphforgecontrib/simulation/neuron_gsl/cpp" additional_link_flags = RCMgr.get('Neuron','additional_link_flags') # "-L/home/michael/hw_to_come/morphforge/src/morphforgecontrib/simulation/neuron_gsl/cpp -lgslwrapper -lgsl -lgslcblas" mod_file = ModFile(name=alphabeta_chl.name, modtxt=txt, additional_compile_flags=additional_compile_flags, additional_link_flags=additional_link_flags) modfile_set.append(mod_file)
def build_mod(cls, alphabeta_chl, modfile_set): gbar_name = 'gBar' e_rev_name = 'e_rev' g_scale_name = 'gScale' base_writer = \ MM_ModFileWriterBase(suffix=alphabeta_chl.get_neuron_suffix()) # Naming Conventions: state_tau = lambda s: '%stau' % s state_inf = lambda s: '%sinf' % s # State Equations and initial values: for s in alphabeta_chl.statevars_new: base_writer.internalstates[s] = '%s' % state_inf( s), "%s'=(%s-%s)/%s" % (s, state_inf(s), s, state_tau(s)) # Parameters: # {name: (value, unit, range)} base_writer.parameters = { gbar_name: (alphabeta_chl.conductance.rescale("S/cm2").magnitude, ("S/cm2"), None), e_rev_name: (alphabeta_chl.reversalpotential.rescale("mV").magnitude, ("mV"), None), g_scale_name: (1.0, None, None) } # Rates: # name : (locals, code), unit for s in alphabeta_chl.statevars_new: base_writer.rates[state_inf(s)] = (('', state_inf(s) + "= %sInf(v)" % state_inf(s)), None) base_writer.rates[state_tau(s)] = (('', state_tau(s) + "= %sTau(v)" % state_tau(s)), "ms") base_writer.ratecalcorder.extend([state_inf(s), state_tau(s)]) base_writer.currentequation = '(v-%s) * %s * %s * %s' % ( e_rev_name, gbar_name, alphabeta_chl.eqn, g_scale_name) base_writer.conductanceequation = '%s * %s * %s' % ( gbar_name, alphabeta_chl.eqn, g_scale_name) base_writer.functions = """ VERBATIM #include <gsl_wrapper.h> ENDVERBATIM""" def buildInterpolatorFunc(state, inftau, funcname): if inftau == 'inf': interp_str_x = ','.join( ['%2.2f' % x for x in alphabeta_chl.statevars_new[s].V]) interp_str_y = ','.join( ['%2.2f' % x for x in alphabeta_chl.statevars_new[s].inf]) elif inftau == 'tau': interp_str_x = ','.join( ['%2.2f' % x for x in alphabeta_chl.statevars_new[s].V]) interp_str_y = ','.join( ['%2.2f' % x for x in alphabeta_chl.statevars_new[s].tau]) else: assert False variables = { 'chlname': state_tau(s), 'nPts': len(alphabeta_chl.statevars_new[s].V), 'x0': interp_str_x, 'y0': interp_str_y, 'funcname': funcname } f = """ FUNCTION %(funcname)s(V) { VERBATIM { static void* pInterpolator = NULL; if(!pInterpolator) { double x[%(nPts)s] = { %(x0)s }; double y[%(nPts)s] = { %(y0)s }; int nPts = %(nPts)d; pInterpolator = makeIntWrapper(x, y, nPts); } _l%(funcname)s= interpolate2(_lV, pInterpolator); } ENDVERBATIM } \n\n""" % variables return f for s in alphabeta_chl.statevars_new: base_writer.functions += buildInterpolatorFunc( state=s, inftau='inf', funcname='%sinfInf' % s) base_writer.functions += buildInterpolatorFunc( state=s, inftau='tau', funcname='%stauTau' % s) txt = base_writer.generate_modfile() # TODO: Remove hard dependancy here additional_compile_flags = "-I/home/michael/hw_to_come/morphforge/src/morphforgecontrib/simulation/neuron_gsl/cpp" additional_link_flags = "-L/home/michael/hw_to_come/morphforge/src/morphforgecontrib/simulation/neuron_gsl/cpp -lgslwrapper -lgsl -lgslcblas" mod_file = ModFile(name=alphabeta_chl.name, modtxt=txt, additional_compile_flags=additional_compile_flags, additional_link_flags=additional_link_flags) modfile_set.append(mod_file)