Changeset 468
- Timestamp:
- 10/04/08 00:21:06 (2 months ago)
- Files:
-
- trunk/src/nest2/__init__.py (modified) (3 diffs)
- trunk/src/nest2/connectors.py (modified) (12 diffs)
- trunk/src/nest2/synapses.py (modified) (6 diffs)
- trunk/test/unittests/nest2tests.py (modified) (9 diffs)
Legend:
- Unmodified
- Added
- Removed
- Modified
- Copied
- Moved
trunk/src/nest2/__init__.py
r465 r468 525 525 connect_id += [Connection(src, tgt, 'static_synapse')] 526 526 #except nest.SLIError: 527 except Exception : # unfortunately, SLIError seems to have disappeared.Hopefully it will be reinstated.528 raise common.ConnectionError 527 except Exception, errmsg: # unfortunately, SLIError seems to have disappeared.Hopefully it will be reinstated. 528 raise common.ConnectionError, errmsg 529 529 return connect_id 530 530 … … 1271 1271 """Each presynaptic cell makes a fixed number of connections.""" 1272 1272 n = parameters['n'] 1273 allow_self_connections = True 1273 1274 if parameters.has_key('allow_self_connections'): 1274 1275 allow_self_connections = parameters['allow_self_connections'] … … 1279 1280 """Each postsynaptic cell receives a fixed number of connections.""" 1280 1281 n = parameters['n'] 1282 allow_self_connections = True 1281 1283 if parameters.has_key('allow_self_connections'): 1282 1284 allow_self_connections = parameters['allow_self_connections'] trunk/src/nest2/connectors.py
r442 r468 17 17 sin, sinh, sqrt, tan, tanh 18 18 19 CHECK_CONNECTIONS = True 20 21 class InvalidWeightError(Exception): pass 22 19 23 def _convertWeight(w, synapse_type): 20 24 weight = w*1000.0 … … 22 26 all_negative = (weight<=0).all() 23 27 all_positive = (weight>=0).all() 24 assert all_negative or all_positive, "Weights must be either all positive or all negative" 28 if not (all_negative or all_positive): 29 raise InvalidWeightError("Weights must be either all positive or all negative") 25 30 if synapse_type == 'inhibitory' and all_positive: 26 31 weight *= -1 32 elif synapse_type == 'excitatory': 33 if not all_positive: 34 raise InvalidWeightError("Weights must be positive for excitatory synapses") 27 35 elif is_number(weight): 28 36 if synapse_type == 'inhibitory' and weight > 0: 29 37 weight *= -1 38 elif synapse_type == 'excitatory': 39 if weight < 0: 40 raise InvalidWeightError("Weight must be positive for excitatory synapses. Actual value %s" % weight) 30 41 else: 31 raise TypeError("we must be either a number or a numpy array")42 raise TypeError("weight must be either a number or a numpy array") 32 43 return weight 33 44 34 35 def get_target_ports(pre, target_list, synapse_type): 36 # The connection dict returned by NEST contains a list of target ids, 37 # so it is possible to obtain the target port by finding the index of 38 # the target in this list. For now, we stick with saving the target port 39 # in Python (faster, but more memory needed), but PyNEST should soon have 40 # a function to do the lookup, at which point we will switch to using that. 41 first_port = len(nest.GetConnections([pre], synapse_type)[0]['targets']) 42 return range(first_port, first_port+len(target_list)) 43 45 def check_connections(prj, src, intended_targets): 46 conn_dict = nest.GetConnections([src], prj.plasticity_name)[0] 47 if isinstance(conn_dict, dict): 48 N = len(intended_targets) 49 all_targets = conn_dict['targets'] 50 actual_targets = all_targets[-N:] 51 assert actual_targets == intended_targets, "%s != %s" % (actual_targets, intended_targets) 52 else: 53 raise Exception("Problem getting connections for %s" % pre) 44 54 45 55 class AllToAllConnector(common.AllToAllConnector): … … 60 70 projection._targets += target_list 61 71 projection._sources += [pre]*N 62 #projection._target_ports += get_target_ports(pre, target_list, projection._plasticity_model) 63 nest.DivergentConnectWD([pre], target_list, weights, delays) 72 nest.DivergentConnectWD([pre], target_list, weights, delays) 73 if CHECK_CONNECTIONS: 74 check_connections(projection, pre, target_list) 64 75 return len(projection._targets) 65 76 … … 71 82 projection._targets = projection.post.cell.flatten() 72 83 N = len(projection._sources) 73 #projection._target_ports = [get_target_ports(pre, [None], projection._plasticity_model)[0] for pre in projection._sources]74 84 weights = self.getWeights(N) 75 85 weights = _convertWeight(weights, projection.synapse_type).tolist() … … 78 88 return projection.pre.size 79 89 else: 80 raise Exception("OneToOneConnector does not support presynaptic and postsynaptic Populations of different sizes.")90 raise common.InvalidDimensionsError("OneToOneConnector does not support presynaptic and postsynaptic Populations of different sizes.") 81 91 82 92 class FixedProbabilityConnector(common.FixedProbabilityConnector): … … 107 117 projection._targets += target_list 108 118 projection._sources += [pre]*N 109 #projection._target_ports += get_target_ports(pre, target_list, projection._plasticity_model) 110 nest.DivergentConnectWD([pre], target_list, weights, delays) 119 nest.DivergentConnectWD([pre], target_list, weights, delays) 120 if CHECK_CONNECTIONS: 121 check_connections(projection, pre, target_list) 111 122 return len(projection._sources) 112 123 … … 166 177 projection._targets += target_list 167 178 projection._sources += [pre]*N 168 #projection._target_ports += get_target_ports(pre, target_list, projection._plasticity_model) 169 nest.DivergentConnectWD([pre], target_list, weights, delays) 179 nest.DivergentConnectWD([pre], target_list, weights, delays) 180 if CHECK_CONNECTIONS: 181 check_connections(projection, pre, target_list) 170 182 return len(projection._sources) 171 183 … … 183 195 else: 184 196 n = self.n 185 target_list = rng.permutation(postsynaptic_neurons)[0:n] 186 # if self connections are not allowed, check whether pre and post are the same 187 if not self.allow_self_connections and pre in target_list: 188 target_list.remove(pre) 189 190 N = len(target_list) 191 weights = self.getWeights(N) 192 weights = _convertWeight(weights, projection.synapse_type).tolist() 193 delays = self.getDelays(N).tolist() 194 nest.DivergentConnectWD([pre], target_list.tolist(), weights, delays) 197 assert n > 0 198 199 if not self.allow_self_connections and projection.pre == projection.post: 200 # if self connections are not allowed, remove `post` from the target list before picking the n values 201 tmp_postsyn = postsynaptic_neurons.tolist() 202 tmp_postsyn.remove(pre) 203 target_list = rng.permutation(tmp_postsyn)[0:n].tolist() 204 else: 205 target_list = rng.permutation(postsynaptic_neurons)[0:n].tolist() 206 207 N = len(target_list) 208 weights = self.getWeights(N) 209 weights = _convertWeight(weights, projection.synapse_type).tolist() 210 delays = self.getDelays(N).tolist() 211 nest.DivergentConnectWD([pre], target_list, weights, delays) 195 212 projection._sources += [pre]*N 196 conn_dict = nest.GetConnections([pre], projection._plasticity_model)[0] 197 if isinstance(conn_dict, dict): 198 all_targets = conn_dict['targets'] 199 total_targets = len(all_targets) 200 projection._targets += all_targets[-N:] 201 #projection._target_ports += range(total_targets-N, total_targets) 202 return len(projection._sources) 203 204 def _n_connections(population, synapse_type): 205 """ 206 Get a list of the total number of connections made by each neuron in a 207 population. 208 """ 209 n = numpy.zeros((len(population),),'int') 210 conn_dict_list = nest.GetConnections([id for id in population], synapse_type) 211 for i, conn_dict in enumerate(conn_dict_list): 212 assert isinstance(conn_dict, dict) 213 n[i] = len(conn_dict['targets']) 214 return n 213 projection._targets += target_list 214 if CHECK_CONNECTIONS: 215 check_connections(projection, pre, target_list) 216 return len(projection._sources) 217 215 218 216 219 class FixedNumberPreConnector(common.FixedNumberPreConnector): … … 222 225 else: 223 226 rng = numpy.random 224 start_ports = _n_connections(projection.pre, projection._plasticity_model)225 227 for post in projection.post.cell.flat: 226 228 if hasattr(self, 'rand_distr'): … … 228 230 else: 229 231 n = self.n 230 source_list = rng.permutation(presynaptic_neurons)[0:n] 231 # if self connections are not allowed, check whether pre and post are the same 232 if not self.allow_self_connections and post in source_list: 233 source_list.remove(post) 234 232 233 if not self.allow_self_connections and projection.pre == projection.post: 234 # if self connections are not allowed, remove `post` from the source list before picking the n values 235 tmp_presyn = presynaptic_neurons.tolist() 236 tmp_presyn.remove(post) 237 source_list = rng.permutation(tmp_presyn)[0:n].tolist() 238 else: 239 source_list = rng.permutation(presynaptic_neurons)[0:n].tolist() 240 235 241 N = len(source_list) 236 242 weights = self.getWeights(N) … … 238 244 delays = self.getDelays(N).tolist() 239 245 240 nest.ConvergentConnectWD(source_list .tolist(), [post],246 nest.ConvergentConnectWD(source_list, [post], 241 247 weights, delays) 242 243 end_ports = _n_connections(projection.pre, projection._plasticity_model) 244 for pre, start_port, end_port in zip(presynaptic_neurons, start_ports, end_ports): 245 #projection._target_ports += range(start_port, end_port) 246 projection._sources += [pre]*(end_port-start_port) 247 conn_dict = nest.GetConnections([pre], projection._plasticity_model)[0] 248 if isinstance(conn_dict, dict): 249 projection._targets += conn_dict['targets'][start_port:end_port] 248 if CHECK_CONNECTIONS: 249 for src in source_list: 250 check_connections(projection, src, [post]) 251 projection._sources += source_list 252 projection._targets += [post]*N 253 250 254 return len(projection._sources) 251 255 … … 261 265 projection._sources.append(src) 262 266 projection._targets.append(tgt) 263 #projection._target_ports.append(get_target_ports(src, [tgt], projection._plasticity_model)[0])264 267 weights.append(_convertWeight(weight, projection.synapse_type)) 265 268 delays.append(delay) trunk/src/nest2/synapses.py
r415 r468 44 44 def __init__(self, U=0.5, tau_rec=100.0, tau_facil=0.0, u0=0.0, x0=1.0, y0=0.0): 45 45 common.TsodyksMarkramMechanism.__init__(self, U, tau_rec, tau_facil, u0, x0, y0) 46 parameters = locals() 47 parameters.pop('self') 46 parameters = dict(locals()) # need the dict to get a copy of locals. When running 47 parameters.pop('self') # through coverage.py, for some reason, the pop() doesn't have any effect 48 print parameters 48 49 self.parameters = self.translate(parameters) 49 50 … … 68 69 raise Exception("Non-zero minimum weight is not supported by NEST.") 69 70 common.AdditiveWeightDependence.__init__(self, w_min, w_max, A_plus, A_minus) 70 parameters = locals()71 parameters = dict(locals()) 71 72 parameters.pop('self') 72 73 self.parameters = self.translate(parameters) … … 93 94 raise Exception("Non-zero minimum weight is not supported by NEST.") 94 95 common.MultiplicativeWeightDependence.__init__(self, w_min, w_max, A_plus, A_minus) 95 parameters = locals()96 parameters = dict(locals()) 96 97 parameters.pop('self') 97 98 self.parameters = self.translate(parameters) … … 117 118 raise Exception("Non-zero minimum weight is not supported by NEST.") 118 119 common.AdditivePotentiationMultiplicativeDepression.__init__(self, w_min, w_max, A_plus, A_minus) 119 parameters = locals()120 parameters = dict(locals()) 120 121 parameters.pop('self') 121 122 self.parameters = self.translate(parameters) … … 143 144 if w_min != 0: 144 145 raise Exception("Non-zero minimum weight is not supported by NEST.") 145 common. AdditivePotentiationMultiplicativeDepression.__init__(self, w_min, w_max, A_plus, A_minus)146 parameters = locals()146 common.GutigWeightDependence.__init__(self, w_min, w_max, A_plus, A_minus) 147 parameters = dict(locals()) 147 148 parameters.pop('self') 148 149 self.parameters = self.translate(parameters) … … 159 160 def __init__(self, tau_plus=20.0, tau_minus=20.0): 160 161 common.SpikePairRule.__init__(self, tau_plus, tau_minus) 161 parameters = locals()162 parameters = dict(locals()) 162 163 parameters.pop('self') 163 164 self.parameters = self.translate(parameters) trunk/test/unittests/nest2tests.py
r433 r468 28 28 return (abs(a-b) < threshold).all() 29 29 30 def max_array_diff(a, b): 31 return max(abs(a-b)) 32 30 33 # ============================================================================== 31 34 class CreationTest(unittest.TestCase): … … 40 43 def testCreateStandardCell(self): 41 44 """create(): First cell created should have GID==1""" 42 ifcell = nest.create(nest.IF_curr_alpha) 43 assert ifcell == 1, 'Failed to create standard cell' 45 for cell_type in nest.list_standard_models(): 46 ifcell = nest.create(cell_type) 47 assert ifcell.cellclass == cell_type 44 48 45 49 def testCreateStandardCells(self): … … 428 432 nest.Population.nPop = 0 429 433 self.target33 = nest.Population((3,3),nest.IF_curr_alpha, label="target33") 430 self.target6 = nest.Population((6,),nest.IF_c urr_alpha, label="target6")434 self.target6 = nest.Population((6,),nest.IF_cond_exp, label="target6") 431 435 self.source5 = nest.Population((5,),nest.SpikeSourcePoisson, label="source5") 436 self.source6 = self.target6 432 437 self.source22 = nest.Population((2,2),nest.SpikeSourcePoisson, label="source22") 433 438 self.source33 = nest.Population((3,3),nest.SpikeSourcePoisson, label="source33") … … 435 440 def testAllToAll(self): 436 441 """For all connections created with "allToAll" it should be possible to obtain the weight using pynest.getWeight()""" 437 for srcP in [self.source5, self.source22]: 438 for tgtP in [self.target6, self.target33]: 439 prj1 = nest.Projection(srcP, tgtP, "allToAll", label="string") 440 prj2 = nest.Projection(srcP, tgtP, nest.AllToAllConnector(), label="connector") 441 for prj in prj1,prj2: 442 assert len(prj._sources) == len(prj._targets) 443 weights = [] 444 for src,tgt in prj.connections(): 445 ###print "--------", prj.label, srcP.label, tgtP.label, src, tgt 446 ###print nest.nest.GetConnections([src],'static_synapse') ### 447 weights.append(get_weight(src, tgt, prj.plasticity_name)) 448 assert weights == [0.0]*len(prj._sources) 442 for srcP in [self.source5, self.source22, self.source6]: 443 for tgtP in [self.target6, self.target33]: 444 for syn_type in 'excitatory', 'inhibitory': 445 for allow_self_connections in True, False: 446 prj1 = nest.Projection(srcP, tgtP, "allToAll", {'allow_self_connections':allow_self_connections}, target=syn_type, label="string") 447 prj2 = nest.Projection(srcP, tgtP, nest.AllToAllConnector(allow_self_connections=allow_self_connections), target=syn_type, label="connector") 448 for prj in prj1,prj2: 449 assert len(prj._sources) == len(prj._targets) 450 weights = [] 451 for src,tgt in prj.connections(): 452 ###print "--------", prj.label, srcP.label, tgtP.label, src, tgt 453 ###print nest.nest.GetConnections([src],'static_synapse') ### 454 weights.append(get_weight(src, tgt, prj.plasticity_name)) 455 assert weights == [0.0]*len(prj._sources) 449 456 450 457 def testOneToOne(self): … … 454 461 assert len(prj1) == self.source33.size 455 462 assert len(prj2) == self.source33.size 463 self.assertRaises(common.InvalidDimensionsError, nest.Projection, self.source33, self.target6, nest.OneToOneConnector()) 456 464 457 465 def testDistanceDependentProbability(self): … … 460 468 for rngclass in (nest.NumpyRNG, nest.NativeRNG): 461 469 for expr in ('exp(-d)', 'd < 0.5'): 462 prj1 = nest.Projection(self.source33, self.target33, 463 'distanceDependentProbability', 464 {'d_expression' : expr},rng=rngclass(12345)) 465 prj2 = nest.Projection(self.source33, self.target33, 466 nest.DistanceDependentProbabilityConnector(d_expression=expr), 467 rng=rngclass(12345)) 468 assert (0 < len(prj1) < len(self.source33)*len(self.target33)) \ 469 and (0 < len(prj2) < len(self.source33)*len(self.target33)) 470 if rngclass == nest.NumpyRNG: 471 assert prj1._sources == prj2._sources, "%s %s" % (rngclass, expr) 472 assert prj1._targets == prj2._targets, "%s %s" % (rngclass, expr) 470 for allow_self_connections in True, False: 471 prj1 = nest.Projection(self.source33, self.target33, 472 'distanceDependentProbability', 473 {'d_expression': expr, 'allow_self_connections':allow_self_connections}, 474 rng=rngclass(12345)) 475 prj2 = nest.Projection(self.source33, self.target33, 476 nest.DistanceDependentProbabilityConnector(d_expression=expr, allow_self_connections=allow_self_connections), 477 rng=rngclass(12345)) 478 assert (0 < len(prj1) < len(self.source33)*len(self.target33)) \ 479 and (0 < len(prj2) < len(self.source33)*len(self.target33)) 480 if rngclass == nest.NumpyRNG: 481 assert prj1._sources == prj2._sources, "%s %s" % (rngclass, expr) 482 assert prj1._targets == prj2._targets, "%s %s" % (rngclass, expr) 483 484 def testFixedNumberPost(self): 485 for srcP in [self.source5, self.source22, self.source6]: 486 for tgtP in [self.target6, self.target33]: 487 for asc in True, False: 488 prj1 = nest.Projection(srcP, tgtP, "fixedNumberPost", {'n': 4, 489 'allow_self_connections':asc}, label="string") 490 prj2 = nest.Projection(srcP, tgtP, nest.FixedNumberPostConnector(n=4, allow_self_connections=asc), label="connector") 491 for prj in prj1,prj2: 492 assert len(prj._sources) == len(prj._targets), "src=%s, tgt=%s" % (prj._sources, prj._targets) 493 assert prj.getWeights('list') == [0.0, 0.0, 0.0, 0.0]*len(srcP), str(prj.getWeights('list')) 494 495 def testFixedNumberPre(self): 496 for srcP in [self.source5, self.source22, self.source6]: 497 for tgtP in [self.target6, self.target33]: 498 for asc in True, False: 499 prj1 = nest.Projection(srcP, tgtP, "fixedNumberPre", {'n': 4, 500 'allow_self_connections':asc}, label="string") 501 prj1.setWeights(0.5) 502 prj2 = nest.Projection(srcP, tgtP, nest.FixedNumberPreConnector(n=4, weights=0.5, allow_self_connections=asc), label="connector") 503 for prj in prj1,prj2: 504 assert len(prj._sources) == len(prj._targets), "src=%s, tgt=%s" % (prj._sources, prj._targets) 505 assert prj.getWeights('list') == [0.5, 0.5, 0.5, 0.5]*len(tgtP), str(prj.getWeights('list')) 473 506 474 507 def testFixedProbability(self): … … 476 509 for srcP in [self.source5, self.source22]: 477 510 for tgtP in [self.target6, self.target33]: 478 prj1 = nest.Projection(srcP, tgtP, "fixedProbability", 0.5) 479 prj2 = nest.Projection(srcP, tgtP, nest.FixedProbabilityConnector(0.5)) 480 for prj in prj1, prj2: 481 assert len(prj._sources) == len(prj._targets) 482 weights = [] 483 for src, tgt in prj.connections(): 484 #print nest.nest.GetConnections([src],[tgt]) 485 weights.append(get_weight(src, tgt, prj.plasticity_name)) 486 assert weights == [0.]*len(prj._sources) 511 for rng in None, random.NumpyRNG(), random.NativeRNG(): 512 prj1 = nest.Projection(srcP, tgtP, "fixedProbability", 0.5, rng=rng) 513 prj2 = nest.Projection(srcP, tgtP, nest.FixedProbabilityConnector(0.5), rng=rng) 514 for prj in prj1, prj2: 515 assert len(prj._sources) == len(prj._targets) 516 weights = [] 517 for src, tgt in prj.connections(): 518 #print nest.nest.GetConnections([src],[tgt]) 519 weights.append(get_weight(src, tgt, prj.plasticity_name)) 520 assert weights == [0.]*len(prj._sources) 521 522 def testFromList(self): 523 conn_list_22_33 = [([0,0], [0,2], 0.25, 0.5), 524 ([0,0], [1,2], 0.5, 0.5), 525 ([1,0], [2,2], 0.125, 0.1)] 526 prj = nest.Projection(self.source22, self.target33, nest.FromListConnector(conn_list_22_33)) 527 assert prj.getWeights('list') == [0.25, 0.5, 0.125], str(prj.getWeights('list')) 528 assert prj.getDelays('list') == [0.5, 0.5, 0.1], str(prj.getDelays('list')) 487 529 488 530 def testSaveAndLoad(self): … … 504 546 assert (w1 == w2) and (d1 == d2) 505 547 548 def testInitialWeightsFromPositiveArray(self): 549 for srcP in [self.source5, self.source22]: 550 for tgtP in [self.target6, self.target33]: 551 for syn_type in 'excitatory', 'inhibitory': 552 weights_in = numpy.random.uniform(0.1,0.2,len(srcP)*len(tgtP)) 553 connector = nest.AllToAllConnector(weights=weights_in) 554 prj = nest.Projection(srcP, tgtP, connector, target=syn_type) 555 weights_out = numpy.array(prj.getWeights(format='list')) 556 if syn_type == 'inhibitory': 557 weights_out *= -1 558 assert arrays_almost_equal(weights_in, weights_out, 1e-9), '(%s) %s != %s' % (syn_type, weights_in, weights_out) 559 560 def testInitialInhibitoryWeightsFromNegativeArray(self): 561 for srcP in [self.source5, self.source22]: 562 for tgtP in [self.target6, self.target33]: 563 weights_in = numpy.random.uniform(-0.1,-0.2,len(srcP)*len(tgtP)) 564 connector = nest.AllToAllConnector(weights=weights_in) 565 prj = nest.Projection(srcP, tgtP, connector, target='inhibitory') 566 weights_out = numpy.array(prj.getWeights(format='list')) 567 assert arrays_almost_equal(weights_in, weights_out, 1e-9), '(%s) %s != %s' % (syn_type, weights_in, weights_out) 568 569 def testInitialExcitatoryWeightsFromNegativeArray(self): 570 for srcP in [self.source5, self.source22]: 571 for tgtP in [self.target6, self.target33]: 572 weights_in = numpy.random.uniform(-0.1,-0.2,len(srcP)*len(tgtP)) 573 connector = nest.AllToAllConnector(weights=weights_in) 574 self.assertRaises(nest.InvalidWeightError, nest.Projection, srcP, tgtP, connector, target='excitatory') 575 576 def testInitialWeightsFromMixedArray(self): 577 for srcP in [self.source5, self.source22]: 578 for tgtP in [self.target6, self.target33]: 579 weights_in = numpy.random.uniform(-0.1,0.1,len(srcP)*len(tgtP)) 580 connector = nest.AllToAllConnector(weights=weights_in) 581 self.assertRaises(nest.InvalidWeightError, nest.Projection, srcP, tgtP, connector) 582 583 def testInitialNegativeWeight(self): 584 for srcP in [self.source5, self.source22]: 585 for tgtP in [self.target6, self.target33]: 586 connector = nest.AllToAllConnector(weights=-1.23) 587 self.assertRaises(nest.InvalidWeightError, nest.Projection, srcP, tgtP, connector, target='excitatory') 588 prj = nest.Projection(srcP, tgtP, connector, target='inhibitory') 589 assert arrays_almost_equal(numpy.array(prj.getWeights(format='list')), -1.23*numpy.ones(len(srcP)*len(tgtP)), 1e-9) 590 506 591 class ProjectionSetTest(unittest.TestCase): 507 592 """Tests of the setWeights(), setDelays(), randomizeWeights() and … … 636 721 self.assert_((self.pop2[0,2].position == (0.5,1.5,0.0)).all()) 637 722 723 class SynapseDynamicsTest(unittest.TestCase): 724 725 def setUp(self): 726 nest.setup(max_delay=0.5) 727 nest.Population.nPop = 0 728 self.target33 = nest.Population((3,3),nest.IF_curr_alpha, label="target33") 729 self.target6 = nest.Population((6,),nest.IF_cond_exp, label="target6") 730 self.source5 = nest.Population((5,),nest.SpikeSourcePoisson, label="source5") 731 self.source6 = self.target6 732 self.source22 = nest.Population((2,2),nest.SpikeSourcePoisson, label="source22") 733 self.source33 = nest.Population((3,3),nest.SpikeSourcePoisson, label="source33") 734 self.connectors = [nest.AllToAllConnector(weights=0.1, delays=0.2), 735 nest.FixedProbabilityConnector(1.0, weights=0.1, delays=0.2)] 736 737 def testCreateProjectionWithTsodyksMarkramSynapses(self): 738 sd = nest.SynapseDynamics(fast=nest.TsodyksMarkramMechanism()) 739 for srcP in [self.source5, self.source22, self.source6]: 740 for tgtP in [self.target6, self.target33]: 741 for conn in self.connectors: 742 prj = nest.Projection(srcP, tgtP, 743 conn, 744 label="connector", 745 synapse_dynamics=sd) 746 assert prj.getWeights('list') == [0.1]*(len(srcP)*len(tgtP)), "%s != %s" % (prj.getWeights('list'),[0.1]*(len(srcP)*len(tgtP))) 747 assert prj.getDelays('list') == [0.2]*(len(srcP)*len(tgtP)) 748 assert prj._get_connection_values('list', 'U', gather=False) == [0.5]*(len(srcP)*len(tgtP)) 749 750 def testCreateSimpleSTDPConnection(self): 751 for wd in [nest.AdditiveWeightDependence(w_max=0.7654), 752 nest.GutigWeightDependence(w_max=0.7654)]: 753 stdp = nest.STDPMechanism(timing_dependence=nest.SpikePairRule(), 754 weight_dependence=wd) 755 sd = nest.SynapseDynamics(slow=stdp) 756 for srcP in [self.source5, self.source22, self.source6]: 757 for tgtP in [self.target6, self.target33]: 758 for conn in self.connectors: 759 prj = nest.Projection(srcP, tgtP, 760 conn, 761 label="connector", 762 synapse_dynamics=sd) 763 assert prj.getWeights('list') == [0.1]*(len(srcP)*len(tgtP)), "%s != %s" % (prj.getWeights('list'),[0.1]*(len(srcP)*len(tgtP))) 764 assert prj.getDelays('list') == [0.2]*(len(srcP)*len(tgtP)) 765 assert prj._get_connection_values('list', 'Kplus', gather=False) == [0.0]*(len(srcP)*len(tgtP)) 766 assert nest.nest.GetSynapseDefaults(prj.plasticity_name)['Wmax'] == 0.7654*1000.0 767 print nest.nest.GetConnections([prj.pre.index(0)], prj.plasticity_name) 768 print nest.nest.GetSynapseDefaults(prj.plasticity_name) 638 769 639 770 if __name__ == "__main__":
