Auryn simulator - manual

adexgroup

Anonymous (anonymous@undisclosed.example.com) — 2015-04-20T15:58:25+00:00

The AdExGroup Available in version > 0.5 The AdExGroup is a NeuronGroup which implements the Adaptive Exponential Integrate and Fire neuron model as proposed by Brette and Gerstner (2005). The AdEx model has three main extensions over a traditional leaky integrate and fire neuron model as documented in the original paper:

aube

Anonymous (anonymous@undisclosed.example.com) — 2017-04-18T16:22:54+00:00

Auryn Binary Extract (aube) This command line tool extracts spike information from binary spike raster files and converts them in the more digestible ras format. Binary files provide a significant simulation speed advantage over the old ras file format, take less disk space and allow random access to temporal chunks of spike information.

aurynexceptions

Anonymous (anonymous@undisclosed.example.com) — 2015-06-01T17:46:42+00:00

Auryn Runtime Exceptions * AurynOpenFileException Failed opening file. * AurynMMFileException Problem reading MatrixMarket file. Not row major format? * AurynMatrixDimensionalityException Cannot add data outside of matrix. * AurynMatrixBufferException Buffer full. * AurynMatrixPushBackException Could not push_back in SimpleMatrix. Out of order execution? * AurynConnectionAllocationException Buffer has not been allocated.

binaryspikemonitor

Anonymous (anonymous@undisclosed.example.com) — 2022-08-19T09:32:01+00:00

Binary Spike Monitor This monitor object behaves like SpikeMonitor, except that it writes binary output files (spk files). Writing binary files is faster and the data in the file can be accessed and processed more efficiently. To decode spk files Auryn comes with suitable

binarystatemonitor

Anonymous (anonymous@undisclosed.example.com) — 2016-08-30T19:05:19+00:00

Binary State Monitor The binary state monitor records neuronal or synaptic state variables like StateMonitor. However, it writes a binary output file which is faster and can be processed more efficiently. To decode files written by a BinaryStateMonitor Auryn comes with suitable

building_blocks

Anonymous (anonymous@undisclosed.example.com) — 2018-02-07T08:48:50+00:00

Building Blocks Auryn was written to simulate networks of spiking neurons. To facilitate the process of building your own network simulation, Auryn handles neurons in populations and synaptic connections between them. For instance, if you were to create a balanced network model you do not have to create individual neurons, but you would create two populations: one for the excitatory neurons and for the inhibitory neurons. You would then connect them using

buildwithmakefile

Anonymous (anonymous@undisclosed.example.com) — 2022-08-19T09:31:38+00:00

