# First Example

In this entry I am going to describe a very basic example with PyNN. Our aim is to build a system with a simple Integrate and Fire neuron under the influence of a direct current. The first thing that we need to do is to import the simulator that we are going to use with the instruction:

``` import pyNN.nest as simulator ```

Note that this could also be Neuron or Brian instead of Nest

Now, we need to define our model but before that we need to do some presettings. So we set first the number of neurons that our simulations is going to run and also the total time it will take.

``` N = 1 # Number of neurons t = 100.0 #Simulation time # Has to be called at the beginning of the simulation simulator.setup(timestep=0.1, min_delay=0.1, max_delay=10) ```

Now we can define a neuron model for our neuron. For this example we are going to chose a leaky integrate and fire with exponentially decaying pos-synpatic current.

``` model = simulator.IF_curr_exp() neurons = simulator.Population(N, model) ```

Note that once we have defined our model and our number of neurons we can define a population with this.

As a next step we define the current and inject it into the neurons

``` # DC source current = simulator.DCSource(amplitude=0.5, start=20.0, stop=80.0) #current = elect.DCSource(amplitude=0.5, start=20.0, stop=80.0) current.inject_into(neurons) #neurons.inject(current) ```

And finally we can indicate our simulator to run with the instruction

``` simulator.run(t) # Run the simulations for t ms ```

With this we have already simulated our neuron. However, as the things stand right now it we are unable to visualize the trajectory in time of the voltage in our system. In order to extract the membrane potential from our data we have to declare a recorder for the voltage.

``` neurons.record('v') # Record voltage simulator.run(t) # Run the simulations for t ms ```

Now in ourder to extract our simulations from the recorder we use:

``` data = neurons.get_data() ```

This returns a Neo bloc. A Neo blocked is a container of segments which in turn contain the data recorded in a given experiment. In order to extract our data from the block above we use the following code:

``` data = neurons.get_data() # Crates a Neo Block segment = data.segments # Takes the first vm = segment.analogsignalarrays ```

Finally in order to plot our data:

``` import matplotlib.pyplot as plt plt.plot(vm.times, vm) plt.xlabel('time') plt.ylabel('Vm') plt.show() ```

Which produces the next plot: