I am working on this paper:

Oscillations and Filtering Networks Support Flexible Routing of Information

Akam et. al. 2010, Neuron

We show that switching one of several convergent pathways from an asynchronous to an oscillatory state allows accurate selective transmission of population-coded information, which can be extracted even when other convergent pathways fire asynchronously at comparable rates. We further show that the band-pass filtering required to perform this information extraction can be implemented in a simple spiking network model with a single feed-forward interneuron layer.

Maybe It’s also interesting for the others and I can get some guide to reproduce the results.

The Brian1 version of the codes available here and I am working to prepare Python3 and brian2 version of the code.

First consider connecting Poissong generator to an inhibitory neuron:

```
eqs = """
VT : volt
IX : amp # external fixed current
Im = IX +
gL * (EL - vm) +
gL * DeltaT * exp((vm - VT) / DeltaT) : amp
dvm/dt = (Im + I_syn_x) / C : volt
# for alpha shape conductance synapse :
ds_x/dt = -s_x / Tau_x : siemens
dg_syn_x/dt = (s_x - g_syn_x) / Tau_x : siemens
I_syn_x = g_syn_x * (Erev_x - vm): amp
"""
Poisson_to_I = b2.PoissonGroup(I_cell_params['Ncells'],
rates=param_I_syn["p_rate"])
cIX = b2.Synapses(Poisson_to_I,
I_cells,
dt=dt0,
method=integration_method,
on_pre="s_x += {}*nS".format(param_I_syn["w_x"]))
cIX.connect(i=0, j=0)
```

with no fixed input to neuron to see the effect of external poisson generator with rate 400 Hz.

Let’s consider input_network.py script.

There is two population of inhibitory and excitatory exponential LIF neurons which connect to themselves and each other. The is also an external poisson input to each population and also external currents.

The synapse are conductance base with alpha shape.

```
eqs = Equations(
"""
VT : volt
IX : amp
I_syn_e = g_syn_e * (Erev_e - vm): amp # input from E cells
I_syn_i = g_syn_i * (Erev_i - vm): amp # input from I cells
I_syn_x = g_syn_x * (Erev_x - vm): amp # input from external poisson generator
Im = IX +
gL * (EL - vm) +
gL * DeltaT * exp((vm - VT) / DeltaT) : amp
######### for inhibitory, excitatory and external inputs
ds_e/dt = -s_e / Tau_e : siemens
dg_syn_e/dt = (s_e - g_syn_e) / Tau_e : siemens
ds_i/dt = -s_i / Tau_i : siemens
dg_syn_i/dt = (s_i - g_syn_i) / Tau_i : siemens
ds_x/dt = -s_x / Tau_x : siemens
dg_syn_x/dt = (s_x - g_syn_x) / Tau_x : siemens
dvm/dt = (Im + I_syn_e + I_syn_i + I_syn_x) / C : volt
"""
)
E_cells = b2.NeuronGroup(E_cell_params['Ncells'],
model=eqs,
dt=dt0,
method=integration_method,
threshold="vm > 0.*mV",
refractory="vm > 0.*mV",
reset="vm={}*mV".format(common_params['Vreset']),
namespace={**common_params,
**param_E_syn})
```

with almost the save code for building inhibitory neurons and also changing the parameters.

I think the synapses are the most tricky part of the codes:

Brian1

```
cEE = Connection(E_cells, E_cells, 'ge')
Connection.connect_random(cEE, sparseness = EEp['sparseness'], weight = EEp['g'], fixed=True)
```

Brian2

```
cEE = b2.Synapses(E_cells, E_cells,
dt=dt0,
delay=common_params['delay'],
on_pre='s_e+= {}*nS'.format(param_E_syn['w_e']),
namespace={**common_params, **param_E_syn})
cEE.connect(p="{:g}".format(param_E_syn["p_e"]), condition='i!=j')
```

which I expect to see a beta pick in the frequency spectrum.

What do you think?

I put the code here in case you want to check.