def extract_and_add_capool(model, comp, pools): params = model.CaPlasticityParams shape = distance_mapping(params.ShapeConfig, comp) OuterShellThick = shape.OutershellThickness BufCapacity = distance_mapping(params.BufferCapacityDensity, comp) pool = addCaPool(model, OuterShellThick, BufCapacity, comp, pools) return pool
def extract_and_add_difshell(model, shellMode, comp,spine): params = model.CaPlasticityParams Pumps = {} for pump in params.PumpVmaxDensities.keys(): Pumps[pump] = distance_mapping(params.PumpVmaxDensities[pump], comp) Buffers = distance_mapping(params.BufferDensity,comp) shape = distance_mapping(params.ShapeConfig,comp) shellsparams = CalciumConfig(shellMode=shellMode,increase_mode=shape.ThicknessIncreaseMode,outershell_thickness=shape.OutershellThickness,thickness_increase=shape.ThicknessIncreaseFactor, min_thickness=shape.MinThickness) dshells_dend = addDifMachineryToComp(model,comp,Buffers,Pumps,shellsparams,spine) return dshells_dend
def extract_and_add_capool(model,comp,pools): params = model.CaPlasticityParams shape = distance_mapping(params.ShapeConfig,comp) OuterShellThick = shape.OutershellThickness BufCapacity = distance_mapping(params.BufferCapacityDensity,comp) if hasattr(params,'Taus'): tau = distance_mapping(params.Taus,comp) tauScale = params.tauScale else: tau = params.CalciumParams.tau tauScale = None pool = addCaPool(model,OuterShellThick,BufCapacity,comp, pools,tau=tau,tauScale=tauScale) return pool
def addCalcium(model,ntype): pools = CaProto(model) capool = [] params = model.CaPlasticityParams for comp in moose.wildcardFind(ntype + '/#[TYPE=Compartment]'): if NAME_NECK not in comp.name and NAME_HEAD not in comp.name: #Look for spines connected to the dendrite shellMode = distance_mapping(params.CaShellModeDensity,comp) dshells_dend = add_calcium_to_compartment(model, shellMode, comp, pools,capool,spine=False) if dshells_dend == -1: return if model.spineYN: spines = [] neighbors = list(comp.neighbors['raxial']) neighbors.extend(list(comp.neighbors['axial'])) for neighbor in neighbors: if NAME_NECK in neighbor.name: spines.append(neighbor) else: 'Could not find spines!!!' for sp in spines: shellMode = distance_mapping(params.CaShellModeDensity,moose.element(sp)) dshells_neck = add_calcium_to_compartment(model,shellMode,moose.element(sp),pools,capool,spine=True) if dshells_neck == -1: return if dshells_dend and dshells_neck: #diffusion between neck and dendrite moose.connect(dshells_neck[-1],"outerDifSourceOut",dshells_dend[0],"fluxFromOut") moose.connect(dshells_dend[0],"innerDifSourceOut",dshells_neck[-1],"fluxFromIn") heads = [] neighbors = list(moose.element(sp).neighbors['raxial']) neighbors.extend(list(moose.element(sp).neighbors['axial'])) for neighbor in neighbors: if NAME_HEAD in neighbor.name: heads.append(neighbor) if not heads: 'Could not find heads!!!' for head in heads: shellMode = distance_mapping(params.CaShellModeDensity,moose.element(head)) dshells_head = add_calcium_to_compartment(model,shellMode,moose.element(head),pools,capool,spine=True) if dshells_head == -1: return if dshells_head and dshells_neck: #diffusion between neck and dendrite moose.connect(dshells_head[-1],"outerDifSourceOut",dshells_neck[0],"fluxFromOut") moose.connect(dshells_neck[0],"innerDifSourceOut",dshells_head[-1],"fluxFromIn") return capool
def fix_calcium(neurontypes, model): """kluge to fix buffer capacity in CaPool Initiating hsolve calculates CaConc.B from thickness, length, diameter; ignores buffer capacity. """ comptype = 'ZombieCompartment' cacomptype = 'ZombieCaConc' ca_elem_suffix = model.CaPlasticityParams.CalciumParams.CaName buffer_capacity_density = model.CaPlasticityParams.BufferCapacityDensity log.info('Fixing calcium buffer capacity for {} elements'.format(comptype)) for ntype in neurontypes: for comp in moose.wildcardFind('{}/#[TYPE={}]'.format(ntype, comptype)): cacomps = [m for m in moose.element(comp).children if m.className==cacomptype] for cacomp in cacomps: buf_capacity = distance_mapping(buffer_capacity_density, comp) radius = cacomp.diameter/2. if cacomp.thick > radius: cacomp.thick = radius if cacomp.length: vol = np.pi * cacomp.length * (radius**2 - (radius-cacomp.thick)**2) else: vol = 4. / 3. * np.pi * ((cacomp.diameter / 2) ** 3 - (cacomp.diameter / 2 - cacomp.thick) ** 3) cacomp.B = 1. / (constants.Faraday * vol * 2) / buf_capacity # volume correction
def create_neuron(model, ntype, ghkYN): p_file = find_morph_file(model,ntype) try: cellproto=moose.loadModel(p_file, ntype) except IOError: print('could not load model from {!r}'.format(p_file)) raise #######channels Cond = model.Condset[ntype] for comp in moose.wildcardFind('{}/#[TYPE=Compartment]'.format(ntype)): #If we are using GHK, just create one GHK per compartment, connect it to comp #calcium concentration is connected in a different function if ghkYN: ghkproto=moose.element('/library/ghk') ghk=moose.copy(ghkproto,comp,'ghk')[0] moose.connect(ghk,'channel',comp,'channel') else: ghk=[] for channame in Cond.keys(): c = _util.distance_mapping(Cond[channame], comp) if c > 0: log.debug('Testing Cond If {} {}', channame, c) calciumPermeable = model.Channels[channame].calciumPermeable add_channel.addOneChan(channame, c, comp, ghkYN, ghk, calciumPermeable=calciumPermeable) #Compensate for actual, experimentally estimated spine density. #This gives a model that can be simulated with no explicit spines or #any number of explicitly modeled spines up to the actual spine density: spines.compensate_for_spines(model,comp,model.param_cond.NAME_SOMA) return cellproto
def create_synpath_array(allsyncomp_list,syntype,NumSyn,prob=None): #list of possible synapses with connection probability, which takes into account prior creation of synapses syncomps=[] totalsyns=0 print('CONNECT: syntype:', syntype, 'prob',prob) for syncomp in allsyncomp_list: dist,nm=util.get_dist_name(syncomp.parent) if prob: #calculate dendritic distance dependent connection probability to store with table dist_prob=dendritic_distance_dep_connect_prob(prob,dist) else: dist_prob=1 #print('syncomp',syncomp,'dist',dist,'prob',dist_prob) if dist_prob>0: #only add synchan to list if connection probability is non-zero sh=moose.element(syncomp.path+'/SH') # TODO: Fix for synapses on spines; there should only be 1 per spine if NAME_HEAD in nm: SynPerComp = 1 #- sh.numSynapses else: SynPerComp = util.distance_mapping(NumSyn[syntype], dist)#-sh.numSynapses for i in range(SynPerComp): totalsyns+=dist_prob #totalsyns=total synapses to connect if i < SynPerComp - sh.numSynapses: syncomps.append([syncomp.path+'/SH',dist_prob]) #print('{} synapses already connected of {} total synapses, adding 1 synapse with {} dist_prob to list'.format(sh.numSynapses,SynPerComp,dist_prob)) else: syncomps.append([syncomp.path+'/SH',0]) #print('{} synapses already connected of {} total synapses, adding 1 synapse with 0 dist_prob to list'.format(sh.numSynapses,SynPerComp)) #normalize probability to pdf syncomp_sum = sum([p[1] for p in syncomps]) print('CONNECT: totsyns:',totalsyns,'syncomp_sum',syncomp_sum) for syn in syncomps: syn[1]=float(syn[1])/syncomp_sum avail_syns=np.int(np.round(syncomp_sum)) return syncomps,totalsyns,avail_syns
def fix_calcium(neurontypes, model): """kluge to fix buffer capacity in CaPool Initiating hsolve calculates CaConc.B from thickness, length, diameter; ignores buffer capacity. """ comptype = 'ZombieCompartment' cacomptype = 'ZombieCaConc' ca_elem_suffix = model.CaPlasticityParams.CalciumParams.CaName buffer_capacity_density = model.CaPlasticityParams.BufferCapacityDensity log.info('Fixing calcium buffer capacity for {} elements'.format(comptype)) for ntype in neurontypes: for comp in moose.wildcardFind('{}/#[TYPE={}]'.format(ntype, comptype)): cacomps = [ m for m in moose.element(comp).children if m.className == cacomptype ] for cacomp in cacomps: buf_capacity = distance_mapping(buffer_capacity_density, comp) if cacomp.length: vol = np.pi * cacomp.diameter * cacomp.thick * cacomp.length else: vol = 4. / 3. * np.pi * ( (cacomp.diameter / 2)**3 - (cacomp.diameter / 2 - cacomp.thick)**3) cacomp.B = 1. / (constants.Faraday * vol * 2) / buf_capacity # volume correction
def extract_and_add_difshell(model, shellMode, comp, spine): params = model.CaPlasticityParams Pumps = distance_mapping(params.PumpDensity, comp) Buffers = distance_mapping(params.BufferDensity, comp) shape = distance_mapping(params.ShapeConfig, comp) shellsparams = CalciumConfig( shellMode=shellMode, increase_mode=shape.ThicknessIncreaseMode, outershell_thickness=shape.OutershellThickness, thickness_increase=shape.ThicknessIncreaseFactor, min_thickness=shape.MinThickness) dshells_dend = addDifMachineryToComp(model, comp, Buffers, Pumps, shellsparams, spine) return dshells_dend
def create_synpath_array(allsyncomp_list, syntype, NumSyn): syncomps = [] totalsyn = 0 for syncomp in allsyncomp_list: xloc = syncomp.parent.x yloc = syncomp.parent.y dist = np.sqrt(xloc * xloc + yloc * yloc) SynPerComp = util.distance_mapping(NumSyn[syntype], dist) syncomps.append([syncomp.path, SynPerComp]) totalsyn += SynPerComp return syncomps, totalsyn
def extract_and_add_capool(model, comp, pools): params = model.CaPlasticityParams shape = distance_mapping(params.ShapeConfig, comp) OuterShellThick = shape.OutershellThickness BufCapacity = distance_mapping(params.BufferCapacityDensity, comp) if hasattr(params, 'Taus'): tau = distance_mapping(params.Taus, comp) tauScale = params.tauScale else: tau = params.CalciumParams.tau tauScale = None pool = addCaPool(model, OuterShellThick, BufCapacity, comp, pools, tau=tau, tauScale=tauScale) return pool
def create_synpath_array(allsyncomp_list, syntype, NumSyn, prob=None, soma_loc=[0, 0, 0]): #list of possible synapses with connection probability, which takes into account prior creation of synapses syncomps = [] totalsyns = 0 #print(' CREATE_SYNPATH_ARRAY: syntype:', syntype, 'prob',prob,'soma_loc',soma_loc) for syncomp in allsyncomp_list: dist, nm = util.get_dist_name(syncomp.parent, soma_loc) if prob: #calculate dendritic distance dependent connection probability to store with table dist_prob = dendritic_distance_dep_connect_prob(prob, dist) else: dist_prob = 1 #print(' syncomp',syncomp,'dist',dist,'prob',dist_prob) #length of syncomps is the number of synapses available for connections #this is the number of synchans * number of synapses per synchan #optionally multiply by probably of connecting to that synchan, e.g. based on distance dependence #since there may be multiple types of pre-synaptic neurons, reduce length of syncomps if synapses already made # if dist_prob > 0: #only add synchan to list if connection probability is non-zero sh = moose.element(syncomp.path + '/SH') # TODO: Fix for synapses on spines; there should only be 1 per spine if NAME_HEAD in nm: SynPerComp = 1 #- sh.numSynapses else: SynPerComp = util.distance_mapping(NumSyn[syntype], dist) #-sh.numSynapses #print(' sh',sh.path,'numSynapses',sh.numSynapses,'synpercomp',SynPerComp,'NumSyn',NumSyn[syntype]) for i in range(SynPerComp): totalsyns += dist_prob #totalsyns=total synapses to connect if i < SynPerComp - sh.numSynapses: syncomps.append([syncomp.path + '/SH', dist_prob]) #print('{} synapses already connected of {} total synapses, adding 1 synapse with {} dist_prob to list'.format(sh.numSynapses,SynPerComp,dist_prob)) else: syncomps.append([syncomp.path + '/SH', 0]) #print(' {} synapses already connected of {} total, adding 1 syn with 0 prob to list'.format(sh.numSynapses,SynPerComp)) #normalize probability to pdf syncomp_sum = sum([p[1] for p in syncomps]) #print('CONNECT: totsyns:',totalsyns,'syncomp_sum',syncomp_sum) if syncomp_sum > 0: for syn in syncomps: syn[1] = float(syn[1]) / syncomp_sum else: log.info( '&&&&&&&&& Un Oh, no synapes remaining on post-synaptic neurons, syncom_sum=' .format(syncomp_sum)) avail_syns = np.int(np.round(syncomp_sum)) return syncomps, totalsyns, avail_syns
def test_distance_mapping_func(): near = (0, 20) far = (20, 30) map = {near: (lambda x: 5 + x), far: (lambda x: 30 - x)} assert util.distance_mapping(map, 0) == 5 assert util.distance_mapping(map, 10) == 15 assert util.distance_mapping(map, 20) == 10 assert util.distance_mapping(map, 25) == 5 assert util.distance_mapping(map, 30) == 0 assert util.distance_mapping(map, 35) == 0
def test_distance_mapping(): near = (0, 20) far = (20, 30) map = {near: 5, far: 6} assert util.distance_mapping(map, 0) == 5 assert util.distance_mapping(map, 10) == 5 assert util.distance_mapping(map, 20) == 6 assert util.distance_mapping(map, 25) == 6 assert util.distance_mapping(map, 30) == 0 assert util.distance_mapping(map, 35) == 0
def distanceWeighting(elementList, distanceMapping): '''Creates non-uniform, distance-dependent weighted probability. distanceMapping should be a callable or a dictionary of {(distanceMin,distanceMax):RelativeWeight} The distance mapping can be relative weights as a function of distance, and this function will normalize the sum to 1. Returns array of weights that can be passed to selectRandom for non-uniform distance-dependent selection of inputs ''' weights = [] for el in elementList: w = util.distance_mapping(distanceMapping, el) weights.append(w) # Normalize weights to sum to 1: weights = weights/np.sum(weights) return weights
def distanceWeighting(elementList, distanceMapping): '''Creates non-uniform, distance-dependent weighted probability. distanceMapping should be a callable or a dictionary of {(distanceMin,distanceMax):RelativeWeight} The distance mapping can be relative weights as a function of distance, and this function will normalize the sum to 1. Returns array of weights that can be passed to selectRandom for non-uniform distance-dependent selection of inputs ''' weights = [] for el in elementList: w = util.distance_mapping(distanceMapping, el) weights.append(w) # Normalize weights to sum to 1: weights = weights / np.sum(weights) return weights
def fix_calcium(neurontypes, model, buf_cap=None): """kluge to fix buffer capacity in CaPool Initiating hsolve calculates CaConc.B from thickness, length, diameter; ignores buffer capacity. """ comptype = 'ZombieCompartment' cacomptype = 'ZombieCaConc' for ntype in neurontypes: ### if neurons come from different packages, they may have different buffer_capacity_densities ### if so, use the dictionary of those values in this function if buf_cap: buffer_density = buf_cap[ntype] log.info( 'Fixing calcium buffer capacity for {} elements, using {}'. format(comptype, list(buffer_density.values()))) else: buffer_density = model.CaPlasticityParams.BufferCapacityDensity log.info('Fixing calcium buffer capacity for {} elements'.format( comptype)) for comp in moose.wildcardFind('{}/#[TYPE={}]'.format(ntype, comptype)): cacomps = [ m for m in moose.element(comp).children if m.className == cacomptype ] for cacomp in cacomps: buf_capacity = distance_mapping(buffer_density, comp) radius = cacomp.diameter / 2. if cacomp.thick > radius: cacomp.thick = radius if cacomp.length: vol = np.pi * cacomp.length * (radius**2 - (radius - cacomp.thick)**2) else: vol = 4. / 3. * np.pi * ( (cacomp.diameter / 2)**3 - (cacomp.diameter / 2 - cacomp.thick)**3) cacomp.B = 1. / (constants.Faraday * vol * 2) / buf_capacity # volume correction
def create_synpath_array(allsyncomp_list, syntype, NumSyn, prob=None): # list of possible synapses with connection probability, which takes into account prior creation of synapses syncomps = [] totalsyns = 0 print('CONNECT: syntype:', syntype, 'prob', prob) for syncomp in allsyncomp_list: dist, nm = util.get_dist_name(syncomp.parent) if prob: # calculate dendritic distance dependent connection probability to store with table dist_prob = dendritic_distance_dep_connect_prob(prob, dist) else: dist_prob = 1 # print('syncomp',syncomp,'dist',dist,'prob',dist_prob) if dist_prob > 0: # only add synchan to list if connection probability is non-zero sh = moose.element(syncomp.path + '/SH') # TODO: Fix for synapses on spines; there should only be 1 per spine if NAME_HEAD in nm: SynPerComp = 1 # - sh.numSynapses else: SynPerComp = util.distance_mapping(NumSyn[syntype], dist) # -sh.numSynapses for i in range(SynPerComp): totalsyns += dist_prob # totalsyns=total synapses to connect if i < SynPerComp - sh.numSynapses: syncomps.append([syncomp.path + '/SH', dist_prob]) # print('{} synapses already connected of {} total synapses, adding 1 synapse with {} dist_prob to list'.format(sh.numSynapses,SynPerComp,dist_prob)) else: syncomps.append([syncomp.path + '/SH', 0]) # print('{} synapses already connected of {} total synapses, adding 1 synapse with 0 dist_prob to list'.format(sh.numSynapses,SynPerComp)) # normalize probability to pdf syncomp_sum = sum([p[1] for p in syncomps]) print('CONNECT: totsyns:', totalsyns, 'syncomp_sum', syncomp_sum) for syn in syncomps: syn[1] = float(syn[1]) / syncomp_sum avail_syns = np.int(np.round(syncomp_sum)) return syncomps, totalsyns, avail_syns
def create_neuron(model, ntype, ghkYN): p_file = find_morph_file(model, ntype) try: cellproto = moose.loadModel(p_file, ntype) except IOError: print('could not load model from {!r}'.format(p_file)) raise #######channels Cond = model.Condset[ntype] for comp in moose.wildcardFind('{}/#[TYPE=Compartment]'.format(ntype)): xloc = moose.Compartment(comp).x yloc = moose.Compartment(comp).y #Possibly this should be replaced by pathlength dist = np.sqrt(xloc * xloc + yloc * yloc) log.debug('comp {.path} dist {}', comp, dist) # #If we are using GHK, just create one GHK per compartment, connect it to comp #calcium concentration is connected in a different function if ghkYN: ghkproto = moose.element('/library/ghk') ghk = moose.copy(ghkproto, comp, 'ghk')[0] moose.connect(ghk, 'channel', comp, 'channel') else: ghk = [] for channame, chanparams in model.Channels.items(): c = _util.distance_mapping(Cond[channame], comp) if c > 0: log.debug('Testing Cond If {} {}', channame, c) calciumPermeable = chanparams.calciumPermeable add_channel.addOneChan(channame, c, comp, ghkYN, ghk, calciumPermeable=calciumPermeable) return cellproto
def addCalcium(model, ntype): pools = CaProto(model) capool = [] params = model.CaPlasticityParams for comp in moose.wildcardFind(ntype + '/#[TYPE=Compartment]'): if NAME_NECK not in comp.name and NAME_HEAD not in comp.name: # Look for spines connected to the dendrite shellMode = distance_mapping(params.CaShellModeDensity, comp) dshells_dend = add_calcium_to_compartment(model, shellMode, comp, pools, capool, spine=False) if dshells_dend == -1: return if model.spineYN: spines = [] neighbors = list(comp.neighbors['raxial']) neighbors.extend(list(comp.neighbors['axial'])) for neighbor in neighbors: if NAME_NECK in neighbor.name: spines.append(neighbor) else: 'Could not find spines!!!' for sp in spines: shellMode = distance_mapping(params.CaShellModeDensity, moose.element(sp)) dshells_neck = add_calcium_to_compartment( model, shellMode, moose.element(sp), pools, capool, spine=True) if dshells_neck == -1: return if dshells_dend and dshells_neck: # diffusion between neck and dendrite moose.connect(dshells_neck[-1], "outerDifSourceOut", dshells_dend[0], "fluxFromOut") moose.connect(dshells_dend[0], "innerDifSourceOut", dshells_neck[-1], "fluxFromIn") heads = [] neighbors = list(moose.element(sp).neighbors['raxial']) neighbors.extend(list( moose.element(sp).neighbors['axial'])) for neighbor in neighbors: if NAME_HEAD in neighbor.name: heads.append(neighbor) if not heads: 'Could not find heads!!!' for head in heads: shellMode = distance_mapping(params.CaShellModeDensity, moose.element(head)) dshells_head = add_calcium_to_compartment( model, shellMode, moose.element(head), pools, capool, spine=True) if dshells_head == -1: return if dshells_head and dshells_neck: # diffusion between neck and dendrite moose.connect(dshells_head[-1], "outerDifSourceOut", dshells_neck[0], "fluxFromOut") moose.connect(dshells_neck[0], "innerDifSourceOut", dshells_head[-1], "fluxFromIn") return capool
def test_distance_mapping_inf(): map = {(0, np.inf): (lambda x: 3 * np.exp(-x / 5))} assert_close(util.distance_mapping(map, 0), 3) assert_close(util.distance_mapping(map, 5), 1.103638323514327) assert_close(util.distance_mapping(map, 1e5), 0)