Build older versions of Auryn using the shipped Makefile Until v0.7.0 Auryn comes shipped with a Makefile which will work on most Debian based distributions. However, you might have to modify the file to your needs to compile Auryn. If you are using a a Debian based distribution like Ubuntu or Mint (if you don't, have a look at the cmake or autools version below) and you have installed all the

checker

Anonymous (anonymous@undisclosed.example.com) — 2015-07-02T17:32:12+00:00

Checker Checker is one of Auryn's abstract base classes. Any descendant of it is a “checker”. That mean it is an object that performs minimalistic online run-monitoring of your simulation and stops the simulation if something goes wrong. Checkers are called last during the Auryn

coding_style_guide

Anonymous (anonymous@undisclosed.example.com) — 2018-05-18T15:08:37+00:00

Naming conventions Overall the Auryn code should follow Googles naming conventions because there seems to be to some degree a consensus on those. However, currently the code only enforces these conventions in part. Here are some naming conventions in Auryn which seem to have emerged over the years. Most of them are in line with the Google style. The most important deviation concerns file names which are so far all in CamelCase.

compileandrunaurynsimulations

Anonymous (anonymous@undisclosed.example.com) — 2017-03-13T19:43:01+00:00

Howto compile, link and run Auryn simulations You have installed the latest release of Auryn and compiled the library. Suppose you now want to start writing your own code. A good way to start is by modifying start. First copy the file to a place where you would like to develop your Auryn code. You could for instance create the directory

compileauryn

Anonymous (anonymous@undisclosed.example.com) — 2022-08-19T09:24:47+00:00

[Image illustration by Larry Ellmore for [[http://www.goodreads.com/book/show/878973.Pillars_of_Pentegarn|Pillars of pentegarn]], adapted by Alex Seeholzer, 2016] In most cases, compiling Auryn is hardly going to be that difficult, but there are a few things to keep in mind. Getting and compiling Auryn To compile and run Auryn download and unpack the source from GitHub. You can either download a release version or clone either the

complexmatrix

Anonymous (anonymous@undisclosed.example.com) — 2016-06-16T17:43:52+00:00

Complex Matrix class As of Auryn v0.8 the library comes with a complex matrix class which generalizes SimpleMatrix to synaptic connections which can have more than just a single scalar value per connection. ComplexMatrix is essentially a rank three tensor class optimized for sparse synaptic transmission.

connection

Anonymous (anonymous@undisclosed.example.com) — 2013-12-22T19:30:50+00:00

Connection Connection is one of the three abstract base classes of Auryn. It implements synaptic connections in Auryn. In its basic function Connection objects take spikes from a SpikingGroup (source) and deliver them to a destination of type NeuronGroup. It implements the transmit() function used to add spike induced quantities to certain neuronal

connections_and_plasticity

Anonymous (anonymous@undisclosed.example.com) — 2018-02-07T08:51:29+00:00

Connections and plasticity In many cases you will want to connect at least some of your populations with random sparse connectivity. To do so you simply instantiate an object of type SparseConnection which does exactly that. SparseConnection comes with a set of tools to directly add Hebbian assemblies or other simple structures into the synaptic weight matrix. However, if you want even more structure

default_specifier

Anonymous (anonymous@undisclosed.example.com) — 2014-11-05T16:02:26+00:00

StateVector default specifiers Each SpikingGroup in Auryn stores and manages a selection of StateVectors which can be accessed through string specifiers/handles and be read out using a StateMonitor. The following default specifiers objects are initialized per default in all classes based on

doxygen

Anonymous (anonymous@undisclosed.example.com) — 2017-04-24T19:16:52+00:00

Doxygen documentation The doxygen generated pages might be useful for exploring the code an when you want to work with Auryn other than just trying out some of the examples (you find an online version of it here). To build the doxygen documentation ensure you have doxygen installed. Under debian like distributions that means to install

duplexconnection

Anonymous (anonymous@undisclosed.example.com) — 2014-01-10T20:45:33+00:00

DuplexConnection constitutes an abstract base class for most plastic connections. It implements a BackwardMatrix and synchronizes it to the ForwardMatrix implemented by SparseConnection. The purpose of this is solely to allow efficient column major access to the elements of the ForwardMatrix to allow efficient backward propagation of a postsynaptic spike to the upstream synapses of the same neuron.

duty_cycle

Anonymous (anonymous@undisclosed.example.com) — 2017-01-24T21:39:55+00:00

Duty cycle Once a simulation is triggered by the run() directive in System the simulation evolves according to a fixed loop structure. Auryn's duty cycle can be coarsely divided into three main parts. * Evolve the state of the network are evolved by one time step. To that end System calls the

extensions

Anonymous (anonymous@undisclosed.example.com) — 2016-09-05T23:31:57+00:00

Default extensions I am using the following default file extensions in most of my simulations: * ras spike raster file (human readable) as produced by SpikeMonitor * spk Binary spike raster file written by BinarySpikeMonitor (decode with aube or Python tools) * wmat Weight matrix file (human readable) in Auryn

external_input_and_stimuli

Anonymous (anonymous@undisclosed.example.com) — 2018-02-07T08:52:38+00:00

External Input and Stimuli In most cases you will want to give some external input. Auryn has multiple classes which allow you to give spiking or current input to your neurons in a network. The most simple form of external input comes in the form of a homogeneous population of Poisson neurons which fire at constant rate

fileinputgroup

Anonymous (anonymous@undisclosed.example.com) — 2016-03-22T04:42:22+00:00

This FileInputGroup is a SpikingGroup that reads spikes from a ras file and emits them like any other SpikingGroup. The default constructor looks the following FileInputGroup(NeuronID n, const char * filename , bool loop, AurynFloat delay ); where filename is the ras file containing the spikes. The other parameters are optional. When setting

fill_level

Anonymous (anonymous@undisclosed.example.com) — 2016-02-17T20:50:56+00:00

Fill level The fill level of a SparseConnection is the ratio between number of possible connections that can be stored in the reserved memory of the connection class and the number of actual nonzero connections in this class. The number is between 0 and 1 and should be close to one to be as memory efficient as possible.

global_variables

Anonymous (anonymous@undisclosed.example.com) — 2016-09-02T20:35:05+00:00

Global variables Auryn classes use the following global variables (as of Auryn v0.8.0) which are initialized by the auryn_init() function. In auryn_global.h extern System * sys; extern Logger * logger; Are references to the Auryn kernel (sys) and the global logger.

ifgroup

Anonymous (anonymous@undisclosed.example.com) — 2017-04-24T19:17:43+00:00

IFGroup IFGroup implements a robust standard integrate-and-fire neuron model included with Auryn. It was used originally in Zenke, F., Hennequin, G., and Gerstner, W. (2013). Synaptic Plasticity in Neural Networks Needs Homeostasis with a Fast Rate Detector. PLoS Comput Biol 9, e1003330.

io_file_formats

Anonymous (anonymous@undisclosed.example.com) — 2018-07-20T09:42:09+00:00

IO File Formats To minimize complicated IO operations Auryn writes most of its monitor data directly into human readable text files that can be post processed using standard Linux command line software and visualized easily (e.g. with Gnuplot). *

known_issues

Anonymous (anonymous@undisclosed.example.com) — 2016-09-01T07:13:17+00:00

Known Issues * Spike-loss and random crashes experienced with with process numbers that were not a power of two. (OpenMPI 1.4.3) * Random communication freezes for large messages (i.e. caused by synchronization in the network -> many spikes in short time intervals). (OpenMPI 1.5.4)

logger

Anonymous (anonymous@undisclosed.example.com) — 2015-08-24T16:25:55+00:00

The Logger class is initialized first and generally passed to System as an argument. It is important that it is declared under the name logger because most Auryn classes expect it to exist globally under this name. A typical instantiation of Logger could look as follows

mem

Anonymous (anonymous@undisclosed.example.com) — 2014-01-13T12:23:43+00:00

Most Monitor objects are monitoring a continuous quantity in time. Such time series are generally written to file in a columnar format, where the first column describes the point in time of recording and the following column catch the value to be monitored. Some monitors such as

monitor

Anonymous (anonymous@undisclosed.example.com) — 2016-07-07T01:30:12+00:00

The Monitor Class Monitor is the abstract base class of recording devices in Auryn. Most popular examples are the SpikeMonitor, the PopulationRateMonitor, or the StateMonitor (these terms are taken from the Brian simulator terminology and they do essentially the same). Monitor objects generally take a file name as argument as where to record the data to and are called by

monitoring_and_readout

Anonymous (anonymous@undisclosed.example.com) — 2018-02-07T08:53:29+00:00

Monitoring and Readout Per default Auryn does not record any information. To see what is happening in your network, you will have to define Monitor objects. Each Monitor specializes on reading out one specific quantity from a network simulation. For instance, a

neurongroup

Anonymous (anonymous@undisclosed.example.com) — 2018-02-07T08:41:29+00:00

NeuronGroup NeuronGroup is the virtual base class of all neuron models within Auryn. It directly derives from SpikingGroup and implements important functionality which allows neurons to receive spikes. They are therefore the default target or destination type for Connection objects. Each non-virtual child of NeuronGroup has to implement the method

neuronid

Anonymous (anonymous@undisclosed.example.com) — 2013-11-01T16:16:14+00:00

NeuronID is an Auryn datatype used to identify neurons or units inside a SpikingGroup. It is currently defined in auryn_definitions.h as typedef unsigned int NeuronID;

neurons_and_populations

Anonymous (anonymous@undisclosed.example.com) — 2018-02-07T08:56:34+00:00

Neurons and populations Objects exchanging spikes such as neurons are simulated as groups in Auryn (in most cases you won't use Auryn to simulate one neuron in isolation, but many of them). Managing neurons in groups makes allows efficient simulation through vectorization, but it also makes it easier to declare and connect a simulation, because these groups can best be thought of as populations of functionally identical (or at least similar) units.

pact

Anonymous (anonymous@undisclosed.example.com) — 2018-02-28T18:02:59+00:00

pact is short for pattern activity. These files are the generic output files of a PatternMonitor. As other Auryn output formats they are organized as timeseries in columnar structure. The first column contains the time. The following columns contain the population firing rate of a given population as well as the running overlap of the network activity with a given pattern (see

pairinteractionconnection

Anonymous (anonymous@undisclosed.example.com) — 2022-08-19T09:32:22+00:00

PairInteractionConnection A STDP class which allows the straight forward implementation of any STDP window as long as only spike pairs (nearest neighbours) have to be considered (the class does not support all-to-all spike interactions). STDP windows are read at initialization from a text file.

parallel_execution

Anonymous (anonymous@undisclosed.example.com) — 2014-10-14T17:41:58+00:00

Running simulations in parallel Let's come back to our example of the Vogels-Abbott network. This network is run by invoking the following commands in the build/home directory. ./sim_coba_benchmark --dir /tmp --simtime 5 Suppose you would like to run the same code in parallel and assuming you have a running MPI implementation like OpenMPI, all you need to do is to use the following syntax:

parallelizing_short-term_plasticity

Anonymous (anonymous@undisclosed.example.com) — 2016-02-01T02:25:07+00:00

How to parallelize short-term plasticity STP To parallelize short-term plasticity efficiently Auryn allows the transmission of spike attributes. This way presynaptic properties of synaptic use can be computed at the presynaptic node and then transmitted with the spikes to the nodes storing the postsynaptic cells. Most scaling of STP thus remains O(N). These attributes are floats which can be

pat

Anonymous (anonymous@undisclosed.example.com) — 2018-02-28T18:00:56+00:00

Pattern files pat - or pattern files are used in Auryn to defined patterns as a subset of neurons of single NeuronGroup with associated activity (gamma) value between zero and one. They are a human readable exchange format and are understood by a range of Auryn objects.

patternmonitor

Anonymous (anonymous@undisclosed.example.com) — 2018-02-28T18:01:35+00:00

PatternMonitor A PatternMonitor reads the firing rates of subpopulations of neurons in a NeuronGroup as specified in a pattern file and writes multicolumn text output to a pact file. Example and Usage PatternMonitor * patmon = new PatternMonitor(neurons_e, outputfile, patternfile, 100);

poissongroup

Anonymous (anonymous@undisclosed.example.com) — 2018-02-07T08:58:48+00:00

PoissonGroup is a SpikingGroup that implements n independent homogenous Poisson neurons spiking at a given and generally fixed rate. It is the standard way of adding noise into any network implemented in Auryn. If you are looking for Poisson generated spikes with changing rates or a spatio-temporal correlation structure see also:

populationratemonitor

Anonymous (anonymous@undisclosed.example.com) — 2015-06-01T17:28:54+00:00

PopulationRateMonitor The PopulationRateMonitor records the firing rate of a neuronal population or a SpikingGroup in Auryn. A typical use case is the following sprintf(strbuf, "%s/%s.%d.prate", dir.c_str(), file_prefix, world.rank()); PopulationRateMonitor * pmon_e = new PopulationRateMonitor( neurons_e, strbuf, 1.0 );

prate

Anonymous (anonymous@undisclosed.example.com) — 2015-06-01T17:51:13+00:00

Population rate file Standard output file extension for files recorded with the PopulationRateMonitor. Simple columnar time series format in which the first column contains the time index and the second column contains the population rate in Hz. Example output Output from the example code

python_binary_toolkit

Anonymous (anonymous@undisclosed.example.com) — 2016-08-30T18:21:50+00:00

This page moved to python tools.

python_tools

Anonymous (anonymous@undisclosed.example.com) — 2016-08-30T18:50:31+00:00

Auryn Python tools Auryn v0.8.0 is the first version to come with a set of Python tools which allow decoding from binary files generated with BinarySpikeMonitor or BinaryStateMonitor. You can find the Python code in the tools/python directory. To use the Auryn Python tools, point your Python path to the

ras

Anonymous (anonymous@undisclosed.example.com) — 2016-08-08T20:22:59+00:00

ras file format definition The ras file format is a human readable ASCII file format to encode spiking activity from a population of numbered neurons. The format is a space separated list containing “time neuronnumber” pairs, of which time is given in seconds and the neuron id is given as integer:

ratechecker

Anonymous (anonymous@undisclosed.example.com) — 2015-07-02T17:40:20+00:00

RateChecker A rate checker monitors the firing rate of a single SpikingGroup and triggers if it goes either above or below a predefined threshold. In most cases your definition will look similar to this: RateChecker * chk = new RateChecker( neurons_e , 0.1 , 1000. , 100e-3);

required_libraries

Anonymous (anonymous@undisclosed.example.com) — 2016-09-01T07:12:53+00:00

Requirements To compile Auryn you need the boost libraries installed (if you do not want to install the complete library you will at least need the following components boost_program_options, boost_mpi, boost_serialization, boost_filesystem, boost_system), a recent version of an MPI compatible library such as MPICH2 or OpenMPI.

run

Anonymous (anonymous@undisclosed.example.com) — 2014-01-10T18:33:45+00:00

Method name in System that starts a simulation for a given period of time. See Doxygen documentation for more details.

simplematrix

Anonymous (anonymous@undisclosed.example.com) — 2013-10-10T08:00:34+00:00

The class SimpleMatrix is a minimalistic template to implement sparse matrices in Auryn for which rows can be accessed efficiently. The class is designed such that neighboring row elements lie together in memory and therefore CPUs can make efficient use of their caches when for instance propagating a spike from neuron

simulation_program

Anonymous (anonymous@undisclosed.example.com) — 2018-02-07T08:49:24+00:00

Simulation program Each Auryn simulation is a fully qualified C++ program. However, to qualify as an Auryn simulation it must initialize instances of two specific Auryn classes. These classes must be made accessible through the following three global pointers declared in

simulation

Anonymous (anonymous@undisclosed.example.com) — 2014-01-10T18:40:42+00:00

A simulation in Auryn is a compiles and executable C++ program that instantiates the System class and makes use of one or more other Auryn classes of (sub)-type SpikingGroup and Connection. To get a good feel we have compile a couple of examples of working simulations in the example section of this wiki.

simulator_init

Anonymous (anonymous@undisclosed.example.com) — 2014-03-21T08:21:38+00:00

Simulator Init Whenever using Auryn you will be required to place the following code in your main program, which initializes the global objects // BEGIN Auryn Init mpi::environment env(ac, av); mpi::communicator world; communicator = &world; logger = new Logger(logfile,world.rank()); sys = new System(&world); // END Auryn Init

simulator_structure

Anonymous (anonymous@undisclosed.example.com) — 2019-02-19T12:21:49+00:00

Simulator Structure Most objects in Auryn that have a direct network function can be subdivided into SpikingGroup, Connection and Monitor. These three base classes implement the important interfaces that are called consecutively during the Auryn duty cycle. Instances of their descendants are registered and managed by the

sparseconnection

Anonymous (anonymous@undisclosed.example.com) — 2013-11-01T15:57:18+00:00

The Sparse Connection Class SparseConnections are used to connect neuron groups with static synapses that are generally initialized randomly with sparse entries. The connection can just as well be loaded from a wmat file or with some tinkering can be influenced directly from within the model file. The underlying connection matrix is stored in the

spikedelay

Anonymous (anonymous@undisclosed.example.com) — 2013-12-22T19:23:18+00:00

SpikeDelay A container object that implements a delay line for spikes with minimal length of MINDELAY. Each time point in a spike delay can be accessed by calling the get_spikes() method, which returns a pointer to an instance of SpikeContainer (a normal std::vector object

spikemonitor

Anonymous (anonymous@undisclosed.example.com) — 2014-11-05T15:46:03+00:00

The SpikeMonitor SpikeMonitors record spikes from a designated NeuronGroup and dump them to a text file (a ras file). The format is standard two column which can be readily read with gnuplot. The first column codes the time and the second column carries the NeuronID. Output example

spikinggroup

Anonymous (anonymous@undisclosed.example.com) — 2013-12-22T19:19:08+00:00

SpikingGroup SpikingGroup is the abstract base class of all vectorized groups in Auryn. It is used for instance for PoissonGroup or for all descendants of the abstract class NeuronGroup; for instance IFGroup, AIFGroup or TIFGroup. SpikingGroup implements all necessary code for storing spikes in

spk

Anonymous (anonymous@undisclosed.example.com) — 2022-08-19T09:32:46+00:00

Binary spike raster files spk is the recommended extension for files generated by BinarySpikeMonitor. It's constructor syntax is the same as SpikeMonitor so that one can transparently switch between the two. The binary spk format can be decoded using provided Python code under tools/python/auryn_binary_tools.py

start

Anonymous (anonymous@undisclosed.example.com) — 2018-02-07T08:58:20+00:00

General * Compiling Auryn: See quick start or CompileAuryn for instructions. * Building blocks of every simulation * Simulator structure * Simulation program Neuron models and populations Neurons and populations * NeuronGroup * IFGroup * TIFGroup * IF2Group * AdExGroup * IzhikevichGroup * AIFGroup * AIF2Group External Input and Stimuli External Input and Stimuli * PoissonGroup * FileInputGroup * StimulusGroup Connections and plasticity

statemonitor

Anonymous (anonymous@undisclosed.example.com) — 2014-11-05T15:59:54+00:00

State monitors are used to monitor time continuous state variables such as the membrane voltage or GABA conductance, etc from NeuronGroups. Since these quantities are generally only locally available at individual nodes, each process writes it own file. Moreover, since a high frequency sampling of a state variable quickly generates massive amounts of data, a StateMonitor only records from a single neuron. To monitor multiple neurons also multiple monitors are required.

statevector

Anonymous (anonymous@undisclosed.example.com) — 2014-11-05T15:39:38+00:00

StateVector StateVectors are vector objects similar to GSL vector types which store floating point numbers. In Auryn they are used in a NeuronGroup to store the state of all neurons and Auryn implements functions to monitor them or to save and load them to/from disc. Typically each neuron model will at least have one such vector storing the membrane potential.

stim

Anonymous (anonymous@undisclosed.example.com) — 2014-04-24T11:49:55+00:00

stim file type Stimfiles are IO files in Auryn with extension *.stim or *.stimtimes that contain a timeseries of stimulus activation time points. In Auryn a stimulus is characterized by the cells that are stimulated, i.e. a pattern of cells which is generally stored in a

stimulusgroup

Anonymous (anonymous@undisclosed.example.com) — 2014-01-10T18:48:25+00:00

StimulusGroup is a complex version of the PoissonGroup that can emits Poisson spiketrains for certain subsets of the neurons in the group (patterns). This is done to mimic external input with a certain correlation structure. See the doxygen documentation for more info.

stpconnection

Anonymous (anonymous@undisclosed.example.com) — 2016-02-01T02:17:29+00:00

STPConnection This Connection class implements the Tsodyks Markram synapse model [1] for short-term plasticity. See sim_epsp_stp for an example. Usage STPConnection * con = new STPConnection(poisson,neuron,w,1.0,GLUT); is the standard usage to set up a connection object between the presynaptic

superspike

Anonymous (anonymous@undisclosed.example.com) — 2019-07-29T15:03:11+00:00

SuperSpike SuperSpike is one of our initial attempts to bring supervised learning to multi-layer and recurrent networks of deterministic spiking neurons. Here you'll find the paper And code You may also find our Tutorials on surrogate gradient learning in spiking neural networks useful

system

Anonymous (anonymous@undisclosed.example.com) — 2016-07-07T01:29:00+00:00

====== The System class and its instance sys ======s The System class keeps track of the different instances of objects that are created during for setting up a simulation. It requires the logger to be defined (see Logger) and expects an MPI communicator as argument. Most Auryn objects expect a global variable

tifgroup

Anonymous (anonymous@undisclosed.example.com) — 2017-04-13T16:21:04+00:00

The TIFGroup The TIFGroup is a NeuronGroup which implements a group of conductance based neurons with exponentially decaying AMPA and GABA conductances. The model has an absolute refractory period and implements the conductance based neuron model used in Vogels and Abbott (2005). It is used in at least one of our

tiser

Anonymous (anonymous@undisclosed.example.com) — 2018-07-20T09:42:49+00:00

Time series files Time series files (tiser) are human-readable text files in two column format (the first column encodes time and the second column encodes the value). These files are for instance read by FileModulatedPoissonGroup and are typically interpreted with linear interpolation between data points. That means they are interpreted the same way how you would plot them by connecting all the dots by a line.

transmittertype

Anonymous (anonymous@undisclosed.example.com) — 2015-06-01T17:45:28+00:00

Transmitter types Transmitter types in Auryn determine on which neuronal or synaptic variable a synaptic event has an effect. The following types are currently implemented in auryn_definitions.h (see also the code of Connection): * GLUT: target glutamatergic receptors at destination neuron

tripletconnection

Anonymous (anonymous@undisclosed.example.com) — 2014-04-15T12:13:53+00:00

This class implements a Connection object that simulates the minimal Triplet STDP connection by Pfister and Gerstner (2006). Please see sim_background for a working example.

warning_and_error_messages

Anonymous (anonymous@undisclosed.example.com) — 2016-08-03T18:44:21+00:00

Runtime warnings Wasteful fill level This warning indicates a low fill level of a connection matrix of a SparseConnection. This means that a SparseConnection has reserver a much larger buffer than needed. When you initialize a connection with random sparse connectivity, usually SparseConnection tries to make a good guess about how much memory is needed before filling the matrix. However, particularly for small values for size_pre x size_post this estimate can be off. For larger matrices this i…

weightmonitor

Anonymous (anonymous@undisclosed.example.com) — 2017-04-24T19:14:55+00:00

WeightMonitor This class monitors one or multiple synaptic weights over time and writes them to a human readable ASCII file. For the full class reference see its doxygen page. Usage example Consider the following examples. Assuming that you have previously define a plastic connection object

wmat

Anonymous (anonymous@undisclosed.example.com) — 2014-12-02T10:03:12+00:00

wmat files are used to store weight matrices in the MatrixMarket format, which can be exchanged easily with MATLAB and other software (). Since in many cases connection matrices are sparse, Auryn uses the coordinate real format, which needs to be kept in row major order, since it directly maps Auryn's internal sparse matrix format

xeonphi

Anonymous (anonymous@undisclosed.example.com) — 2014-12-15T12:54:29+00:00

Running Auryn simulations on the Intel® Xeon Phi™ Product Family (MIC architecture) The following section is experimental. To compile Auryn in native mode for the Intel Xeon Phi cards the following steps worked. Requirements: First, use the newest Auryn development version, which does not compile against GSL any more. This saves you some extra trouble in compiling GSL. Second, you need the Intel Composer suite. Third, you need the boost libraries (see

zynapseconnection

Anonymous (anonymous@undisclosed.example.com) — 2016-08-03T18:18:05+00:00

Zynapse This connection implements a complex synapse model as described in: Ziegler, L., Zenke, F., Kastner, D.B., and Gerstner, W. (2015). Synaptic Consolidation: From Synapses to Behavioral Modeling. J. Neurosci. 35, 1319–1334. Fulltext: The code of the model (Connection object) is available here