# Description of problem

I was wondering if there is a direct way to use dictionaries to save Neurongroups (like in the example code below). Instead of having to first use Vars() to convert the string to a variable (or locals, globals) and then storing it.

# Minimal code to reproduce problem

``````from brian2 import *
eqs = "dV/dt = 1/ms : 1"

N = NeuronGroup(1, eqs, dt=0.1*ms)

J= {"N": NeuronGroup(1, eqs, dt=0.1*ms)}
K = [NeuronGroup(1, eqs, dt=0.1*ms)]
M1 = StateMonitor(N, variables=["V"], record=range(1))
M2 = StateMonitor(J["N"], variables=["V"], record=range(1))
M3 = StateMonitor(K[0], variables=["V"], record=range(1))
run(20*ms)
print("neurongroup N values:", M1.V)
print("neurongroup J['N'] values:", M2.V)
print("neurongroup K[0] values:", M3.V)
``````

output:

``````neurongroup N values: [[ 0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. 1.1 1.2 1.3
1.4 1.5 1.6 1.7 1.8 1.9 2. 2.1 2.2 2.3 2.4 2.5 2.6 2.7
2.8 2.9 3. 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 4. 4.1
4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 5. 5.1 5.2 5.3 5.4 5.5
5.6 5.7 5.8 5.9 6. 6.1 6.2 6.3 6.4 6.5 6.6 6.7 6.8 6.9

7.1 7.2 7.3 7.4 7.5 7.6 7.7 7.8 7.9 8. 8.1 8.2 8.3 8.4 8.5 8.6 8.7 8.8 8.9 9. 9.1 9.2 9.3 9.4 9.5 9.6 9.7 9.8 9.9 10. 10.1 10.2 10.3 10.4 10.5 10.6 10.7 10.8 10.9 11. 11.1 11.2 11.3 11.4 11.5 11.6 11.7 11.8 11.9 12. 12.1 12.2 12.3 12.4 12.5 12.6 12.7 12.8 12.9 13. 13.1 13.2 13.3 13.4 13.5 13.6 13.7 13.8 13.9
14.1 14.2 14.3 14.4 14.5 14.6 14.7 14.8 14.9 15. 15.1 15.2 15.3
15.4 15.5 15.6 15.7 15.8 15.9 16. 16.1 16.2 16.3 16.4 16.5 16.6 16.7 16.8 16.9 17. 17.1 17.2 17.3 17.4 17.5 17.6 17.7 17.8 17.9 18. 18.1 18.2 18.3 18.4 18.5 18.6 18.7 18.8 18.9 19. 19.1 19.2 19.3 19.4 19.5 19.6 19.7 19.8 19.9]]
neurongroup J['N'] values: []
neurongroup K[0] values: []
``````

# What you have aready tried

The locals, globals, but I wanted to see if there was something in Brian2 built in that would allow you not to use it.

# Expected output (if relevant)

see Neurongroup 1 values

Hi @Victor5 (and thanks for moving your question here). When you call `run`, you are using Brian’s “magic” mode, where it tries to figure out on its own what is part of the network. It does so by looking at the variables that are defined at the same level, but does not inspect containers like dictionaries or list. In situations like this, you should instead explicitly create a `Network` object (see Running a simulation — Brian 2 2.5.1 documentation) and tell Brian what objects are part of your simulation. In your example code, you could do this by replacing `run(20*ms)` by:

``````net = Network(N, J.values(), K, M1, M2, M3)
net.run(20*ms)
``````

or (useful if only a few of your objects are “hidden” in containers):

``````net = Network(collect())  # add objects stored in variables
net.add(J.values(), K)  # add objects stored in containers
net.run(20*ms)
``````

Hope that makes things clearer!
Marcel

PS: To display code nicely, please use triple backticks around the code as shown below:

`````````
# here comes the Python code
from brian2 import *
# ...
```
``````