Changeset 77 for branches

Show
Ignore:
Timestamp:
05/24/07 13:16:52 (5 years ago)
Author:
apdavison
Message:

* Deleted the facetsml and nest2 modules, which are not mature enough to be in the 0.3 release.

  • Deleted the misc directory, which is of no use to anyone, really.
  • Deleted some commented-out code.
  • Removed methods that aren't part of the official 0.3 API.

Don't worry - all the deleted stuff is still in the trunk!

Location:
branches/0.3
Files:
3 removed
7 modified

Legend:

Unmodified
Added
Removed

  • branches/0.3/README

    r10 r77  
    1111Fetching the source: 
    1212 
    13 svn co https://neuralensemble.kip.uni-heidelberg.de/svn/PyNN/trunk pyNN   
     13svn co https://neuralensemble.kip.uni-heidelberg.de/svn/PyNN/branches/0.3 pyNN   
    1414 
    1515** Anonymous checkout is allowed 
    1616 
    17 Commiting Changes: 
     17Committing Changes: 
    1818 
    1919In the svn dir: 

  • branches/0.3/__init__.py

    r26 r77  
    1 __version__ = '0.3alpha' 
     1__version__ = '0.3.0' 
    22__all__ = ["common", "random", "nest", "oldneuron","neuron", "pcsim" ] 

  • branches/0.3/common.py

    r76 r77  
    162162        'e_rev_I'    : -70.0,   # Reversal potential for inhibitory input in mV 
    163163        'v_thresh'   : -50.0,   # Spike threshold in mV. 
    164         'v_reset'    : -65.0,   # Reset potential after a spike in mV. 
    165         'i_offset'   : 0.0,     # Offset current in nA 
     164        'v_reset'    : -65.0,   # Reset potential after a spike in mV. 
     165        'i_offset'   : 0.0,     # Offset current in nA 
    166166        'v_init'     : -65.0,   # Membrane potential in mV at t = 0 
    167167    } 

  • branches/0.3/nest.py

    r76 r77  
    44$Id:nest.py 5 2007-04-16 15:01:24Z davison $ 
    55""" 
    6 __version__ = "$Revision:5 $" 
     6__version__ = "$Revision$" 
    77 
    88import pynest 
    … …  
    11541154            self._targets.append(tgt)         
    11551155            self._targetPorts.append(pynest.connectWD(pre_addr,post_addr, 1000*weight, delay)) 
    1156  
    1157     def _2D_Gauss(self,parameters,synapse_type=None): 
    1158         """ 
    1159         Source neuron is connected to a 2D targetd population with a spatial profile (Gauss). 
    1160         parameters should have: 
    1161         rng: 
    1162         source_position: x,y of source neuron mapped to target populatio. 
    1163         source_id: source id 
    1164         n: number of synpases 
    1165         sigma: sigma of the Gauss 
    1166         """ 
    1167         self.synapse_type = synapse_type 
    1168         def rcf_2D(parameters): 
    1169             rng = parameters['rng'] 
    1170             pre_id = parameters['pre_id'] 
    1171             pre_position = parameters['pre_position'] 
    1172             n = parameters['n'] 
    1173             sigma = parameters['sigma'] 
    1174             weight = parameters['weight'] 
    1175             delay = parameters['delay'] 
    1176              
    1177             phi = rng.uniform(size=n)*(2.0*pi) 
    1178             r = rng.normal(scale=sigma,size=n) 
    1179             target_position_x = numpy.floor(pre_position[1]+r*numpy.cos(phi)) 
    1180             target_position_y = numpy.floor(pre_position[0]+r*numpy.sin(phi)) 
    1181             target_id = [] 
    1182             for syn_nr in range(len(target_position_x)): 
    1183                 #print syn_nr 
    1184                 try: 
    1185                     # print target_position_x[syn_nr] 
    1186                     target_id.append(self.post[(target_position_x[syn_nr],target_position_y[syn_nr])]) 
    1187                     # print target_id 
    1188                 except IndexError: 
    1189                     target_id.append(False) 
    1190              
    1191             pynest.divConnect(pre_id,target_id,[weight],[delay]) 
    1192          
    1193          
    1194         n = parameters['n'] 
    1195                  
    1196         if n > 0: 
    1197             ratio_dim_pre_post = ((1.*self.pre.dim[0])/(1.*self.post.dim[0])) 
    1198             print 'ratio_dim_pre_post',ratio_dim_pre_post 
    1199             run_id = 0 
    1200  
    1201             for pre in numpy.reshape(self.pre.cell,(self.pre.cell.size)): 
    1202                 #print 'pre',pre 
    1203                 run_id +=1 
    1204                 #print 'run_id',run_id 
    1205                 if numpy.mod(run_id,500) == 0: 
    1206                     print 'run_id',run_id 
    1207                  
    1208                 pre_position_tmp = self.pre.locate(pre) 
    1209                 parameters['pre_position'] = numpy.divide(pre_position_tmp,ratio_dim_pre_post) 
    1210                 parameters['pre_id'] = pre 
    1211                 #a=Projection(self.pre,self.post,'rcf_2D',parameters) 
    1212                 rcf_2D(parameters) 
    1213  
    1214     def _test_delay(self,params,synapse_type=None): 
    1215         self.synapse_type = synapse_type 
    1216         # debug get delays from outside 
    1217         #delay_array = parameters['delays_array'] 
    1218         #weight_array = parameters['weights_array'] 
    1219         #target_id = parameters['target_id'] 
    1220         #pre_id = parameters['pre_id'] 
    1221         print 'inside test_delay' 
    1222         print 'delays ',params['delays_array'] 
    1223         print 'weights ',params['weights_array'] 
    1224         print 'pre_id ',params['pre_id'] 
    1225         print 'target_id ',params['target_id'] 
    1226         eval(params['eval_string']) 
    1227         #cons=pynest.divConnect(params['pre_id'],params['target_id'],params['weights_array'].tolist(),params['delays_array'].tolist()) 
    1228         #pynest.divConnect(pre_id,target_id,weight_array.tolist(),delay_array.tolist()) 
    1229         print 'leaving test_delay' 
    1230          
    1231     def _3D_Gauss(self,parameters,synapse_type=None): 
    1232         """ 
    1233         Source neuron is connected to a 3D targetd population with a spatial profile (Gauss). 
    1234         parameters should have: 
    1235         rng: 
    1236         source_position: x,y of source neuron mapped to target populatio. 
    1237         source_id: source id 
    1238         n: number of synpases 
    1239         sigma: sigma of the Gauss 
    1240         """ 
    1241         #def get_ids(self,parameters): 
    1242             #ids = [] 
    1243             #if len(addrs) == self.ndim: 
    1244         # 
    1245         #for addr in range(len(parameters['x'])): 
    1246         #    try: 
    1247         #        ids = numpy.append(ids,post.cell[addr]) 
    1248         #    except IndexError: 
    1249         #        pass 
    1250         #else: 
    1251         #    raise common.InvalidDimensionsError, "Population has %d dimensions. Address was %s" % (self.ndim,str(addrs)) 
    1252         #return ids.astype('int') 
    1253  
    1254          
    1255         def rcf_3D(parameters): 
    1256             rng = parameters['rng'] 
    1257             rng_params = parameters['rng_params'] 
    1258             pre_id = parameters['pre_id'] 
    1259             pre_position = parameters['pre_position'] 
    1260             n = parameters['n'] 
    1261             sigma = parameters['sigma'] 
    1262             weight = parameters['weight'] 
    1263             weight = weight*1000 # weights should be in nA or µS, but iaf_neuron uses pA and iaf_cond_neuron uses nS. 
    1264             # Using convention in this way is not ideal. We should be able to look up the units used by each model somewhere. 
    1265              
    1266             min_delay_offset = parameters['min_delay_offset'] 
    1267             post_dim = parameters['post_dim'] 
    1268             params_dist = parameters['params_dist'] 
    1269             size_in_mm = parameters['size_in_mm'] 
    1270             #architecture = parameters['architecture'] 
    1271             conduction_speed = parameters['conduction_speed'] 
    1272             #min_delay = parameters['min_delay'] 
    1273              
    1274             phi = rng.uniform(size=n)*(2.0*pi) 
    1275             r = rng.normal(scale=sigma,size=n) 
    1276             # for z  
    1277             #h = rng.uniform(size=n)*post_dim[2] # here post dim because it does not metter where it comes from in pre dim 
    1278              
    1279             target_position_x = numpy.floor(pre_position[1]+r*numpy.cos(phi)).astype('int') 
    1280             target_position_y = numpy.floor(pre_position[0]+r*numpy.sin(phi)).astype('int') 
    1281              
    1282  
    1283             # because array[-1] gives you the last entrie, we have to get rid of the negative values, in either x or y 
    1284             valid_positions= eval('target_position_x >= 0')*eval('target_position_y >= 0') 
    1285             target_position_x = target_position_x[valid_positions] 
    1286             target_position_y = target_position_y[valid_positions] 
    1287             r = r[valid_positions]#  this is needed for the distant dependant delay  
    1288             # new n 
    1289             n = len(target_position_x) 
    1290              
    1291             # for z dim, here we dont have to remove unvalid pos, because the values can not be unvalid since it is unfiorm dis between the limits 
    1292             # however, n is reduced 
    1293             h = rng.uniform(size=n)*post_dim[2] # here post dim because it does not metter where it comes from in pre dim 
    1294             target_position_z = numpy.floor(h).astype('int') 
    1295              
    1296             target_id = [] 
    1297             # an array of bool, will be filled with True if synpase is on the grid, with False when outside 
    1298             target_id_bool = numpy.array([],dtype='bool') 
    1299             # __getitems__ version 
    1300              
    1301              
    1302             for syn_nr in range(len(target_position_x)): 
    1303                 try: 
    1304                     target_id.append(self.post.cell[(target_position_x[syn_nr],target_position_y[syn_nr],target_position_z[syn_nr])]) 
    1305                     #target_id.append(self.post[(target_position_x[syn_nr],target_position_y[syn_nr],target_position_z[syn_nr])]) 
    1306                     target_id_bool = numpy.append(target_id_bool,True) 
    1307                     #target_id_bool.append(True) 
    1308                 except IndexError: 
    1309                     target_id_bool = numpy.append(target_id_bool,False) 
    1310                     #target_id_bool.append(False) 
    1311                     #pass 
    1312                 # some synapses fall outside the grid, they are lost 
    1313                     #target_id.append(False) 
    1314                      
    1315             # number of synapses that are actually made 
    1316             n_syn = len(target_id)  
    1317             # r will be used to calculate the distant dependent delay, but since some synapses have not been made, they have to be removed 
    1318             r_syn = numpy.abs(r[target_id_bool]) 
    1319             # print 'min r_syn: ',r_syn.min() 
    1320             # print 'max r_syn: ',r_syn.max() 
    1321             # from r_syn we calculate the delay, with 0.1 m/s --> 0.1 mm/ms 
    1322             # r_syn is in units of population size, meaning in grid size, since sigma was around 0.4 of p.dim 
    1323             # we have to convert it to mm to get delay in mm/ms 
    1324             # we do this by: r_syn * architecture['a']/post_dim[0] , the x dim of the post synaptic population 
    1325             # should give us: r_syn in mm, since r_syn [in grid units], post_dim[0] [max grid units],   architecture['a'] is in mm 
    1326             # print 'size_in_mm: ',size_in_mm 
    1327             # print 'post_dim[0]: ',post_dim[0] 
    1328             # print 'conduction_speed: ',conduction_speed 
    1329             # print 'params dist: ',params_dist 
    1330             # units*mm/units 
    1331             r_syn2 = r_syn*size_in_mm/numpy.float(post_dim[0]) 
    1332             #print 'type r_syn',type(r_syn) 
    1333             # there is a min dely, which is around 1.0 ms, params['min_delay'] see Markam 97 
    1334             min_delay_offset_array = rng_params.normal(loc=min_delay_offset,scale=abs(min_delay_offset*params_dist),size=n_syn) 
    1335             #print 'type min_delay',type(min_delay_array) 
    1336             # print 'min min_delay_arrayr_syn: ',min_delay_array.min() 
    1337             # print 'max min_delay_array: ',min_delay_array.max() 
    1338             delay_array = numpy.add(r_syn2/conduction_speed,min_delay_offset_array) 
    1339             #delay_array=delay_array.round(decimals=2) 
    1340             #print 'type delay_array',type(delay_array) 
    1341             #print 'min delay_arrayr: ',delay_array.min() 
    1342             #print 'max delay_array: ',delay_array.max() 
    1343             #print 'min delay_arrayr.tolsit(): ',min(delay_array.tolist()) 
    1344             #print 'max delay_array.tolist(): ',max(delay_array.tolist()) 
    1345             #print 'params dist', params_dist 
    1346             #if params_dist >0: 
    1347                 #print 'with dist' 
    1348             # print 'n_syn',n_syn 
    1349             # print 'abs(weight*params_dist) ',abs(weight*params_dist) 
    1350             # print 'weight ', weight 
    1351              
    1352              
    1353             weight_array = rng_params.normal(loc=weight,scale=abs(weight*params_dist),size=n_syn) 
    1354             #weight_array=weight_array.round(decimals=2) 
    1355                 #delay_list = rng_params.normal(loc=delay,scale=delay/params_dist,size=n_syn) 
    1356             #delay_list = r_syn/transmission_speed 
    1357  
    1358              
    1359             # debug get delays from outside 
    1360             #delay_array = parameters['delays_array'] 
    1361             #weight_array = parameters['weights_array'] 
    1362             #target_id = parameters['target_id'] 
    1363             #if pre_id==100: 
    1364             #    print '#############################################' 
    1365             #    print 'This is the data in 3D Gauss' 
    1366             #    print '#############################################' 
    1367             #    print 'preneuron id',pre_id 
    1368                 #print 'r_syn: ',r_syn 
    1369                 #print 'r_syn2',r_syn2 
    1370                 #print 'min_delay_offset_array ',min_delay_offset_array 
    1371             #    print 'delay_array ',delay_array 
    1372             #    print 'type first element of delay ',type(delay_array[0]) 
    1373             #    print 'weight ',weight_array 
    1374             #    print 'type first element of weight ',type(weight_array[0]) 
    1375             #    print 'now we dive into pynest.hl_api.... yeah' 
    1376             #    print '#############################################' 
    1377             #    print '\n' 
    1378                 #print 'size_in_mm: ',size_in_mm 
    1379                 #print 'post_dim[0]: ',post_dim[0] 
    1380                 #print 'conduction_speed: ',conduction_speed 
    1381                 #print 'params dist: ',params_dist 
    1382             #    printed = True 
    1383             #    done = True 
    1384             #print 'len delay == len weigth',len(delay_array.tolist())==len(weight_array.tolist()) 
    1385                 #print 'len weigth ', len(weight_array.tolist()) 
    1386                 #print 'delay list: ',type(delay_array.tolist()) 
    1387  
    1388             #pynest.divConnect(pre_id,target_id,weight_array.tolist(),delay_array.tolist()) 
    1389             #delays_array = rng.normal(loc=pynest.getDict([0])[0]['max_delay']/2.,scale=abs(pynest.getDict([0])[0]['max_delay']/2.*params_dist),size=n) 
    1390             #weights_array = delays_array 
    1391              
    1392             pynest.divConnect(pre_id,target_id,weight_array.tolist(),delay_array.tolist()) 
    1393              
    1394             #return delay_array 
    1395             #else: 
    1396                 #print 'no dist' 
    1397             #    pynest.divConnect(pre_id,target_id,[weight],[delay]) 
    1398          
    1399          
    1400         n = parameters['n'] 
    1401         #global printed 
    1402         #printed = False 
    1403         #done = False 
    1404         if n > 0: 
    1405             ratio_dim_pre_post = ((1.*self.pre.dim[0])/(1.*self.post.dim[0])) 
    1406             #print 'ratio_dim_pre_post',ratio_dim_pre_post 
    1407             run_id = 0 
    1408              
    1409             for pre in numpy.reshape(self.pre.cell,(self.pre.cell.size)): 
    1410                 #if done: 
    1411                 #    return 
    1412                 #print 'pre',pre 
    1413                 run_id +=1 
    1414                 #print 'run_id',run_id 
    1415                 if numpy.mod(run_id,500) == 0: 
    1416                     print 'run_id',run_id 
    1417                  
    1418                 pre_position_tmp = self.pre.locate(pre) 
    1419                 parameters['pre_position'] = numpy.divide(pre_position_tmp,ratio_dim_pre_post) 
    1420                 parameters['pre_id'] = pre 
    1421                 parameters['post_dim'] = self.post.dim 
    1422                 #a=Projection(self.pre,self.post,'rcf_2D',parameters) 
    1423                 rcf_3D(parameters) 
    1424                 #if done: 
    1425                 #    return 
    1426          
    1427  
    14281156     
    14291157    # --- Methods for setting connection parameters ---------------------------- 

  • branches/0.3/neuron.py

    r76 r77  
    560560    for param,val in paramDict.items(): 
    561561        if isinstance(val,str): 
    562             ## If we know the hoc name of the object (set() applied to a population object), we use it 
    563             #if (hocname != None): 
    564             #    fmt = '%s.%s = "%s"' 
    565             #else: 
    566             #    fmt = 'cell%d.%s = "%s"' 
    567562            fmt = 'pc.gid2cell(%d).%s = "%s"' 
    568563        elif isinstance(val,list): 
    569564            cmds,argstr = _hoc_arglist([val]) 
    570565            hoc_commands += cmds 
    571             ## If we know the hoc name of the object (set() applied to a population object), we use it 
    572             #if (hocname != None): 
    573             #    fmt = '%s.%s = %s' 
    574             #else: 
    575             #    fmt = 'cell%d.%s = %s' 
    576566            fmt = 'pc.gid2cell(%d).%s = %s' 
    577567            val = argstr 
    578568        else: 
    579             ## If we know the hoc name of the object (set() applied to a population object), we use it 
    580             #if (hocname != None): 
    581             #    fmt = '%s.%s = %g' 
    582             #else: 
    583             #    fmt = 'cell%d.%s = %g' 
    584569            fmt = 'pc.gid2cell(%d).%s = %g' 
    585570        for cell in cells: 
    586571            if cell in gidlist: 
    587                 ## If we know the hoc name of the object (set() applied to a population object), we use it 
    588                 #if (hocname != None): 
    589                 #    hoc_commands += [fmt % (hocname,param,val), 
    590                 #                     'tmp = %s.param_update()' %hocname] 
    591                 #else: 
    592                 #    hoc_commands += [fmt % (cell,param,val), 
    593                 #                     'tmp = cell%d.param_update()' %cell] 
    594572                hoc_commands += [fmt % (cell,param,val), 
    595573                                 'tmp = pc.gid2cell(%d).param_update()' % cell] 
    … …  
    662640         
    663641        common.Population.__init__(self,dims,cellclass,cellparams,label) 
    664         #if self.ndim > 1: 
    665         #    for i in range(1,self.ndim): 
    666         #        if self.dim[i] != self.dim[0]: 
    667         #            raise common.InvalidDimensionsError, "All dimensions must be the same size (temporary restriction)." 
    668  
     642         
    669643        # set the steps list, used by the __getitem__() method. 
    670644        self.steps = [1]*self.ndim 

  • branches/0.3/pcsim.py

    r76 r77  
    995995    nProj = 0 
    996996     
    997     #class ConnectionDict: 
    998     #         
    999     #    def __init__(self,parent): 
    1000     #        self.parent = parent 
    1001     # 
    1002     #    def __getitem__(self,id): 
    1003     #        """Returns a connection id. 
    1004     #        Suppose we have a 2D Population (5x3) projecting to a 3D Population (4x5x7). 
    1005     #        Total number of possible connections is 5x3x4x5x7 = 2100. 
    1006     #        Therefore valid calls are: 
    1007     #        connection[2099] - 2099th possible connection (may not exist) 
    1008     #        connection[14,139] - connection between 14th pre- and 139th postsynaptic neuron (may not exist) 
    1009     #        connection[(4,2),(3,4,6)] - connection between presynaptic neuron with address (4,2) 
    1010     #        and post-synaptic neuron with address (3,4,6) (may not exist). 
    1011     #        """ 
    1012     #        if isinstance(id, int): # linear mapping 
    1013     #            preID = id/self.parent.post.size; postID = id%self.parent.post.size 
    1014     #            return self.__getitem__((preID,postID)) 
    1015     #        elif isinstance(id, tuple): # (pre,post) 
    1016     #            if len(id) == 2: 
    1017     #                pre = id[0] 
    1018     #                post = id[1] 
    1019     #                if isinstance(pre,int) and isinstance(post,int): 
    1020     #                    pre_coords = self.parent.pre.locate(pre) 
    1021     #                    post_coords = self.parent.post.locate(post) 
    1022     #                    return self.__getitem__((pre_coords,post_coords)) 
    1023     #                elif isinstance(pre,tuple) and isinstance(post,tuple): # should also allow lists 
    1024     #                    if len(pre) == self.parent.pre.ndim and len(post) == self.parent.post.ndim: 
    1025     #                        fmt = "[%d]"*(len(pre)+len(post)) 
    1026     #                        address = fmt % (pre+post) 
    1027     #                    else: 
    1028     #                        raise common.InvalidDimensionsError 
    1029     #                else: 
    1030     #                    raise KeyError 
    1031     #            else: 
    1032     #                raise common.InvalidDimensionsError 
    1033     #        else: 
    1034     #            raise KeyError #most appropriate? 
    1035     #         
    1036     #        return address 
    1037     # 
    1038      
    1039997    def __init__(self, presynaptic_population, postsynaptic_population, method='allToAll', methodParameters=None, source=None, target=None, label=None, rng=None): 
    1040998        """ 

  • branches/0.3/setup.py

    r18 r77  
    55setup( 
    66    name = "PyNN", 
    7     version = "0.3.0alpha", 
     7    version = "0.3.0", 
    88    package_dir={'pyNN': ''}, 
    99    packages = ['pyNN'],