Recipes

The recipe class documentation is below.

A recipe describes neuron models in a cell-oriented manner and supplies methods to provide cell information. Details on why Arbor uses recipes and general best practices can be found in Recipes.

class arbor.recipe

Describe a model by describing the cells and network, without any information about how the model is to be represented or executed.

All recipes derive from this abstract base class.

Recipes provide a cell-centric interface for describing a model. This means that model properties, such as connections, are queried using the global identifier (arbor.cell_member.gid) of a cell. In the description below, the term gid is used as shorthand for the cell with global identifier.

Required Member Functions

The following member functions (besides a constructor) must be implemented by every recipe:

num_cells()

The number of cells in the model.

cell_kind(gid)

The cell kind of the cell with global identifier arbor.cell_member.gid (return type: arbor.cell_kind).

cell_description(gid)

A high level decription of the cell with global identifier arbor.cell_member.gid, for example the morphology, synapses and ion channels required to build a multi-compartment neuron. The type used to describe a cell depends on the kind of the cell. The interface for querying the kind and description of a cell are seperate to allow the cell type to be provided without building a full cell description, which can be very expensive.

Optional Member Functions

connections_on(gid)

Returns a list of all the incoming connections to arbor.cell_member.gid. Each connection should have post-synaptic target connection.dest.gid that matches the argument arbor.cell_member.gid, and a valid synapse id connection.dest.index on arbor.cell_member.gid. See connection.

By default returns an empty list.

gap_junctions_on(gid)

Returns a list of all the gap junctions connected to arbor.cell_member.gid. Each gap junction gj should have one of the two gap junction sites gj.local.gid or gj.peer.gid matching the argument arbor.cell_member.gid, and the corresponding synapse id gj.local.index or gj.peer.index should be valid on arbor.cell_member.gid. See gap_junction_connection.

By default returns an empty list.

event_generators(gid)

A list of all the event_generator s that are attached to arbor.cell_member.gid.

By default returns an empty list.

num_sources(gid)

The number of spike sources on arbor.cell_member.gid.

By default returns 0.

num_targets(gid)

The number of post-synaptic sites on arbor.cell_member.gid, which corresponds to the number of synapses.

By default returns 0.

num_probes(gid)

The number of probes attached to the cell with arbor.cell_member.gid.

By default returns 0.

num_gap_junction_sites(gid)

Returns the number of gap junction sites on arbor.cell_member.gid.

By default returns 0.

get_probe(id)

Returns the probe(s) to allow monitoring.

By default throws a runtime error. If num_probes() returns a non-zero value, this must also be overridden.

class arbor.probe

Describes the cell probe’s information.

arbor.cable_probe(kind, id, location)

Returns the description of a probe at an arbor.location on a cable cell with id available for monitoring data of voltage or current kind.

An example of a probe on a cable cell for measuring voltage at the soma reads as follows:

import arbor

id    = arbor.cell_member(0, 0) # cell 0, probe 0
loc   = arbor.location(0, 0)    # at the soma
probe = arbor.cable_probe('voltage', id, loc)
class arbor.connection

Describes a connection between two cells: Defined by source and destination end points (that is pre-synaptic and post-synaptic respectively), a connection weight and a delay time.

connection(source, destination, weight, delay)

Construct a connection between the source and the dest with a weight and delay.

source

The source end point of the connection (type: arbor.cell_member).

dest

The destination end point of the connection (type: arbor.cell_member).

weight

The weight delivered to the target synapse. The weight is dimensionless, and its interpretation is specific to the type of the synapse target. For example, the expsyn synapse interprets it as a conductance with units μS (micro-Siemens).

delay

The delay time of the connection [ms]. Must be positive.

An example of a connection reads as follows:

import arbor

# construct a connection between cells (0,0) and (1,0) with weight 0.01 and delay of 10 ms.
src  = arbor.cell_member(0,0)
dest = arbor.cell_member(1,0)
w    = 0.01
d    = 10
con  = arbor.connection(src, dest, w, d)
class arbor.gap_junction_connection

Describes a gap junction between two gap junction sites. Gap junction sites are represented by arbor.cell_member.

local

The gap junction site: one half of the gap junction connection.

peer

The gap junction site: other half of the gap junction connection.

ggap

The gap junction conductance [μS].

Event Generator and Schedules

class arbor.event_generator
event_generator(target, weight, schedule)

Construct an event generator for a target synapse with weight of the events to deliver based on a schedule (i.e., arbor.regular_schedule, arbor.explicit_schedule, arbor.poisson_schedule).

target

The target synapse of type arbor.cell_member.

weight

The weight of events to deliver.

class arbor.regular_schedule

Describes a regular schedule with multiples of dt within the interval [tstart, tstop).

