1Reference guide: NEST 2.x vs NEST 3.0 2===================================== 3 4* This guide shows changes to functions or their output between PyNEST 2.x and PyNEST 3.0 5 6* Functions not mentioned are unchanged 7 8* Terms that changed for NEST 3.0 are marked in :green:`green` 9 10* **Please note that NEST 3.0 no longer supports Python 2** 11 12.. contents:: On this page you'll find 13 :local: 14 :depth: 1 15 16.. seealso:: 17 18 To see code examples of the key changes, check out our :doc:`nest3_features/index`. 19 20.. _setverbosity: 21 22Suppress output on startup 23~~~~~~~~~~~~~~~~~~~~~~~~~~ 24 25+---------------------------------------+----------------------------------+ 26| NEST 2.x | NEST 3.0 | 27+=======================================+==================================+ 28| export DELAY_PYNEST_INIT = 1 | export :green:`PYNEST_QUIET = 1` | 29| | | 30| import nest | import nest | 31| | | 32| nest.ll_api.init(["nest", "--quiet"]) | | 33+---------------------------------------+----------------------------------+ 34 35Consistent use of allow_offgrid_times 36~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 37 38+---------------------------------------+---------------------------------------+ 39| NEST 2.x | NEST 3.0 | 40+=======================================+=======================================+ 41| nest.Create("spike_generator", | nest.Create("spike_generator", | 42| params={"allow_offgrid_spikes"=True}) | params={":green:`allow_offgrid_times`"| 43| | =True}) | 44| | | 45+---------------------------------------+---------------------------------------+ 46 47 48.. _node_ref: 49 50Functions related to creation and retrieval of nodes 51~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 52 53+---------------------------------+-------------------------------------+ 54| NEST 2.x | NEST 3.0 | 55+=================================+=====================================+ 56| nest.Create(model, n=1, params= | nest.Create(model, n=1, params= | 57| None) *returns* | None) *returns* | 58| list | :darkgreen:`nest.NodeCollection` | 59+---------------------------------+-------------------------------------+ 60| nest.GetLid(gid) *returns* | :green:`nest.GetLocalNodeConnection(| 61| list | nest.NodeConnection)` | 62| | *returns the MPI local nodes* | 63| | *in a new* nest.NodeCollection. | 64+---------------------------------+-------------------------------------+ 65 66.. _conn_ref: 67 68Functions related to connection 69~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 70 71+---------------------------------------------+--------------------------------------------------+ 72| NEST 2.x | NEST 3.0 | 73+=============================================+==================================================+ 74| nest.GetConnections(list=None, | nest.GetConnections( | 75| list=None, synapse_model=None, | :green:`nest.NodeCollection` =None, | 76| synapse_label=None) | :green:`nest.NodeCollection` =None, | 77| *returns* numpy.array | synapse_model=None, synapse_label=None) | 78| | *returns* :darkgreen:`nest.SynapseCollection` | 79+---------------------------------------------+--------------------------------------------------+ 80| nest.Connect(list, list, conn_spec | nest.Connect(:green:`nest.NodeCollection`, | 81| =None, syn_spec=None, model=None) | :green:`nest.NodeCollection`, conn_spec= | 82| | None, syn_spec=None, | 83| | :green:`return_SynapseCollection`\ = False) | 84| | | 85| | *In syn_spec the synapse model is given by* | 86| | *the* synapse_model *key, where before it* | 87| | *was* model | 88+---------------------------------------------+--------------------------------------------------+ 89| nest.DataConnect(pre, post) | *Use* nest.Connect(np.array, np.array, | 90| | conn_spec="one_to_one") | 91+---------------------------------------------+--------------------------------------------------+ 92| nest.CGConnect(list, list, cg, | *Use* nest.Connect(:green:`nest.NodeCollection`, | 93| parameter_map=params_map, | :green:`nest.NodeCollection`, | 94| model='static_synapse') | :green:`{"rule": "conngen", "cg": cg, | 95| | "params_map": params_map}`, | 96| | :green:`synapse_model` ='static_synapse') | 97+---------------------------------------------+--------------------------------------------------+ 98| nest.DisconnectOneToOne(int, int, | nest.Disconnect(:green:`nest.NodeCollection`, | 99| syn_spec) | :green:`nest.NodeCollection`, | 100| | syn_spec='static_synapse') | 101+---------------------------------------------+--------------------------------------------------+ 102| nest.Disconnect(list, list, conn_spec= | nest.Disconnect(:green:`nest.NodeCollection`, | 103| 'one_to_one', syn_spec='static_synapse') | :green:`nest.NodeCollection`, conn_spec= | 104| | 'one_to_one', syn_spec='static_synapse') | 105| | | 106+---------------------------------------------+--------------------------------------------------+ 107 108.. _subnet_ref: 109 110Functions related to subnets 111~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 112 113**The subnet model is removed in NEST 3.0!** 114 115+----------------------------------------+--------------------------------------------+ 116| NEST 2.x | NEST 3.0 | 117+========================================+============================================+ 118| nest.PrintNetwork(depth=1, subnet | :green:`nest.PrintNodes()` | 119| =None) | | 120+----------------------------------------+--------------------------------------------+ 121| nest.CurrentSubnet() | | 122+----------------------------------------+--------------------------------------------+ 123| nest.ChangeSubnet(subnet) | | 124+----------------------------------------+--------------------------------------------+ 125| nest.GetLeaves(subnet, properties | :green:`nest.NodeCollection` will contain | 126| =None, local_only=False) | all nodes | 127+----------------------------------------+--------------------------------------------+ 128| nest.GetNodes(subnets, properties | GetNodes(properties={}, local_only=False) | 129| =None, local_only=False) | *returns* :darkgreen:`nest.NodeCollection` | 130+----------------------------------------+--------------------------------------------+ 131| nest.GetChildren(subnets, properties | :green:`nest.NodeCollection` will contain | 132| =None, local_only=False) | all nodes | 133+----------------------------------------+--------------------------------------------+ 134| nest.GetNetwork(gid, depth) | | 135+----------------------------------------+--------------------------------------------+ 136| nest.BeginSubnet(label=None, params | | 137| =None) | | 138+----------------------------------------+--------------------------------------------+ 139| nest.EndSubnet() | | 140+----------------------------------------+--------------------------------------------+ 141| nest.LayoutNetwork(model, dim, | *Use* | 142| label=None, params=None) | nest.Create(model, n=1, params=None, | 143| | positions=None) | 144+----------------------------------------+--------------------------------------------+ 145 146.. _info_ref: 147 148Functions related to setting and getting parameters 149~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 150 151+---------------------------------------+---------------------------------------------+ 152| NEST 2.x | NEST 3.0 | 153+=======================================+=============================================+ 154| nest.SetStatus(list/tuple, | nest.SetStatus(:green:`nest.NodeCollection`,| 155| params, val=None) | params, val=None) *Can* | 156| | *also use* :green:`nodes.set(params)`, | 157| | :green:`nodes.parameter = value`, | 158| | :green:`conns.set(params)` *or* | 159| | :green:`conns.parameter = value` | 160+---------------------------------------+---------------------------------------------+ 161| nest.GetStatus(list/tuple, | nest.GetStatus(:green:`nest.NodeCollection`,| 162| keys=None) | keys=None) *Can* | 163| | *also use* :green:`nodes.get(keys=None)`, | 164| | :green:`nodes.parameter`, | 165| | :green:`conns.get(keys=None)` *or* | 166| | :green:`conns.parameter` | 167+---------------------------------------+---------------------------------------------+ 168 169.. _topo_ref: 170 171 172Functions related to spatially distributed nodes 173~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 174 175Spatial structure, formerly provided by the Topology module, is now integrated into NEST and is no longer 176a separate module. 177 178+------------------------------------------------+----------------------------------------------------+ 179| NEST 2.x | NEST 3.0 | 180+================================================+====================================================+ 181| tp.CreateLayer(specs) *returns* | :green:`nest.Create`\ (model, params=None, | 182| tuple of int(s) | positions=nest.spatial.free/grid) | 183| | *returns* | 184| | :darkgreen:`nest.NodeCollection` NOTE: | 185| | *Composite layers no longer* | 186| | *possible.* | 187+------------------------------------------------+----------------------------------------------------+ 188| tp.ConnectLayers(list, list, | :green:`nest.Connect`\ (\ | 189| projections) | :green:`nest.NodeCollection`, | 190| | :green:`nest.NodeCollection`, conn_spec=None, | 191| | syn_spec=None, :green:`return_SynapseCollection` | 192| | =False) | 193+------------------------------------------------+----------------------------------------------------+ 194| | :green:`spatial_NodeCollection.spatial` | 195| | *returns* | 196| | *Dictionary with spatial properties* | 197+------------------------------------------------+----------------------------------------------------+ 198| tp.GetLayer(nodes) *returns* | :green:`nest.NodeCollection` will represent the | 199| tuple | spatially distributed nodes | 200+------------------------------------------------+----------------------------------------------------+ 201| tp.GetElement(layers, location) | :green:`nest.NodeCollection` will contain all nodes| 202| *returns* | | 203| tuple | | 204+------------------------------------------------+----------------------------------------------------+ 205| tp.GetPosition(tuple) *returns* | :green:`nest`.GetPosition(\ | 206| tuple of tuple(s) | :green:`nest.NodeCollection`) *returns* | 207| | tuple or | 208| | tuple of tuple(s) | 209+------------------------------------------------+----------------------------------------------------+ 210| tp.Displacement(from_arg, to_arg) | :green:`nest`.Displacement(from_arg, to_arg) | 211| from_arg: | *from_arg:* | 212| tuple/list of int(s) / tuple/list | :green:`nest.NodeCollection` *or* tuple/list | 213| of tuples/lists of floats] | with tuple(s)/list(s) of floats | 214| to_arg: | *to_arg:* | 215| tuple/list of int(s) *returns* | :green:`nest.NodeCollection` *returns* | 216| tuple | tuple | 217+------------------------------------------------+----------------------------------------------------+ 218| tp.Distance(from_arg, to_arg) | :green:`nest`.Distance(from_arg, to_arg) | 219| from_arg: | *from_arg:* | 220| [tuple/list of ints / tuple/list | :green:`nest.NodeCollection` *or* tuple/list | 221| with tuples/lists of floats] | with tuple(s)/list(s) of floats | 222| to:arg: | *to_arg:* | 223| tuple/list of ints *returns* | :green:`nest.NodeCollection` *returns* | 224| tuple | tuple | 225+------------------------------------------------+----------------------------------------------------+ 226| tp.FindNearestElement(tuple/list, | :green:`nest`.FindNearestElement(\ | 227| locations, find_all=True) | :green:`nest.NodeCollection`, locations, | 228| *returns* | find_all=True) *returns* | 229| tuple | :darkgreen:`nest.NodeCollection` | 230+------------------------------------------------+----------------------------------------------------+ 231| tp.DumpLayerNodes(tuple, outname) | :green:`nest`.DumpLayerNodes(\ | 232| | :green:`nest.NodeCollection`, outname) | 233+------------------------------------------------+----------------------------------------------------+ 234| tp.DumpLayerConnections(tuple, | :green:`nest`.DumpLayerConnections( | 235| synapse_model, outname) | :green:`nest.NodeCollection`, | 236| | :green:`nest.NodeCollection`, synapse_model, | 237| | outname) | 238+------------------------------------------------+----------------------------------------------------+ 239| tp.FindCenterElement(tuple) | :green:`nest`.FindCenterElement(\ | 240| *returns* | :green:`nest.NodeCollection`) *returns* | 241| tuple | :darkgreen:`nest.NodeCollection` | 242+------------------------------------------------+----------------------------------------------------+ 243| tp.GetTargetNodes(tuple, tuple, | :green:`nest`.GetTargetNodes(\ | 244| tgt_model=None, syn_model=None) | :green:`nest.NodeCollection`, | 245| *returns* | :green:`nest.NodeCollection`, syn_model=None) | 246| tuple of list(s) of int(s) | *returns* tuple of :darkgreen:`nest.NodeConnection`| 247+------------------------------------------------+----------------------------------------------------+ 248| tp.GetTargetPositions(tuple, tuple, | :green:`nest`.GetTargetPositions(\ | 249| tgt_model=None, syn_model=None) | :green:`nest.NodeCollection`, | 250| *returns* | :green:`nest.NodeCollection`, | 251| tuple of tuple(s) of tuple(s) | :green:`synapse_model`\ =None) *returns* list of | 252| of floats | list(s) of tuple(s) of floats | 253+------------------------------------------------+----------------------------------------------------+ 254| tp.SelectNodesByMask(tuple, anchor, | :green:`nest`.SelectNodesByMaks(\ | 255| mask_obj) *returns* | :green:`nest.NodeCollection`, anchor, mask_obj) | 256| list | *returns* | 257| | :darkgreen:`nest.NodeConnection` | 258+------------------------------------------------+----------------------------------------------------+ 259| tp.PlotLayer(tuple, fig=None, | :green:`nest`.PlotLayer(\ | 260| nodecolor='b', nodesize=20) | :green:`nest.NodeCollection`, fig=None, | 261| *returns* | nodecolor ='b', nodesize=20) *returns* | 262| matplotlib.figure.Figure | matplotlib.figure.Figure | 263| object | object | 264+------------------------------------------------+----------------------------------------------------+ 265| tp.PlotTargets(int, tuple, tgt_model= | :green:`nest`.PlotTargets(\ | 266| =None, syn_type=None, fig=None, | :green:`nest.NodeCollection`, | 267| mask=None, kernel=None, src_color= | :green:`nest.NodeCollection`, syn_type= | 268| 'red', src_size=50, tgt_color= | None, fig=None, mask=None, kernel= | 269| 'blue', tgt_size=20, mask_color | None, src_color='red', src_size= | 270| ='red', kernel_color='red') | 50, tgt_color='blue', tgt_size= | 271| *returns* | '20, mask_color='red', kernel_color='red') | 272| matplotlib.figure.Figure | *returns* matplotlib.figure.Figure | 273| object | object | 274+------------------------------------------------+----------------------------------------------------+ 275| tp.PlotKernel(ax, int, mask, | :green:`nest.PlotProbabilityParameter` ( | 276| kern=None, mask_color='red', | :green:`nest.NodeCollection`, | 277| kernel_color='red') | :green:`parameter=None`, mask=None, | 278| | :green:`edges=[-0.5, 0.5, -0.5, 0.5]`, | 279| | :green:`shape=[100, 100]`, ax=None, | 280| | :green:`prob_cmap` ='Greens', mask_color='yellow') | 281+------------------------------------------------+----------------------------------------------------+ 282| 'mask': {'volume': | 'mask': {':green:`box`' | 283| {'lower_left': [-2., -1., -1.], | {'lower_left': [-2., -1., -1.], | 284| 'upper_right': [2., 1., 1.]}} | 'upper_right': [2., 1., 1.]}} | 285+------------------------------------------------+----------------------------------------------------+ 286 287 288.. _connrules: 289 290Spatially distributed connection rules 291^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 292 293====================================== ================================================= 294NEST 2.x NEST 3.0 295====================================== ================================================= 296convergent pairwise_bernoulli *and* use_on_source=True 297convergent *and* num_connections fixed_indegree 298divergent pairwise_bernoulli 299divergent *and* num_connections fixed_outdegree 300====================================== ================================================= 301 302.. _sim_ref: 303 304Functions related to simulation 305~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 306 307+-------------------------------------+--------------------------------------------------------+ 308| NEST 2.x | NEST 3.0 | 309+=====================================+========================================================+ 310| nest.ResetNetwork() | Use nest.ResetKernel() instead | 311+-------------------------------------+--------------------------------------------------------+ 312| nest.GetKernelStatus('time'), | nest.GetKernelStatus(':green:`biological_time`'), | 313| nest.SetKernelStatus({'time': 0.}) | nest.SetKernelStatus({':green:`biological_time`': 0.}) | 314+-------------------------------------+--------------------------------------------------------+ 315 316 .. note:: 317 318 The structural_plasticity_update_interval now reports time in ms instead of number of simulation steps. 319 320Functions related to models 321~~~~~~~~~~~~~~~~~~~~~~~~~~~ 322 323No Change 324 325 326Functions related to random number generators 327~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 328 329In NEST 2.x, you would have to set a global seed and individual seeds for each virtual process manually. 330In NEST 3.0, you set only a single `rng_seed`, which is used as a base for all other seeds. 331 332+-------------------------------------------------+----------------------------------------------------------------+ 333| NEST 2.x | NEST 3.0 | 334+=================================================+================================================================+ 335| nest.SetKernelStatus({’grng_seed’ : msd+N_vp}) | nest.SetKernelStatus({'rng_seed': msd}) | 336+-------------------------------------------------+ | 337| nest.SetKernelStatus({’rng_seeds’ : range( | | 338| msd+N_vp+1, msd+2*N_vp+1)}) | | 339| | | 340+-------------------------------------------------+----------------------------------------------------------------+ 341| nest.ll_api.sli_func('rngdict keys') | nest.GetKernelStatus('rng_types') | 342| | | 343+-------------------------------------------------+----------------------------------------------------------------+ 344| nest.ll_api.sli_run('0 << /grng | nest.SetKernelStatus({'rng_type': 'mt19937', 'rng_seed': 101}) | 345| rngdict/MT19937 :: 101 CreateRNG >> SetStatus') | | 346| | | 347+-------------------------------------------------+----------------------------------------------------------------+ 348 349 350Functions related to parallel computing 351~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 352 353No Change 354 355 356Model names 357~~~~~~~~~~~ 358 359* The synapse model *stdp_nn_pre-centered_synapse* has been renamed to 360 *stdp_nn_pre_centered_synapse* for consistency with the naming convention. 361 362 363Parameters 364~~~~~~~~~~ 365 366Parameters can now be used to set node and connection parameters. 367 368.. note:: 369 370 Check out the section on :ref:`param_ex` for example usage 371 372.. _random_param: 373 374:green:`random` 375^^^^^^^^^^^^^^^^ 376The random module contains random distributions that can be used to set node 377and connection parameters, as well as positions for spatially distributed nodes. 378 379+-------+------------------------------------------------------------+ 380| NEST | NEST 3.0 | 381| 2.x | | 382+=======+============================================================+ 383| | nest.random.exponential(beta=1.0) *returns* | 384| | nest.Parameter | 385+-------+------------------------------------------------------------+ 386| | nest.random.lognormal(mean=0.0, std=1.0) *returns* | 387| | nest.Parameter | 388+-------+------------------------------------------------------------+ 389| | nest.random.normal(mean=0.0, std=1.0) *returns* | 390| | nest.Parameter | 391+-------+------------------------------------------------------------+ 392| | nest.random.uniform(min=0.0, max=1.0) *returns* | 393| | nest.Parameter | 394+-------+------------------------------------------------------------+ 395 396.. _spatial_param: 397 398:green:`spatial` 399^^^^^^^^^^^^^^^^^ 400The spatial module contains parameters related to spatial positions for the 401nodes. 402 403+-------+----------------------------------------------------------------+ 404| NEST | NEST 3.0 | 405| 2.x | | 406+=======+================================================================+ 407| | nest.spatial.distance.x nest.spatial.distance.y | 408| | nest.spatial.distance.z | 409| | *returns* | 410| | nest.Parameter | 411+-------+----------------------------------------------------------------+ 412| | nest.spatial.distance *returns* nest.Parameter | 413+-------+----------------------------------------------------------------+ 414| | nest.spatial.free(pos, extent=None, edge_wrap=False, | 415| | num_dimensions=None) *returns* | 416| | nest.Parameter | 417+-------+----------------------------------------------------------------+ 418| | nest.spatial.grid(shape, center=None, extent=None, | 419| | edge_wrap=False) *returns* | 420| | nest.Parameter | 421+-------+----------------------------------------------------------------+ 422| | nest.spatial.pos.x nest.spatial.pos.y nest.spatial.pos.z | 423| | *returns* | 424| | nest.Parameter | 425+-------+----------------------------------------------------------------+ 426| | nest.spatial.source_pos.x nest.spatial.source_pos.y | 427| | nest.spatial.source_pos.z *returns* | 428| | nest.Parameter | 429+-------+----------------------------------------------------------------+ 430| | nest.spatial.target_pos.x nest.spatial.target_pos.y | 431| | nest.spatial.target_pos.z *returns* | 432| | nest.Parameter | 433+-------+----------------------------------------------------------------+ 434 435.. _math_param: 436 437:green:`math` 438^^^^^^^^^^^^^ 439The math module contains parameters for mathematical expressions. The mathematical 440expressions all take a nest.Parameter. 441 442+----------+--------------------------------------------+ 443| NEST 2.X | NEST 3.0 | 444+==========+============================================+ 445| | nest.math.exp(nest.Parameter) | 446| | *returns* nest.Parameter | 447+----------+--------------------------------------------+ 448| | nest.math.sin(nest.Parameter) | 449| | *returns* nest.Parameter | 450+----------+--------------------------------------------+ 451| | nest.math.cos(nest.Parameter) | 452| | *returns* nest.Parameter | 453+----------+--------------------------------------------+ 454| | nest.math.min(nest.Parameter, value) | 455| | *returns* nest.Parameter | 456+----------+--------------------------------------------+ 457| | nest.math.max(nest.Parameter, value) | 458| | *returns* nest.Parameter | 459+----------+--------------------------------------------+ 460| | nest.math.redraw(nest.Parameter, min, max) | 461| | *returns* nest.Parameter | 462+----------+--------------------------------------------+ 463 464.. _logic_param: 465 466:green:`logic` 467^^^^^^^^^^^^^^ 468The logic module contains logical expressions between nest.Parameter's. 469 470+-------+------------------------------------------------------------------+ 471| NEST | NEST 3.0 | 472| 2.x | | 473+=======+==================================================================+ 474| | nest.logic.conditional(condition, param_if_true, param_if_false) | 475| | *returns* | 476| | nest.Parameter | 477+-------+------------------------------------------------------------------+ 478 479.. _distr_param: 480 481:green:`spatial_distributions` 482^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 483The spatial_distributions module contains random distributions that take a spatial 484parameter as input and applies the distribution on the parameter. They are used 485for spatially distributed nodes. 486 487+-------+------------------------------------------------------------+ 488| NEST | NEST 3.0 | 489| 2.x | | 490+=======+============================================================+ 491| | nest.spatial_distributions.exponential(nest.Parameter, | 492| | beta=1.0) *returns* nest.Parameter | 493+-------+------------------------------------------------------------+ 494| | nest.spatial_distributions.gaussian(nest.Parameter, | 495| | mean=0.0, std=1.0) *returns* nest.Parameter | 496+-------+------------------------------------------------------------+ 497| | nest.spatial_distributions.gaussian2D(nest.Parameter, | 498| | nest.Parameter, mean_x=0.0, mean_y=0.0, std_x=1.0, | 499| | std_y=1.0, rho=0.0) *returns* nest.Parameter | 500+-------+------------------------------------------------------------+ 501| | nest.spatial_distributions.gamma(nest.Parameter, kappa=1.0 | 502| | theta=1.0) *returns* nest.Parameter | 503+-------+------------------------------------------------------------+ 504 505What's removed from NEST 3.0? 506============================= 507 508Subnets 509~~~~~~~ 510 511Subnets are gone. Instead NodeCollections should be used to group and organize neurons. 512 513 +---------------------------------------------+---------------------------------------+ 514 | NEST 2.x | NEST 3.0 | 515 +=============================================+=======================================+ 516 | | | 517 | :: | :: | 518 | | | 519 | net = nest.LayoutNetwork(model, dim) | nrns = nest.Create(model, dim) | 520 | nrns = nest.GetLeaves(net)[0] | | 521 | | | 522 +---------------------------------------------+---------------------------------------+ 523 524Printing the network as a tree of subnets is no longer possible. The 525``PrintNetwork()`` function has been replaced with ``PrintNodes()``, which 526prints ID ranges and model names of the nodes in the network. 527 528 +----------------------------------------------+---------------------------------------+ 529 | NEST 2.x | NEST 3.0 | 530 +==============================================+=======================================+ 531 | | | 532 | >>> nest.PrintNetwork(depth=2, subnet=None) | >>> nest.PrintNodes() | 533 | [0] root dim=[15] | 1 .. 10 iaf_psc_alpha | 534 | [1]...[10] iaf_psc_alpha | 11 .. 15 iaf_psc_exp | 535 | [11]...[15] iaf_psc_exp | | 536 | | | 537 | | | 538 +----------------------------------------------+---------------------------------------+ 539 540Models 541~~~~~~ 542 543With NEST 3.0, some models have been removed. They all have alternative models that can 544be used instead. 545 546 +----------------------------------------------+-----------------------------------------------+ 547 | Removed model | Replacement model | 548 +==============================================+===============================================+ 549 | iaf_neuron | iaf_psc_alpha | 550 +----------------------------------------------+-----------------------------------------------+ 551 | aeif_cond_alpha_RK5 | aeif_cond_alpha | 552 +----------------------------------------------+-----------------------------------------------+ 553 | iaf_psc_alpha_presc | iaf_psc_alpha_ps | 554 +----------------------------------------------+-----------------------------------------------+ 555 | iaf_psc_delta_canon | iaf_psc_delta_ps | 556 +----------------------------------------------+-----------------------------------------------+ 557 | subnet | no longer needed, use NodeCollection instead | 558 +----------------------------------------------+-----------------------------------------------+ 559 | spike_detector | spike_recorder | 560 +----------------------------------------------+-----------------------------------------------+ 561 562Furthermore, the model `iaf_tum_2000` has been renamed to `iaf_psc_exp_htum`. iaf_psc_exp_htum is 563the exact same model as iaf_tum_2000, it has just been renamed to match NEST's naming conventions. 564 565Functions 566~~~~~~~~~ 567 568Some functions have also been removed. The removed functions where either related to subnets, 569or they can be replaced by using other functions with indexing into a NodeCollection. 570 571The following functions have been removed: 572 573+----------------------+------------------------------+ 574| - BeginSubnet | | 575| - ChangeSubnet | | 576| - CurrentSubnet | | 577| - EndSubnet | | 578| - GetChildren | | 579| - GetLayer | See :ref:`subnet_ref` | 580| - GetLeaves | | 581| - GetLID | | 582| - GetNetwork | | 583| - LayoutNetwork | | 584+----------------------+------------------------------+ 585| - ResetNetwork | See :ref:`sim_ref` | 586+----------------------+------------------------------+ 587| - DataConnect | | 588| - DisconnectOneToOne | See :ref:`conn_ref` | 589| - CGConnect | | 590+----------------------+------------------------------+ 591| - GetElement | See :ref:`topo_ref` | 592+----------------------+------------------------------+ 593| - RestoreNodes | (have never existed on PyNEST| 594| | level, it was only a SLI | 595| | function) | 596+----------------------+------------------------------+ 597 598