/***************************************************************************** This file contains functions implementing a linear distribution of channel conductances. Christina Weaver Feb 2006 last updated Jun '07 NOTE: NEURON does not consider the values 0 and 1 to be separate nodes. Instead, the values of any range variables at those points is equal to the value assumed at the nearest node. As a result there will be a slight discontinuity of the linear variation of the range variables at section ends. To minimize this discontinuity you can increase NSEG in all the sections, but be warned that this could cause your simulations to run much more slowly. Procedures defined below include: applysec_slope() After the appropriate slope and intercept have been determined for this particular section, apply the linear function to the desired range variable. assign_slope2all() Write a matlab file that determines the appropriate conductance parameters throughout the dendrite, to apply the specified global conductance slope and intercept to the entire dendrite. No parameter values are actually changed in this procedure. BParea() Calculate the area between the backpropagation curve and the straight line V = minV (default -80). This is measured in each segment as the maximum voltage observed over the entire simulation. calc_global_slope() Given the conductance values of the proximal and distal dendritic sections, calculate the appropriate slope from these values and the length of the dendrite. findsec_slope() Determine the appropriate slope and intercept for this section, and apply the linear change to the section. linear_bakerKCAdec_ratios() Apply the conductance ratios referred to as "bakerKCAdec" linearly throughout the dendrite. print_cond_linscale() Print the conductance values with distance for all neuron compartments. set_cond_linear() Apply this global slope and intercept to the specified conductance type, for all dendritic segments. total_dend_cond() Calculate the total amount of conductance of the specified channel type. That is, multiply g_bar * surface area of each dendritic section. *****************************************************************************/ objref fin VERBOSE = 0 most_distal = 0 most_proximal = 0 /****************************************************************** applysec_slope() After the appropriate slope and intercept have been determined for this particular section, apply the linear function to the desired range variable. If the proposed conductance value is negative, it is instead set to zero. input $s1 section name $2 slope $3 intercept $4 index of range variable 0 : gbar_naf 1 : gbar_kdr 2 : gbar_kc 3 : phi_cad // not a range variable (phi equivalent to Kp_cad from Av-Ron) 4 : beta_cad // not a range variable (beta equivalent to RCa_cad from Av-Ron) 5 : gbar_ka 6 : gbar_cal 7 : gbar_nap 8 : g_pas 9 : gbar_cat 10 : gbar_km 11 : gbar_k2 12 : gbar_kahp 13 : gbar_h ******************************************************************/ proc applysec_slope() { local m, y0, idx m = $2 y0 = $3 idx = $4 forsec $s1 { for(x) { // if we execute this command on x==1 //if( x == 1 ) continue if( idx == 0 && ismembrane("naf") ) { gbar_naf(x) = m*x + y0 if( gbar_naf(x) < 0 ) gbar_naf(x) = 0 if( VERBOSE ) printf("\t\tSetting gbar_naf(%g) = %g\n",x,gbar_naf(x)) continue } if( idx == 1 && ismembrane("kdr") ) { gbar_kdr(x) = m*x + y0 if( gbar_kdr(x) < 0 ) gbar_kdr(x) = 0 if( VERBOSE ) printf("\t\tSetting gbar_kdr(%g) = %g\n",x,gbar_kdr(x)) continue } if( idx == 2 && ismembrane("kc") ) { gbar_kc(x) = m*x + y0 if( gbar_kc(x) < 0 ) gbar_kc(x) = 0 if( VERBOSE ) printf("\t\tSetting gbar_kc(%g) = %g\n",x,gbar_kc(x)) continue } // phi & beta (i.e. Avron's Kp and Rca) are not range variables; skip over idx == 3 or 4 if( idx == 5 && ismembrane("ka") ) { gbar_ka(x) = m*x + y0 if( gbar_ka(x) < 0 ) gbar_ka(x) = 0 if( VERBOSE ) printf("\t\tSetting gbar_ka(%g) = %g\n",x,gbar_ka(x)) continue } if( idx == 6 && ismembrane("cal") ) { gbar_cal(x) = m*x + y0 if( gbar_cal(x) < 0 ) gbar_cal(x) = 0 if( VERBOSE ) printf("\t\tSetting gbar_cal(%g) = %g\n",x,gbar_cal(x)) continue } if( idx == 7 && ismembrane("nap") ) { gbar_nap(x) = m*x + y0 if( gbar_nap(x) < 0 ) gbar_nap(x) = 0 if( VERBOSE ) printf("\t\tSetting gbar_nap(%g) = %g\n",x,gbar_nap(x)) continue } if( idx == 8 && ismembrane("pas") ) { g_pas(x) = m*x + y0 if( g_pas(x) < 0 ) g_pas(x) = 0 if( VERBOSE ) printf("\t\tSetting g_pas(%g) = %g\n",x,g_pas(x)) continue } else { if( idx == 8 && ismembrane("pasR") ) { g_pasR(x) = m*x + y0 if( g_pasR(x) < 0 ) g_pasR(x) = 0 if( VERBOSE ) printf("\t\tSetting g_pasR(%g) = %g\n",x,g_pasR(x)) continue } } if( idx == 9 && ismembrane("cat") ) { gbar_cat(x) = m*x + y0 if( gbar_cat(x) < 0 ) gbar_cat(x) = 0 if( VERBOSE ) printf("\t\tSetting gbar_cat(%g) = %g\n",x,gbar_cat(x)) continue } if( idx == 10 && ismembrane("km") ) { gbar_km(x) = m*x + y0 if( gbar_km(x) < 0 ) gbar_km(x) = 0 if( VERBOSE ) printf("\t\tSetting gbar_km(%g) = %g\n",x,gbar_km(x)) continue } if( idx == 11 && ismembrane("k2") ) { gbar_k2(x) = m*x + y0 if( gbar_k2(x) < 0 ) gbar_k2(x) = 0 if( VERBOSE ) printf("\t\tSetting gbar_k2(%g) = %g\n",x,gbar_k2(x)) continue } if( idx == 12 && ismembrane("kahp") ) { gbar_kahp(x) = m*x + y0 if( gbar_kahp(x) < 0 ) gbar_kahp(x) = 0 if( VERBOSE ) printf("\t\tSetting gbar_kahp(%g) = %g\n",x,gbar_kahp(x)) continue } if( idx == 13 && ismembrane("ar") ) { gbar_ar(x) = m*x + y0 if( gbar_ar(x) < 0 ) gbar_ar(x) = 0 if( VERBOSE ) printf("\t\tSetting gbar_ar(%g) = %g\n",x,gbar_ar(x)) continue } } } } /****************************************************************** calc_global_slope() Given the conductance values of the proximal and distal dendritic sections, calculate the appropriate slope from these values and the length of the dendrite. input $1 proximal conductance value (distance = 0) $2 most distal conductance value (distance = end of dendrite) ******************************************************************/ func calc_global_slope() { local s_rad, chgC, chgD, Pdist, Ddist, slp, segID soma { distance() Pdist = distance(1) if( VERBOSE ) printf("Proximal distance set to %g\n",Pdist) } strdef lng_name Ddist = find_longest_dend(lng_name,segID) chgD = Ddist - Pdist chgC = $2 - $1 slp = chgC / chgD return slp } /****************************************************************** calc_global_slopefac() Given the values of the proximal and distal dendritic sections relative to the soma (e.g. '2' for twice the soma value), calculate the appropriate factor to apply to each compartment's maximal conductances. Let the value of a certain conductance in the soma be g0. Suppose that conductance at the most proximal dendritic segments (distance x0) is defined by k0 * g0, and k1 * g0 at the most distal segments (distance x1). Then if dendritic conductances are to be scaled linearly, they will be defined by y1 - y0 = m * (x1-x0) i.e. (k1-k0) * g0 ------- = m (x1-x0) Then for any dendritic point at a distance x*, the appropriate conductance to apply is: y* - y0 = m * (x* - x0); suppose y = k* * g0. Then (k1-k0) k* = ------- * (x* - x0) + k0 (x1-x0) The values k0 are stored in int_vec; store the value of the first term (the 'slope scale factor') in slp_vec. The values k1 are stored in sec_vec, defined in linear_migliore_ratios() below. input $o1 vector of proximal conductances, relative to soma value(distance = 0) (int_vec) $o2 vector of most distal conductance, relative to soma value (distance = end of dendrite) (sec_vec) $o3 vector of slope factors, slp_vec ******************************************************************/ proc calc_global_slopefac() { local s_rad, chgC, chgD, Pdist, Ddist, slp, segID, i soma { distance() } strdef lng_name, shrt_name Ddist = find_longest_dend(lng_name,segID) most_distal = Ddist Pdist = find_shortest_dend(shrt_name,segID) most_proximal = Pdist chgD = Ddist - Pdist $o3 = new Vector() for i = 0, $o1.size()-1 { chgC = $o2.x[i]-$o1.x[i] slp = chgC / chgD $o3.append(slp) } /*** printf("Finished calc_global_slopefac. Given dendrites from %g to %g;\nint_vec = \n",most_proximal,most_distal) $o1.printf printf(" and sec_vec\n") $o2.printf printf("\nWe find slp_vec=\n") $o3.printf ***/ } /****************************************************************** findsec_slope() Determine the appropriate slope and intercept for this section, and apply the linear change to the section. input $s1 section name $2 global slope $3 global intercept $4 index of conductance type to change ******************************************************************/ proc findsec_slope() { local m, g0, y0, y1, m_lcl soma { distance() s_end = distance(.5) } m = $2 g0 = $3 forsec $s1 { y0 = g0 + m*(distance(0)-s_end) y1 = g0 + m*(distance(1)-s_end) m_lcl = y1-y0 if( VERBOSE) { printf("For section %s with Length %g and distance from soma %g,\n",secname(),L,distance(0)-s_end) printf("\tGlobal slope %g, intcpt %g becomes local slope %g, local intcpt %g\n",m,g0,m_lcl,y0) } applysec_slope($s1,m_lcl,y0,$4) } } /******************************************************************* set_cond_linear() Apply this global slope and intercept to the specified conductance type, for all dendritic segments. input $1 index of conductance type (see applysec_slope for list) $2 global slope to apply $3 intercept value for the most proximal dendrite section *******************************************************************/ proc set_cond_linear() { forsec dendritic { ifsec "soma" continue findsec_slope(secname(),$2,$3,$1) } copy_slope_intercept($1,$2,$3) } /******************************************************************** assign_slope2all() Write a matlab file that determines the appropriate conductance parameters throughout the dendrite, to apply the specified global conductance slope and intercept to the entire dendrite. No parameter values are actually changed in this procedure. input $1 global slope $2 global intercept $s3 file basename for output ********************************************************************/ proc assign_slope2all() { local i, s_rad soma { distance() s_rad = distance(1) } strdef finname sprint(finname,"checklin_%s.m",$s3) fin = new File() fin.wopen(finname) //findsec_slope("dend[0]",$1,$2) //findsec_slope("dend[1]",$1,$2) //findsec_slope("dend[2]",$1,$2) forsec dendritic { fin.printf("%s = [ \n",secname()) for(x) { if( ismembrane("pas")) { fin.printf("%g %g %g\n",x,distance(x)-s_rad,g_pas(x)) } else { if( ismembrane("pasR")) { fin.printf("%g %g %g\n",x,distance(x)-s_rad,g_pasR(x)) } } } fin.printf("];\n") } /*** fin.printf("plot(dend0(:,2),dend0(:,3),dend1(:,2),dend1(:,3),dend2(:,2),dend2(:,3));\n") fin.printf("legend('dend[0]','dend[1]','dend[2]');\n") fin.printf("m = %g; intcpt = %g;\n",$1,$2) fin.printf("ttl = sprintf('Changing g_{pas}: Slope %%g, intercept %%g',m,intcpt);\n") fin.printf("title(ttl);\n") ***/ fin.close() } /******************************************************************** print_cond_linscale() Print the conductance values with distance for all neuron compartments. input $1 index of conductance type $s2 if writing M-file, suffix for parameter ********************************************************************/ proc print_cond_linscale() { local idx, cval, i, tot strdef strg, lgstrg idx = $1 if( idx == 0 ) { printf("Values of g_Na:\n") strg = "Na" } if( idx == 1 ) { printf("Values of g_KDR:\n") strg = "KDR" } if( idx == 2 ) { printf("Values of g_KCa:\n") strg = "KCa" } if( idx == 3 ) { printf("Values of Kp (Ca influx):\n") strg = "Kp" } if( idx == 4 ) { printf("Values of beta (Ca efflux):\n") strg = "beta" } if( idx == 5 ) { printf("Values of g_KA:\n") strg = "KA" } if( idx == 6 ) { printf("Values of g_CaL:\n") strg = "Ca" } if( idx == 7 ) { printf("Values of g_NaP:\n") strg = "NaP" } if( idx == 8 ) { printf("Values of g_Leak:\n") strg = "Lk" } if( idx == 9 ) { printf("Values of gbar_caT:\n") strg = "CaT" } soma { distance() s_rad = distance(1) } forall { print secname(), nseg, " segments" for(x) { cval = -1 if( idx == 0 && ismembrane("naf") ) cval = gbar_naf(x) if( idx == 1 && ismembrane("kdr") ) cval = gbar_kdr(x) if( idx == 2 && ismembrane("kc") ) cval = gbar_kc(x) // Kp and beta are not range variables; skip over idx == 3 or 4 if( idx == 5 && ismembrane("ka") ) cval = gbar_ka(x) if( idx == 6 && ismembrane("cal") ) cval = gbar_cal(x) if( idx == 7 && ismembrane("nap") ) cval = gbar_nap(x) if( idx == 8 && ismembrane("pas") ) cval = g_pas(x) if( idx == 8 && ismembrane("pasR") ) cval = g_pasR(x) if( idx == 9 && ismembrane("cat") ) cval = gbar_cat(x) if( idx == 10 && ismembrane("k2") ) cval = gbar_k2(x) if( idx == 11 && ismembrane("km") ) cval = gbar_km(x) if( idx == 12 && ismembrane("kahp") ) cval = gbar_kahp(x) if( idx == 13 && ismembrane("ar") ) cval = gbar_ar(x) printf("\t[%g]\t%g um\t%g\n",x,distance(x),cval) } } tot = total_dend_cond(idx,$s2) } /******************************************************************** print_lincond_smry() Print the conductance values with distance for all neuron compartments. input $1 index of conductance type ********************************************************************/ proc print_lincond_smry() { local idx, cval, i, tot strdef strg, lgstrg for idx = 0, 8 { cval = -1 if( idx == 0 ) { strg = "Na" } if( idx == 1 ) { strg = "KDR" } if( idx == 2 ) { strg = "KCa" } if( idx == 3 ) { strg = "Kp" } if( idx == 4 ) { strg = "beta" } if( idx == 5 ) { strg = "KA" } if( idx == 6 ) { strg = "Ca" } if( idx == 7 ) { strg = "NaP" } if( idx == 8 ) { strg = "Lk" } if( idx == 0 && ismembrane("naf") ) cval = dendritic.object(0).gbar_naf(0) / soma.gbar_naf if( idx == 1 && ismembrane("kdr") ) cval = dendritic.object(0).gbar_kdr(0) / soma.gbar_kdr if( idx == 2 && ismembrane("kc") ) cval = dendritic.object(0).gbar_kc(0) / soma.gbar_kc // phi and beta are not range variables; skip over idx == 3 or 4 if( idx == 3 && ismembrane("cad") ) cval = phi_cad if( idx == 4 && ismembrane("cad") ) cval = beta_cad if( idx == 5 && ismembrane("ka") ) cval = dendritic.object(0).gbar_ka(0) / soma.gbar_ka if( idx == 6 && ismembrane("cal") ) cval = dendritic.object(0).gbar_cal(0) / soma.gbar_cal if( idx == 7 && ismembrane("nap") ) cval = dendritic.object(0).gbar_nap(0) / soma.gbar_nap if( idx == 8 && ismembrane("pas") ) cval = dendritic.object(0).g_pas(0) / soma.g_pas if( idx == 8 && ismembrane("pasR") ) cval = dendritic.object(0).g_pasR(0) / soma.g_pasR if( idx == 9 && ismembrane("cat") ) cval = dendritic.object(0).gbar_cat(0) / soma.gbar_cat if( idx == 10 && ismembrane("k2") ) cval = dendritic.object(0).gbar_k2(0) / soma.gbar_k2 if( idx == 11 && ismembrane("km") ) cval = dendritic.object(0).gbar_km(0) / soma.gbar_km if( idx == 12 && ismembrane("kahp") ) cval = dendritic.object(0).gbar_kahp(0) / soma.gbar_kahp if( idx == 13 && ismembrane("ar") ) cval = dendritic.object(0).gbar_ar(0) / soma.gbar_ar printf("%s: %g\n",strg,cval) } } /********************************************************************* BParea() Calculate the area between the backpropagation curve and the straight line V = minV (default -80). This is measured in each segment as the maximum voltage observed over the entire simulation. *********************************************************************/ func BParea() { local sum, minV sum = 0 minV = -80 forsec dendritic { if( !ismembrane("mar")) continue if( VERBOSE ) print secname() for(x) { if( x==0 || x==1 ) continue sum += L*(val_mar(x)-minV)/(nseg) if( VERBOSE ) print "\t",x,nseg,L/(nseg),val_mar(x),sum } } return sum } /********************************************************************* total_dend_cond() Calculate the total amount of conductance of the specified channel type. That is, multiply g_bar * surface area of each dendritic section. input $1 index of conductance type $s2 channel suffix (e.g. "kdr" for gbar_kdr) *********************************************************************/ func total_dend_cond() { local sum, minV, idx strdef strg idx = $1 sum = 0 forsec dendritic { if( !ismembrane($s2)) continue print secname() for(x) { if( x==0 || x==1 ) continue cval = -1 if( idx == 0 && ismembrane("naf") ) cval = gbar_naf(x) if( idx == 1 && ismembrane("kdr") ) cval = gbar_kdr(x) if( idx == 2 && ismembrane("kc") ) cval = gbar_kc(x) // phi and beta are not range variables; skip over idx == 3 or 4 if( idx == 5 && ismembrane("ka") ) cval = gbar_ka(x) if( idx == 6 && ismembrane("cal") ) cval = gbar_cal(x) if( idx == 7 && ismembrane("nap") ) cval = gbar_nap(x) if( idx == 8 && ismembrane("pas") ) cval = g_pas(x) if( idx == 8 && ismembrane("pasR") ) cval = g_pasR(x) if( idx == 9 && ismembrane("cat") ) cval = gbar_cat(x) if( idx == 10 && ismembrane("k2") ) cval = gbar_k2(x) if( idx == 11 && ismembrane("km") ) cval = gbar_km(x) if( idx == 12 && ismembrane("kahp") ) cval = gbar_kahp(x) if( idx == 13 && ismembrane("ar") ) cval = gbar_ar(x) if( cval < 0 ) continue sum += cval*area(x) printf("\t%g:\t%g * %g = %g\n",x,cval,area(x),cval*area(x)) } } if( idx == 0 ) strg = "Na" if( idx == 1 ) strg = "KDR" if( idx == 2 ) strg = "KCa" if( idx == 3 ) strg = "phi" if( idx == 4 ) strg = "beta" if( idx == 5 ) strg = "KA" if( idx == 6 ) strg = "CaL" if( idx == 7 ) strg = "NaP" if( idx == 8 ) strg = "Leak" if( idx == 9 ) strg = "CaT" if( idx == 10 ) strg = "K2" if( idx == 11 ) strg = "KM" if( idx == 12 ) strg = "KAHP" if( idx == 13 ) strg = "AR" printf("Total %s conductance = %g mS\n",strg,sum) return sum } // these vectors store the dendritic conductance info: slopes & intercepts. objref slp_vec, int_vec, sec_vec slp_vec = new Vector() int_vec = new Vector() sec_vec = new Vector() /******************************************************************** copy_slope_intercept We've just applied the global slope & intercept to the dendrite. Now copy that information into the 'slp_vec' and 'int_vec' vectors. input $1 index of conductance type (see applysec_slope for list) $2 global slope that was applied $3 intercept value for the most proximal dendrite section ********************************************************************/ proc copy_slope_intercept() { if( $1 <= 2 ) { slp_vec.x[$1] = $2 int_vec.x[$1] = $3 if( VERBOSE ) printf("index %d -> slope, int [%d] = %g, %g\n",$1,$1,slp_vec.x[$1],int_vec.x[$1]) } else { if( $1 > 4 && $1 < 9 ) { slp_vec.x[$1-2] = $2 int_vec.x[$1-2] = $3 if( VERBOSE ) printf("index %d -> slope, int [%d] = %g, %g\n",$1,$1-2,slp_vec.x[$1-2],int_vec.x[$1-2]) } else { if( VERBOSE ) printf("index %d NOT APPLICABLE for slope/intercept vector.\n",$1) } } } /****************************************************************** define_dend_slope() Given the proximal and distal dendritic values, apply the associated linearly scaled conductance. input $1 index: which conductance to change? if( idx == 0 ) strg = "Na" if( idx == 1 ) strg = "KDR" if( idx == 2 ) strg = "KCa" if( idx == 3 ) strg = "phi" if( idx == 4 ) strg = "beta" if( idx == 5 ) strg = "KA" if( idx == 6 ) strg = "CaL" if( idx == 7 ) strg = "NaP" if( idx == 8 ) strg = "Leak" $2 proximal conductance value $3 distal conductance ******************************************************************/ proc define_dend_slope() { local slp, idx, Pval, Dval idx = $1 Pval = $2 Dval = $3 slp = calc_global_slope(Pval,Dval) set_cond_linear(idx,slp,Pval) //print_cond_linscale(idx,"L","") //printf("\n\n") } /****************************************************************** linear_migliore_ratios() Jun 11 '07 Based on data found in Migliore & Shepherd '02 review, plus a few other references on neocortical pyramidal cells (mostly layer 5). ******************************************************************/ proc linear_migliore_ratios() { local slp, idx, Pval, Dval int_vec = new Vector() sec_vec = new Vector() // component 0 of int_vec and sec_vec pri_nafac = 1 sec_nafac = $2 int_vec.append(pri_nafac) sec_vec.append(sec_nafac) pri_kfac = 1 sec_kfac = $3 int_vec.append(pri_kfac) sec_vec.append(sec_kfac) pri_kcafac = 1 sec_kcafac = 1 int_vec.append(pri_kcafac) sec_vec.append(sec_kcafac) // append for phi_cad and beta_cad, in case we need it later. int_vec.append(0) sec_vec.append(0) int_vec.append(0) sec_vec.append(0) // component 5 of int_vec and sec_vec pri_kafac = 1 sec_kafac = 2 int_vec.append(pri_kafac) sec_vec.append(sec_kafac) pri_cafac = 1 sec_cafac = 1 int_vec.append(pri_cafac) sec_vec.append(sec_cafac) pri_napfac = pri_nafac sec_napfac = sec_nafac int_vec.append(pri_napfac) sec_vec.append(sec_napfac) pri_pasfac = 1 sec_pasfac = 1 int_vec.append(pri_pasfac) sec_vec.append(sec_pasfac) // component 9 of int_vec and sec_vec pri_locafac = 1 sec_locafac = 1 int_vec.append(pri_locafac) sec_vec.append(sec_locafac) pri_k2fac = 1 sec_k2fac = 1 int_vec.append(pri_k2fac) sec_vec.append(sec_k2fac) pri_kmfac = 1 sec_kmfac = 1 int_vec.append(pri_kmfac) sec_vec.append(sec_kmfac) pri_kahpfac = 1 sec_kahpfac = 1 int_vec.append(pri_kahpfac) sec_vec.append(sec_kahpfac) // component 13 of int_vec and sec_vec pri_hfac = 1 sec_hfac = $1 int_vec.append(pri_hfac) sec_vec.append(sec_hfac) pri_skahpfac = 1 sec_skahpfac = 1 int_vec.append(pri_skahpfac) sec_vec.append(sec_skahpfac) //printf("From linear_migliore_ratios()\n") calc_global_slopefac(int_vec,sec_vec,slp_vec) apply_linear_ratios() } /***************************************************************** apply_one_dendcond() input $1 index of channel to set $2 conductance value in the soma Use data contained in int_vec and slp_vec (see calc_global_slopevec) to set the conductance value throughout the dendrites. *****************************************************************/ proc apply_one_dendcond() { local distx, idx strdef tg idx = $1 forsec dendritic { for(x) { distx = distance(x) kstar = slp_vec.x[idx] * (distx - most_proximal) + int_vec.x[idx] if( idx == 0 && ismembrane("naf") ) { tg = "Na" gbar_naf(x) = $2 * kstar } if( idx == 1 && ismembrane("kdr") ) { tg = "KDR" gbar_kdr(x) = $2 * kstar } if( idx == 2 && ismembrane("kc") ) { tg = "KCa" gbar_kc(x) = $2 * kstar } if( idx == 5 && ismembrane("ka") ) { tg = "KA" gbar_ka(x) = $2 * kstar } if( idx == 6 && ismembrane("cal") ) { tg = "CaL" gbar_cal(x) = $2 * kstar } if( idx == 7 && ismembrane("nap") ) { tg = "NaP" gbar_nap(x) = $2 * kstar } if( idx == 8 && ismembrane("pas") ) { tg = "Pas" g_pas(x) = $2 * kstar } if( idx == 8 && ismembrane("pasR") ) { tg = "PasR" g_pasR(x) = $2 * kstar } if( idx == 9 && ismembrane("cat") ) { tg = "CaT" gbar_cat(x) = $2 * kstar } if( idx == 10 && ismembrane("k2") ) { tg = "K2" gbar_k2(x) = $2 * kstar } if( idx == 11 && ismembrane("km") ) { tg = "KM" gbar_km(x) = $2 * kstar } if( idx == 12 && ismembrane("kahp") ) { tg = "KAHP" gbar_kahp(x) = $2 * kstar } if( idx == 13 && ismembrane("ar") ) { tg = "H" gbar_ar(x) = $2 * kstar } if( idx == 14 && ismembrane("skahp") ) { tg = "SKAHP" gbar_skahp(x) = $2 * kstar } if( VERBOSE && idx == 5 ) { printf("%s, [%g\t%g]: %s: gbar %g * kstar %g = %g\n",secname(),x,distx,tg,$2,kstar,$2*kstar) } } } forsec axon { if( ismembrane("kc")) gbar_kc=0 if( ismembrane("skahp")) gbar_skahp=0 if( ismembrane("kahp")) gbar_kahp=0 if( ismembrane("cal")) gbar_cal=0 if( ismembrane("ar")) gbar_ar=0 if( ismembrane("cat")) gbar_cat=0 if( ismembrane("km")) gbar_km=0 } forsec "AxonInitseg" { if( ismembrane("kc")) gbar_kc=0 if( ismembrane("skahp")) gbar_skahp=0 if( ismembrane("kahp")) gbar_kahp=0 if( ismembrane("cal")) gbar_cal=0 if( ismembrane("ar")) gbar_ar=0 if( ismembrane("cat")) gbar_cat=0 if( ismembrane("km")) gbar_km=0 } } /***************************************************************** apply_linear_ratios() Assuming pri*fac and sec*fac have been calculated according to some prior rule, apply these as the proximal and distal values of the dendritic conductances. Intermediate distances along the dendrite have conductances that vary linearly between these two values. *****************************************************************/ proc apply_linear_ratios() { local idx, g0 strdef tg soma{ distance() } for idx = 0, int_vec.size()-1 { if( idx == 0 ) g0 = soma.gbar_naf if( idx == 1 ) g0 = soma.gbar_kdr if( idx == 2 ) g0 = soma.gbar_kc if( idx == 3 || idx == 4 ) continue if( idx == 5 ) g0 = soma.gbar_ka if( idx == 6 ) g0 = soma.gbar_cal if( idx == 7 ) g0 = soma.gbar_nap if( idx == 8 && ismembrane("pas" ) ) g0 = soma.g_pas if( idx == 8 && ismembrane("pasR") ) g0 = soma.g_pasR if( idx == 9 ) g0 = soma.gbar_cat if( idx == 10 ) g0 = soma.gbar_k2 if( idx == 11 ) g0 = soma.gbar_km if( idx == 12 ) g0 = soma.gbar_kahp if( idx == 13 ) g0 = soma.gbar_ar if( idx == 14 ) g0 = soma.gbar_skahp apply_one_dendcond(idx,g0) } } objref soma_vals proc make_active_dendrite() { local val1, val2, val3, val4, sNash soma { //if( ismembrane("naf") ) print "Soma HAS naf." else print "Soma does NOT have naf." if( !ismembrane("naf") ) { insert naf gbar_naf = 0 } sNash = fastNashift_naf if( !ismembrane("kdr") ) { insert kdr gbar_kdr = 0 } if( !ismembrane("ka") ) { insert ka gbar_ka = 0 } if( !ismembrane("kc") ) { insert kc gbar_kc = 0 } if( !ismembrane("km") ) { insert km gbar_km = 0 } if( !ismembrane("k2") ) { insert k2 gbar_k2 = 0 } if( !ismembrane("kahp") ) { insert kahp gbar_kahp = 0 } if( !ismembrane("cal") ) { insert cal gbar_cal = 0 } if( !ismembrane("nap") ) { insert nap gbar_nap = 0 } if( !ismembrane("cad") ) { insert cad phi_cad = PHI_DFLT beta_cad = BETA_SOMA ceiling_cad = CEILING_CA } if( !ismembrane("cat") ) { insert cat gbar_cat = 0 } if( !ismembrane("ar") ) { insert ar gbar_ar = 0 } if( !ismembrane("skahp") ) { insert skahp gbar_skahp = 0 } soma_vals = new Vector() soma_vals.append(gbar_naf,gbar_kdr) } forsec dendritic { if( !ismembrane("naf") ) { insert naf gbar_naf = 0 tmp = sNash //print "soma has Na shift of ", tmp fastNashift_naf = tmp //print "just added naf to ", secname() } if( !ismembrane("kdr") ) { insert kdr gbar_kdr = 0 } if( !ismembrane("ka") ) { insert ka gbar_ka = 0 } if( !ismembrane("kc") ) { insert kc gbar_kc = 0 } if( !ismembrane("km") ) { insert km gbar_km = 0 } if( !ismembrane("k2") ) { insert k2 gbar_k2 = 0 } if( !ismembrane("kahp") ) { insert kahp gbar_kahp = 0 } if( !ismembrane("cal") ) { insert cal gbar_cal = 0 } if( !ismembrane("nap") ) { insert nap gbar_nap = 0 } if( !ismembrane("cad") ) { insert cad phi_cad = soma.phi_cad beta_cad = BETA_DEND //ceiling_cad = soma.ceiling_cad //printf("Added cad to %s: %g, %g, %g\n",secname(),phi_cad,beta_cad,ceiling_cad) } if( !ismembrane("cat") ) { if( VERBOSE ) printf("Now inserting cat.\n") insert cat gbar_cat = 0 } if( !ismembrane("ar") ) { insert ar gbar_ar = 0 } if( !ismembrane("skahp") ) { insert skahp gbar_kahp = 0 } } if( VERBOSE ) printf("Rendering the axon active:\n") forsec axonal { if( !ismembrane("naf") ) insert naf if( !ismembrane("kdr") ) insert kdr ifsec "AxInitSeg" { gbar_naf = soma_vals.x[0] fastNashift_naf = sNash gbar_kdr = soma_vals.x[1] } ifsec "axon" { gbar_naf = AX_GNASCALE*soma_vals.x[0] fastNashift_naf = sNash gbar_kdr = soma_vals.x[1] } if( VERBOSE ) printf("\t%s\t%g\t%g\n",secname(),gbar_naf,gbar_kdr) } //printf("From make_active_dendrite()\n") calc_global_slopefac(int_vec,sec_vec,slp_vec) apply_linear_ratios() } /***************************************************************** input $1 1 or 0, make soma passive too? *****************************************************************/ proc make_passive_dendrite() { forall { if( $1==0 ) ifsec "soma" continue if( ismembrane("naf") ) { uninsert naf } if( ismembrane("kdr") ) { uninsert kdr } if( ismembrane("ka") ) { uninsert ka } if( ismembrane("kc") ) { uninsert kc } if( ismembrane("cal") ) { uninsert cal } if( ismembrane("nap") ) { uninsert nap } if( ismembrane("cad") ) { uninsert cad } if( ismembrane("cat") ) { uninsert cat } if( ismembrane("k2") ) { uninsert k2 } if( ismembrane("km") ) { uninsert km } if( ismembrane("kahp") ) { uninsert kahp } if( ismembrane("ar") ) { uninsert ar } } } /****************************************************************** linear_passive_ratios() Experimentation with model "PD83" of the ball & stick model suggests that using a proximal Na, NaP factor of 0.1 (relative to soma value) shows a greatly reduced backpropagating AP. input none ******************************************************************/ proc linear_passive_ratios() { local slp, idx, Pval, Dval pri_nafac = 0 sec_nafac = 0 pri_kfac = 0 sec_kfac = 0 pri_kcafac = 0 sec_kcafac = 0 pri_pasfac = 1 sec_pasfac = 1 pri_kafac = 0 sec_kafac = 0 pri_cafac = 0 sec_cafac = 0 pri_napfac = 0 sec_napfac = 0 pri_locafac = 0 sec_locafac = 0 pri_k2fac = 0 sec_k2fac = 0 pri_kmfac = 0 sec_kmfac = 0 pri_kahpfac = 0 sec_kahpfac = 0 pri_hfac = 0 sec_hfac = 0 int_vec = new Vector(14,0) sec_vec = new Vector(14,0) // passive conductance not changed. int_vec.x[8] = 1 sec_vec.x[8] = 1 //printf("From linear_passive_ratios()\n") calc_global_slopefac(int_vec,sec_vec,slp_vec) apply_linear_ratios() } /*************************************************************** axon_set() Adjust the axonal parameters. Copied from ~ani/old_forAni/axon_set.hoc ***************************************************************/ proc axon_set() { forsec axon { gbar_naf=2.13*soma.gbar_naf gbar_kdr=3.2*soma.gbar_kdr } forall if (issection("AxonInitseg")){ gbar_naf=2.13*soma.gbar_naf gbar_kdr=3.2*soma.gbar_kdr } } /*************************************************************** adj_{naf, kdr, kca...} : Adjust the soma value of the specified conductance,then apply a linear scaling of this value throughout the dendrite. input $1 somatic value to apply ***************************************************************/ proc adj_naf() { local setval gbar_naf = $1 apply_one_dendcond(0,$1) axon_set() // set axonal values forsec "axon" { if( ismembrane("naf") ) { gbar_naf = AX_GNASCALE * $1 if( VERBOSE ) printf("AXON: %s gNa set to %g\n",secname(),gbar_naf) } else { if( VERBOSE ) printf("AXON: %s does not include gNa\n",secname()) } } forsec "Init" { if( ismembrane("naf") ) { gbar_naf = $1 if( VERBOSE ) printf("AXON: %s gNa set to %g\n",secname(),gbar_naf) } else { if( VERBOSE ) printf("AXON: %s does not include gNa\n",secname()) } } } proc adj_kdr() { gbar_kdr = $1 apply_one_dendcond(1,$1) axon_set() /******* // set axonal values forsec "axon" { if( ismembrane("kdr") ) { gbar_kdr = $1 if( VERBOSE ) printf("AXON: %s gKDR set to %g\n",secname(),gbar_kdr) } else { if( VERBOSE ) printf("AXON: %s does not include gKDR\n",secname()) } } ********/ forsec "Init" { if( ismembrane("kdr") ) { gbar_kdr = $1 if( VERBOSE ) printf("AXON: %s gKDR set to %g\n",secname(),gbar_kdr) } else { if( VERBOSE ) printf("AXON: %s does not include gKDR\n",secname()) } } } proc adj_kca() { gbar_kc = $1 apply_one_dendcond(2,$1) } /****** * these two procedures are included for completeness; they are * also defined in adjust_procs.hoc ******/ proc adj_beta() { local DENDSCL DENDSCL = 5 soma { if( ismembrane("cad")) beta_cad = $1 } forall { ifsec "soma" continue if( ismembrane("cad")) { beta_cad = $1 * DENDSCL } } } proc adj_phi() { forall { if( ismembrane("cad")) phi_cad = $1 } } proc adj_ka() { gbar_ka = $1 apply_one_dendcond(5,$1) } proc adj_caL() { gbar_cal = $1 apply_one_dendcond(6,$1) } proc adj_nap() { gbar_nap = $1 apply_one_dendcond(7,$1) } proc adj_pas() { if( ismembrane("pas") ) { g_pas = $1 } else { if( ismembrane("pasR") ) g_pasR = $1 } apply_one_dendcond(8,$1) } proc adj_caT() { gbar_cat = $1 apply_one_dendcond(9,$1) } proc adj_km() { gbar_km = $1 apply_one_dendcond(11,$1) } proc adj_k2() { gbar_k2 = $1 apply_one_dendcond(10,$1) } proc adj_kahp() { gbar_kahp = $1 apply_one_dendcond(12,$1) } proc adj_h() { gbar_ar = $1 apply_one_dendcond(13,$1) } proc adj_Cm() { forall { cm = $1 } init() } proc adj_Ra() { forall { Ra = $1 } init() } proc adj_skahp() { gbar_skahp = $1 apply_one_dendcond(14,$1) } proc add_LoCa() { forall { if( !ismembrane("cat") ) insert cat } } /************************************************** func find_longest_dend output $s1 name of section with longest distance $2 segment with longest distance **************************************************/ func find_longest_dend() { local lngdist, curdist, segID soma { distance() } strdef lng_name lngdist = 0 segID = -1 forsec dendritic { for(x) { curdist = distance(x) if( curdist > lngdist ) { segID = x lng_name = secname() lngdist = curdist } } } $s1 = lng_name $2 = segID //printf("Longest dendrite was %s(%d), distance from soma %g um.\n",lng_name,segID,lngdist) return lngdist } /************************************************** func find_shortest_dend output $s1 name of section with longest distance $2 segment with longest distance **************************************************/ func find_shortest_dend() { local shrtdist, curdist, segID soma { distance() } strdef shrt_name shrtdist = 1e6 segID = -1 forsec dendritic { for(x) { curdist = distance(x) if( curdist < shrtdist ) { segID = x shrt_name = secname() shrtdist = curdist } } } $s1 = shrt_name $2 = segID //printf("Shortest dendrite was %s(%d), distance from soma %g um.\n",shrt_name,segID,shrtdist) return shrtdist } /************************************************** proc shift_axonNa input $1 amount to shift Na's V_half **************************************************/ proc shift_axonNa() { forsec "axon" { fastNashift_naf = $1 } } /************************************************** proc axonNa_hypol input $1 amount to shift Na's V_half, times -1 (so we can run this in log mode) **************************************************/ proc axonNa_hypol() { forsec "axon" { fastNashift_naf = -1*$1 } } proc set_memres() { forsec dendritic { // set membrane resistance RM = $1 g_pas=1/$1 } forsec axon {g_pas=1/1000} soma { // set membrane resistance RM = $1 g_pas=1/$1 } } /****************************************************************** set_dend_Hratios() Feb 19 '13 specify the ratio of H current at the farthest dendritic tip, relative to the soma value. Increases linearly with distance from the soma. input $1 ratio at tip, relative to soma (e.g. $1=2 means twice the somatic value) ******************************************************************/ proc set_dend_Hratios() { local slp, idx, Pval, Dval int_vec.x[13] = 1 sec_vec.x[13] = $1 calc_global_slopefac(int_vec,sec_vec,slp_vec) apply_linear_ratios() }