regular_schedule(tstart, dt, tstop)

Construct a regular schedule as list of times from tstart to tstop in dt time steps.

By default returns a schedule with tstart = tstop = None and dt = 0 ms.

tstart

The delivery time of the first event in the sequence [ms]. Must be non-negative or None.

dt

The interval between time points [ms]. Must be non-negative.

tstop

No events delivered after this time [ms]. Must be non-negative or None.

events(t0, t1)

Returns a view of monotonically increasing time values in the half-open interval [t0, t1).

class arbor.explicit_schedule

Describes an explicit schedule at a predetermined (sorted) sequence of times.

explicit_schedule(times)

Construct an explicit schedule.

By default returns a schedule with an empty list of times.

times

The list of non-negative times [ms].

events(t0, t1)

Returns a view of monotonically increasing time values in the half-open interval [t0, t1).

class arbor.poisson_schedule

Describes a schedule according to a Poisson process.

poisson_schedule(tstart, freq, seed)

Construct a Poisson schedule.

By default returns a schedule with events starting from tstart = 0 ms, with an expected frequency freq = 10 Hz and seed = 0.

tstart

The delivery time of the first event in the sequence [ms].

freq

The expected frequency [Hz].

seed

The seed for the random number generator.

events(t0, t1)

Returns a view of monotonically increasing time values in the half-open interval [t0, t1).

An example of an event generator reads as follows:

import arbor

# define a Poisson schedule with start time 1 ms, expected frequency of 5 Hz,
# and the target cell's gid as seed
target = arbor.cell_member(0,0)
seed   = target.gid
tstart = 1
freq   = 5
sched  = arbor.poisson_schedule(tstart, freq, seed)

# construct an event generator with this schedule on target cell and weight 0.1
w      = 0.1
gen    = arbor.event_generator(target, w, sched)

Cells

class arbor.cable_cell

See Python Cable Cells.

class arbor.lif_cell

A benchmarking cell (leaky integrate-and-fire), used by Arbor developers to test communication performance, with neuronal parameters:

tau_m

Membrane potential decaying constant [ms].

V_th

Firing threshold [mV].

C_m

Membrane capacitance [pF].

E_L

Resting potential [mV].

V_m

Initial value of the Membrane potential [mV].

t_ref

Refractory period [ms].

V_reset

Reset potential [mV].

class arbor.spike_source_cell

A spike source cell, that generates a user-defined sequence of spikes that act as inputs for other cells in the network.

spike_source_cell(schedule)

Construct a spike source cell that generates spikes

Parameters:schedule – User-defined sequence of time points (choose from arbor.regular_schedule, arbor.explicit_schedule, or arbor.poisson_schedule).
class arbor.benchmark_cell

A benchmarking cell, used by Arbor developers to test communication performance.

benchmark_cell(schedule, realtime_ratio)

A benchmark cell generates spikes at a user-defined sequence of time points:

and the time taken to integrate a cell can be tuned by setting the parameter realtime_ratio.

Parameters:

Below is an example of a recipe construction of a ring network of multi-compartmental cells. Because the interface for specifying cable morphology cells is under construction, the temporary helpers in cell_parameters and make_cable_cell for building cells are used.

import sys
import arbor

class ring_recipe (arbor.recipe):

    def __init__(self, n=4):
        # The base C++ class constructor must be called first, to ensure that
        # all memory in the C++ class is initialized correctly.
        arbor.recipe.__init__(self)
        self.ncells = n
        self.params = arbor.cell_parameters()

    # The num_cells method that returns the total number of cells in the model
    # must be implemented.
    def num_cells(self):
        return self.ncells

    # The cell_description method returns a cell
    def cell_description(self, gid):
        return arbor.make_cable_cell(gid, self.params)

    def num_targets(self, gid):
        return 1

    def num_sources(self, gid):
        return 1

    # The kind method returns the type of cell with gid.
    # Note: this must agree with the type returned by cell_description.
    def cell_kind(self, gid):
        return arbor.cell_kind.cable

    # Make a ring network
    def connections_on(self, gid):
        src = (gid-1)%self.ncells
        w = 0.01
        d = 10
        return [arbor.connection(arbor.cell_member(src,0), arbor.cell_member(gid,0), w, d)]

    # Attach a generator to the first cell in the ring.
    def event_generators(self, gid):
        if gid==0:
            sched = arbor.explicit_schedule([1])
            return [arbor.event_generator(arbor.cell_member(0,0), 0.1, sched)]
        return []

    # Define one probe (for measuring voltage at the soma) on the cell.
    def num_probes(self, gid):
        return 1

    def get_probe(self, id):
        loc = arbor.location(0, 0) # at the soma
        return arbor.cable_probe('voltage', id, loc)