Classes
class	ABSConnection

class	AdExGroup
	Conductance based Adaptive Exponential neuron model - Brette and Gerstner (2005). More...

class	AIF2Group
	An adaptive integrate and fire group comparable to AIFGroup but with two independent adaptation timescales. More...

class	AIFGroup
	A simple extension of IFGroup with spike triggered adaptation. More...

class	AllToAllConnection
	Provides all to all connectivity. More...

class	AuditoryBeepGroup
	A special Poisson generator that mimicks thalamo-cortical input to auditory cortex layer 3/4. More...

class	AurynConnectionAllocationException

class	AurynDelayTooSmallException

class	AurynDelayVector
	AurynDelayVector is a AurynVectorFloat which keeps its own history in a ring buffer. More...

class	AurynGenericException

class	AurynMatrixBufferException

class	AurynMatrixComplexStateException

class	AurynMatrixDimensionalityException

class	AurynMatrixPushBackException

class	AurynMemoryAlignmentException

class	AurynMMFileException

class	AurynOpenFileException

class	AurynSpikeAttributeSizeException

class	AurynStateVectorException

class	AurynTimeOverFlowException

class	AurynVector
	Default Auryn vector template. More...

class	AurynVectorDimensionalityException

class	AurynVectorFloat
	Default AurynVectorFloat class for performance computation. More...

class	AurynVersion
	Container class providing Auryn version number. More...

class	BinarySpikeMonitor
	The standard Monitor object to record spikes from a SpikingGroup and write them to a binary file. More...

class	BinaryStateMonitor
	Records from an arbitray state vector of one unit from the source SpikingGroup to a binary file. More...

class	BurstRateMonitor
	Monitor class to record population firing rates. More...

class	Checker
	The abstract base class for all checkers. More...

class	ComplexMatrix
	Template for a sparse matrix with row major ordering and fast access of rows and capability to store float values per matrix entry. More...

class	Connection
	The abstract base class for all Connection objects in Auryn. More...

class	CorrelatedPoissonGroup
	A PoissonGroup with multiple subpopulations that co-modulate their firing rate according to an Ornstein Uhlenbeck process. More...

class	CubaIFGroup
	Current based neuron model with absolute refractoriness as used in Vogels and Abbott 2005. More...

class	CurrentInjector
	Stimulator class to add values in each timestep to arbitrary neuronal states. More...

class	DelayConnection
	DelayConnection implements a SparseConnection with adjustable delays. More...

class	DelayedSpikeMonitor
	SpikeMonitor that reads the delayed spikes as they are received by a postsynaptic neuron. More...

class	Device
	Abstract base class for all Device, Stimulator, etc objects. More...

class	DuplexConnection
	Duplex connection is the base class of most plastic connections. More...

class	EulerTrace
	Solves a set of identical linear differential equations with the Euler method. It is used to implement synaptic traces in most STDP models. More...

class	ExpCobaSynapse
	Implements an exponential conductance-based synapse model. More...

class	ExpCubaSynapse
	Implements an exponential current-based synapse model. More...

class	FanOutConnection
	Provides all to all connectivity. More...

class	FileInputGroup
	Reads spikes from a ras file and emits them as SpikingGroup in a simulation. More...

class	FileModulatedPoissonGroup
	A special Poisson generator that reads its instantaneous firing rate from a tiser file. Datapoints in the rate file are interpolated linearly. More...

class	IafPscDeltaGroup
	Conductance based neuron model with absolute refractoriness as used in Vogels and Abbott 2005. More...

class	IafPscExpGroup
	Simple LIF neuron model with absolute refractoriness and current based synapses. More...

class	IdentityConnection
	Provides a unity matrix like connectivity. More...

class	IFGroup
	Implements the standard integrate and file model used in Auryn. More...

class	InputChannelGroup
	A PoissonGroup with multiple subpopulations that co-modulate their firing rate according to an Ornstein Uhlenbeck process. More...

class	IzhikevichGroup
	This NeuronGroup implements the Izhikevich neuron model with conductance based AMPA and GABA synapses. More...

class	LinearComboSynapse
	Implements Auryn's default conductance based AMPA, Combo synapse without Combo voltage dependence. More...

class	LinearTrace
	Exponential synaptic trace which exactly solves in an event-based manner in non-follow scenarios. More...

class	Logger
	A generic logger class that logs to screen and a log-file. More...

class	LPTripletConnection
	Implements triplet STDP in which weight updates are low-pass filtered. More...

class	MinimalTripletConnection
	Implements minimal triplet STDP as described by Pfister and Gerstner 2006. More...

class	ModSynIFGroup
	Implements the standard integrate and file model used in Auryn. More...

class	Monitor
	Abstract base class for all Monitor objects. More...

class	MovingBumpGroup
	A special PoissonGroup that generates jumping Gaussian bumps in the firing rate profile. More...

class	NaudGroup
	This file implements NaudGroup, Richard Naud's reduced two compartment model with active dendrites. More...

struct	neuron_pair
	Struct that defines a pair of neurons in SparseConnection. More...

class	NeuronGroup
	Abstract base class for all neuron groups. More...

class	NormalStimulator
	Stimulator class to inject timeseries of currents to patterns (subpopulations) of neurons. More...

class	PairInteractionConnection
	STDP Connection class to simulate arbitrary nearest-neighbor STDP windows. More...

class	ParrotGroup
	A SpikingGroup that copies the output of another source SpikingGroup. More...

struct	pattern_member
	Struct used to define neuronal assembly patterns in SparseConnection. More...

class	PatternMonitor
	Monitor class to record population firing rates. More...

class	PatternStimulator
	Stimulator class to inject timeseries of currents to patterns (subpopulations) of neurons. More...

class	PoissonGroup
	A SpikingGroup that creates poissonian spikes with a given rate. More...

class	PoissonSpikeInjector
	A PoissonGroup which can directly add its output spike to another SpikingGroup by piggy backing onto it. More...

class	PoissonStimulator
	Stimulator class to inject timeseries of currents NeuronGroups. More...

class	PopulationRateMonitor
	Monitor class to record population firing rates. More...

class	ProfilePoissonGroup
	A SpikingGroup that creates poissonian spikes with a given rate and spatial profile. More...

class	RateChecker
	A Checker class that tracks population firing rate as a moving average and breaks a run if it goes out of bound. More...

class	RateModulatedConnection
	Rate Modulated Connection implements a SparseConnection in which the weights depend. More...

class	RateMonitor
	Monitor class to record neural firing rates. More...

class	RealTimeMonitor
	Monitor class to record the system time in every timestep. More...

class	SimpleMatrix
	Template for a sparse matrix with row major ordering and fast access of rows. More...

class	SparseConnection
	The base class to create sparse random connections. More...

class	SpikeDelay
	Delay object for spikes which is synchronized between nodes using the SyncBuffer formalism implemented in System. More...

struct	SpikeEvent_type
	Auryn spike event for binary monitors. More...

class	SpikeMonitor
	The standard Monitor object to record spikes from a SpikingGroup and write them to a text file. More...

class	SpikeTimingStimGroup

class	SpikingGroup
	Abstract base class of all objects producing spikes. More...

class	SRM0Group
	Implements SRM0 neuron model with escape noise. More...

class	StateMonitor
	Records from an arbitray state vector of one unit from the source SpikingGroup to a file. More...

struct	StateValue_type
	Auryn spike event for binary monitors. More...

class	STDPConnection
	Double STDP All-to-All Connection. More...

class	STDPwdConnection
	Doublet STDP All-to-All as implemented in NEST as stdp_synapse_hom. More...

class	StimulusGroup
	Provides a poisson stimulus at random intervals in one or more predefined subsets of the group that are read from a file. More...

class	STPConnection
	This class implements short term plasticity according to the Tsodyks-Markram synapse. More...

class	StructuredPoissonGroup
	A special Poisson generator that can hide a fixed number of spatio-temporal patterns in the spike data. More...

class	SymmetricSTDPConnection
	Implements a symmetric STDP window with an optional presynaptic offset as used for inhibitory plasticity in Vogels et al. 2011. More...

class	SynapseModel
	Implements base class for modular synapse models. More...

class	SyncBuffer
	Buffer object to capsulate native MPI_Allgather for SpikingGroups. More...

class	System
	Class that implements system wide variables and methods to manage and run simulations. More...

class	TIFGroup
	Conductance based LIF neuron model with absolute refractoriness as used in Vogels and Abbott 2005. More...

class	Trace
	Abstract base class of synaptic traces. More...

class	TripletConnection
	Implements triplet STDP with metaplasticity as described by Pfister and Gerstner 2006. More...

class	TripletDecayConnection
	Implements triplet STDP with an exponential weight decay. More...

class	TripletScalingConnection

class	VoltageClampMonitor
	Implements a voltage clamp for one neuron and records the clamp current. More...

class	VoltageMonitor
	Records the membrane potential from one unit from the source neuron group to a file. More...

class	WeightChecker
	A Checker class that tracks the meain weight of a Connection and breaks a run if it goes out of bound. More...

class	WeightMatrixMonitor
	Saves the weight matrix of a given connection in regular time intervals. More...

class	WeightMonitor
	Monitors the evolution of a single or a set of weights. More...

class	WeightPatternMonitor
	Records mean weights from a connection specified by one or two pattern files. Can be used to easily monitor the mean synaptic weight in assemblies or feed-forward connections of populations of neurons. More...

class	WeightStatsMonitor
	Records mean and standard deviation of a weight matrix in predefined intervals. More...

class	WeightSumMonitor
	Records sum of all weights in synaptic weight matrix in predefined intervals. More...

Typedefs
typedef unsigned int	NeuronID
	NeuronID is an unsigned integeger type used to index neurons in Auryn. More...

typedef NeuronID	AurynInt

typedef unsigned int	StateID
	StateID is an unsigned integeger type used to index synaptic states in Auryn. More...

typedef unsigned long	AurynLong
	An unsigned long type used to count synapses or similar. More...

typedef NeuronID	AurynTime
	Defines Auryns discrete time unit of the System clock. Change to AurynLong if 120h of simtime are not sufficient. More...

typedef std::string	string
	Standard library string type which is imported into Auryn namespace. More...

typedef float	AurynFloat
	Low precision floating point datatype. More...

typedef double	AurynDouble
	Higher precision floating point datatype. More...

typedef AurynFloat	AurynWeight
	Unit of synaptic weights. More...

typedef AurynFloat	AurynState
	Type for Auryn state variables (default single precision since it needs to be compatible with auryn_vector_float). More...

typedef std::vector< NeuronID >	SpikeContainer
	Spike container type. Used for storing spikes. More...

typedef std::vector< float >	AttributeContainer
	Attribute container type. Used for storing spike attributes that are needed for efficient STP implementations. More...

typedef std::vector< pattern_member >	type_pattern

typedef AurynVectorFloat	AurynStateVector
	Defines AurynStateVector type as synonymous to AurynVectorFloat. More...

typedef AurynVector< AurynWeight, AurynLong >	AurynSynStateVector
	Defines AurynSynStateVector for synaptic states. More...

typedef AurynStateVector	auryn_vector_float
	Legacy definition of AurynStateVector. More...

typedef AurynVector< unsigned short, NeuronID >	auryn_vector_ushort
	Legacy definition of AurynVector<unsigned short> More...

typedef SimpleMatrix< AurynWeight * >	BackwardMatrix

typedef ComplexMatrix< AurynWeight >	ForwardMatrix

Enumerations
enum	TransmitterType { GLUT, GABA, AMPA, NMDA, MEM, CURSYN }
	Specifies the different transmitter types that Auryn knows. More...

enum	StimulusGroupModeType { MANUAL, RANDOM, SEQUENTIAL, SEQUENTIAL_REV, STIMFILE }
	Specifies stimulus order used in StimulusGroup. More...

enum	LogMessageType { EVERYTHING, VERBOSE, INFO, NOTIFICATION, SETTINGS, PROGRESS, WARNING, ERROR, NONE }
	Enum type for significance level of a given message send to the Logger. More...

enum	NodeDistributionMode { AUTO, ROUNDROBIN, BLOCKLOCK, RANKLOCK }
	Specifies howto distribute different neurons across ranks when simulation is run in parallel. More...

enum	RecordingMode { SINGLE, DATARANGE, ELEMENTLIST, GROUPS }

enum	PatternMode { ALLTOALL, ASSEMBLIES_ONLY }

Functions
int	auryn_AlignOffset (const int N, const void *vp, const int inc, const int align)
	Determines memory alignment (adapted from ATLAS library) More...

NeuronID	calculate_vector_size (NeuronID i)
	Rounds vector size to multiple of four to allow using the SSE optimizations. More...

void	auryn_vector_float_mul (auryn_vector_float a, auryn_vector_float b)

void	auryn_vector_float_add_constant (auryn_vector_float *a, float b)
	Computes a := a + b. More...

void	auryn_vector_float_scale (const float a, auryn_vector_float *b)

void	auryn_vector_float_saxpy (const float a, auryn_vector_float x, auryn_vector_float y)

void	auryn_vector_float_add (auryn_vector_float a, auryn_vector_float b)
	Internal version of to add GSL vectors. More...

void	auryn_vector_float_sub (auryn_vector_float a, auryn_vector_float b)
	Computes a := a-b. More...

void	auryn_vector_float_sub (auryn_vector_float a, auryn_vector_float b, auryn_vector_float *r)
	Computes r := a-b. More...

void	auryn_vector_float_clip (auryn_vector_float *v, const float a, const float b)

void	auryn_vector_float_clip (auryn_vector_float *v, const float a)

auryn_vector_float *	auryn_vector_float_alloc (const NeuronID n)

void	auryn_vector_float_free (auryn_vector_float *v)

void	auryn_vector_float_set_all (auryn_vector_float *v, AurynFloat x)

void	auryn_vector_float_set_zero (auryn_vector_float *v)

AurynFloat	auryn_vector_float_get (auryn_vector_float *v, const NeuronID i)

AurynFloat *	auryn_vector_float_ptr (auryn_vector_float *v, const NeuronID i)

void	auryn_vector_float_set (auryn_vector_float *v, const NeuronID i, AurynFloat x)

void	auryn_vector_float_copy (auryn_vector_float src, auryn_vector_float dst)
	Copies vector src to dst assuming they have the same size. More...

auryn_vector_ushort *	auryn_vector_ushort_alloc (const NeuronID n)

void	auryn_vector_ushort_free (auryn_vector_ushort *v)

void	auryn_vector_ushort_set_all (auryn_vector_ushort *v, unsigned short x)

void	auryn_vector_ushort_set_zero (auryn_vector_ushort *v)

unsigned short	auryn_vector_ushort_get (auryn_vector_ushort *v, const NeuronID i)

unsigned short *	auryn_vector_ushort_ptr (auryn_vector_ushort *v, const NeuronID i)

void	auryn_vector_ushort_set (auryn_vector_ushort *v, const NeuronID i, unsigned short x)

void	auryn_vector_ushort_copy (auryn_vector_ushort src, auryn_vector_ushort dst)

void	auryn_env_init (int ac, char *av[], string dir=".", string logfile_prefix="", LogMessageType filelog_level=NOTIFICATION, LogMessageType consolelog_level=PROGRESS)
	Initalizes Auryn base environment (used internally) More...

void	auryn_kernel_init (string dir=".", string simulation_name="default")
	Initalizes the Auryn kernel (used internally) More...

void	auryn_init (int ac, char *av[], string dir=".", string simulation_name="default", string logfile_prefix="", LogMessageType filelog_level=NOTIFICATION, LogMessageType consolelog_level=PROGRESS)
	Initalizes MPI and the Auryn simulation environment. More...

void	auryn_kernel_free ()
	Frees the current auryn kernel (used interally) More...

void	auryn_env_free ()
	Frees logger and MPI. More...

void	auryn_free ()
	Cleanly shuts down Auryn simulation environment. More...

void	auryn_abort (int errcode=0)
	Terminates Auryn simulation abnormally. More...

Variables
double	auryn_timestep = 1e-4
	Simulation timestep in seconds. More...

mpi::communicator *	mpicommunicator
	Global pointer to instance of mpi::mpicommunicator which needs to be initialized in every simulation main program. More...

mpi::environment *	mpienv
	Global pointer to instance of mpi::environment which needs to be initialized in every simulation main program. More...

Logger *	logger
	Global pointer to instance of Logger which needs to be initialized in every simulation main program. More...

System *	sys
	Global pointer to instance of System which needs to be initialized in every simulation main program. More...

Typedef Documentation

◆ AttributeContainer

typedef std::vector<float> auryn::AttributeContainer

Attribute container type. Used for storing spike attributes that are needed for efficient STP implementations.

◆ auryn_vector_float

typedef AurynStateVector auryn::auryn_vector_float

Legacy definition of AurynStateVector.

Default legacy Auryn state vector type

◆ auryn_vector_ushort

typedef AurynVector<unsigned short, NeuronID> auryn::auryn_vector_ushort

Legacy definition of AurynVector<unsigned short>

Default legacy Auryn ushort vector type

◆ AurynDouble

typedef double auryn::AurynDouble

Higher precision floating point datatype.

◆ AurynFloat

typedef float auryn::AurynFloat

Low precision floating point datatype.

◆ AurynInt

typedef NeuronID auryn::AurynInt

◆ AurynLong

typedef unsigned long auryn::AurynLong

An unsigned long type used to count synapses or similar.

◆ AurynState

typedef AurynFloat auryn::AurynState

Type for Auryn state variables (default single precision since it needs to be compatible with auryn_vector_float).

◆ AurynStateVector

typedef AurynVectorFloat auryn::AurynStateVector

Defines AurynStateVector type as synonymous to AurynVectorFloat.

Auryn state vectors are used to implement vectorized code for SpikingGroup and NeuronGroup. An AurynStateVector in a SpikingGroup typically has the local rank size of that group and each neuronal state variable corresponds to a state vector that houses this state for all neurons on that rank. AurynStateVectors are defined as AurynVectorFloat. This typically needs to change when AurynState or AurynFloat types are changed.

◆ AurynSynStateVector

typedef AurynVector<AurynWeight, AurynLong> auryn::AurynSynStateVector

Defines AurynSynStateVector for synaptic states.

◆ AurynTime

typedef NeuronID auryn::AurynTime

Defines Auryns discrete time unit of the System clock. Change to AurynLong if 120h of simtime are not sufficient.

◆ AurynWeight

typedef AurynFloat auryn::AurynWeight

Unit of synaptic weights.

◆ BackwardMatrix

typedef SimpleMatrix< AurynWeight * > auryn::BackwardMatrix

Definition of BackwardMatrix - a sparsematrix of pointers to weight values.

◆ ForwardMatrix

typedef ComplexMatrix<AurynWeight> auryn::ForwardMatrix

◆ NeuronID

typedef unsigned int auryn::NeuronID

NeuronID is an unsigned integeger type used to index neurons in Auryn.

◆ SpikeContainer

typedef std::vector<NeuronID> auryn::SpikeContainer

Spike container type. Used for storing spikes.

◆ StateID

typedef unsigned int auryn::StateID

StateID is an unsigned integeger type used to index synaptic states in Auryn.

◆ string

typedef std::string auryn::string

Standard library string type which is imported into Auryn namespace.

◆ type_pattern

typedef std::vector<pattern_member> auryn::type_pattern

Enumeration Type Documentation

◆ LogMessageType

enum auryn::LogMessageType

Enum type for significance level of a given message send to the Logger.

Enumerator
EVERYTHING
VERBOSE
INFO
NOTIFICATION
SETTINGS
PROGRESS
WARNING
ERROR
NONE

41 { EVERYTHING, VERBOSE, INFO, NOTIFICATION, SETTINGS, PROGRESS, WARNING, ERROR, NONE };

auryn::NOTIFICATION

Definition: Logger.h:41

auryn::WARNING

Definition: Logger.h:41

auryn::NONE

Definition: Logger.h:41

auryn::EVERYTHING

Definition: Logger.h:41

auryn::ERROR

Definition: Logger.h:41

auryn::VERBOSE

Definition: Logger.h:41

auryn::INFO

Definition: Logger.h:41

auryn::PROGRESS

Definition: Logger.h:41

auryn::SETTINGS

Definition: Logger.h:41

◆ NodeDistributionMode

enum auryn::NodeDistributionMode

Specifies howto distribute different neurons across ranks when simulation is run in parallel.

Enumerator
AUTO	Tries to make a smart choice.
ROUNDROBIN	Default mode of distribution.
BLOCKLOCK	Tries to implement block lock.
RANKLOCK	Locks to single rank (this is a special case of BLOCKLOCK.

                           { 
         AUTO, 
         ROUNDROBIN, 
         BLOCKLOCK, 
         RANKLOCK 
 };

◆ PatternMode

enum auryn::PatternMode

Determines how pattern files are interpreted for loading. ALLTOALL will add connections between all possible pattern combinations, whereas ASSEMBLIES_ONLY restricts recording to inside each pattern.

Enumerator
ALLTOALL
ASSEMBLIES_ONLY

55 { ALLTOALL, ASSEMBLIES_ONLY};

auryn::ALLTOALL

Definition: WeightMonitor.h:55

auryn::ASSEMBLIES_ONLY

Definition: WeightMonitor.h:55

◆ RecordingMode

enum auryn::RecordingMode

RecordingMode determines the default recording behavior of the monitor. The modes SINGLE, DATARANGE and ELEMENTLIST (default) record weight values from single synapses while GROUPS records the statistics over groups of synapses

Enumerator
SINGLE	The entire Monitor will record from a single synapse specified at initialization.
DATARANGE	The Monitor will record from a range of synapses specified at initialization.
ELEMENTLIST	The Monitor records from selected synapses stored in a list. This is the default behavior.
GROUPS	This mode is added in versions >0.4.1 and allows to record summary statistics of synapses between neural groups/patterns.

                    { 
         SINGLE, 
         DATARANGE, 
         ELEMENTLIST, 
         GROUPS 
 };

◆ StimulusGroupModeType

enum auryn::StimulusGroupModeType

Specifies stimulus order used in StimulusGroup.

Enumerator
MANUAL
RANDOM
SEQUENTIAL
SEQUENTIAL_REV
STIMFILE

148 { MANUAL, RANDOM, SEQUENTIAL, SEQUENTIAL_REV, STIMFILE };

auryn::RANDOM

Definition: auryn_definitions.h:148

auryn::SEQUENTIAL_REV

Definition: auryn_definitions.h:148

auryn::SEQUENTIAL

Definition: auryn_definitions.h:148

auryn::STIMFILE

Definition: auryn_definitions.h:148

auryn::MANUAL

Definition: auryn_definitions.h:148

◆ TransmitterType

enum auryn::TransmitterType

Specifies the different transmitter types that Auryn knows.

Enumerator
GLUT	Standard Glutamatergic (excitatory) transmission.
GABA	Standard Gabaergic (inhibitory) transmission.
AMPA	Only targets AMPA channels.
NMDA	Only targets NMDA.
MEM	Current based synapse. Adds the transmitted quantity directly to membrane voltage.
CURSYN	Current based synapse with dynamics.

Function Documentation

◆ auryn_abort()

void auryn::auryn_abort ( int errcode = 0 )

Terminates Auryn simulation abnormally.

This issues a term signal to all MPI processes in case of error, but first closes the Auryn kernel and terminates the logger to ensure all information of the issuing rank are written to disk.

Parameters

errcode The errorcode to be returned by the MPI processes

                                       {
                 delete sys;
                 delete logger;
 #ifdef AURYN_CODE_USE_MPI
                 mpienv->abort(errcode);
 #endif // AURYN_CODE_USE_MPI
                 // In the MPI case the above line should have killed this process already ...
                 std::exit(errcode); 
         }

◆ auryn_AlignOffset()

int auryn::auryn_AlignOffset	(	const int	N,
		const void *	vp,
		const int	inc,
		const int	align
	)

Determines memory alignment (adapted from ATLAS library)

Parameters

N	max return value
*vp	Pointer to be aligned
inc	size of element, in bytes
align	required alignment, in bytes

 {
         const int p = align/inc;
         const size_t k=(size_t)vp, j=k/inc;
         int iret;
         if (k == (j)*inc && p*inc == align)
         {
                 iret = ((j+p-1) / p)*p - j;
                 if (iret <= N) return(iret);
         }
         return(N);
 }

◆ auryn_env_free()

void auryn::auryn_env_free ( )

Frees logger and MPI.

This function frees the MPI modules and logger. It is usually called by auryn_free()

See also: auryn_kernel_init

         {
                 delete logger;
 #ifdef AURYN_CODE_USE_MPI
                 delete mpicommunicator;
                 delete mpienv;
 #endif // AURYN_CODE_USE_MPI
         }

◆ auryn_env_init()

void auryn::auryn_env_init	(	int	ac,
		char *	av[],
		string	dir = `"."`,
		string	logfile_prefix = `""`,
		LogMessageType	filelog_level = `NOTIFICATION`,
		LogMessageType	consolelog_level = `PROGRESS`
	)

Initalizes Auryn base environment (used internally)

This function is called as port of auryn_init and is typically called internally. It instantiates the global Logger object and initializes the MPI environment.

         {
 #ifdef AURYN_CODE_USE_MPI
                 // init MPI environment
                 mpienv = new mpi::environment(ac, av); 
                 mpicommunicator = new mpi::communicator(); 
                 const unsigned int local_rank = mpicommunicator->rank();
 #else
                 const unsigned int local_rank = 0;
 #endif // AURYN_CODE_USE_MPI
 
                 // Init logger environment
                 try 
                 { 
                         string log_prefix_ = boost::filesystem::basename(av[0]);
                         log_prefix_.erase(std::remove(log_prefix_.begin(),log_prefix_.end(),' '),log_prefix_.end()); // remove spaces
                         std::transform(log_prefix_.begin(), log_prefix_.end(), log_prefix_.begin(), ::tolower); // convert to lower case
 
                         if ( !logfile_prefix.empty() ) log_prefix_ = logfile_prefix;
 
                         char strbuf_tmp [255]; 
                         sprintf(strbuf_tmp, "%s/%s.%d.log", dir.c_str(), log_prefix_.c_str(), local_rank); 
                         string auryn_simulation_logfile = strbuf_tmp; 
                         logger = new Logger(auryn_simulation_logfile, local_rank, consolelog_level, filelog_level); 
                 } 
                 catch ( AurynOpenFileException excpt ) 
                 { 
                         std::cerr << "Cannot proceed without log file. Exiting all ranks ..." << std::endl; 
                         auryn_abort(10);
                 } 
 
         }

Here is the call graph for this function:

◆ auryn_free()

void auryn::auryn_free ( )

Cleanly shuts down Auryn simulation environment.

Deletes global variables mpienv, mpicommunicator, sys and logger and ensures that all data is written to disk.

         {
                 auryn_kernel_free();
                 auryn_env_free();
         }

Here is the call graph for this function:

◆ auryn_init()

void auryn::auryn_init	(	int	ac,
		char *	av[],
		string	dir = `"."`,
		string	simulation_name = `"default"`,
		string	logfile_prefix = `""`,
		LogMessageType	filelog_level = `NOTIFICATION`,
		LogMessageType	consolelog_level = `PROGRESS`
	)

Initalizes MPI and the Auryn simulation environment.

This function has to be called only once and before any Auryn class is used. It is thus typically invoked in the main function of your simulation program. The function initalizes up the global objects mpienv, mpicommunicator, sys and logger. It takes the command line parameters from your main method (needed to initializes the MPI environment) as well as some additional arguments. You can for instance pass a default output directory which can be used by Device instances or any class which writes to disk. Moreover, you can pass a simulation_name to auryn_init which will appear in logging output. Finally, you can explicitly pass a logfile_prefix string which Auryn will decorate with the mpi rank number and a "log" extension. If this option is omitted, Auryn will derive a log file name from the name of your simulation binary. At the end of your simulation, make sure to call auryn_free() to cleanly terminate Auryn and avoid data loss.

Parameters

ac	Number of command line parameters argc passed to main
av	Command line parameters passed as argv to main
dir	The default output directory for files generated by your simulation
simulation_name	A name for your simulation which will appear in logfiles
logfile_prefix	A file prefix (without path) which Auryn will use to generate a log file name.

         {
                 // Init MPI and Logger
                 auryn_env_init(ac, av, dir, logfile_prefix, filelog_level, consolelog_level);
                 // Init Auryn Kernel
                 auryn_kernel_init(dir, simulation_name);
         }

Here is the call graph for this function:

◆ auryn_kernel_free()

void auryn::auryn_kernel_free ( )

Frees the current auryn kernel (used interally)

This function frees the current auryn kernel. It is usually called by auryn_free(), but in some cases it may make sense to use this independently.

See also: auryn_kernel_init

         {
                 delete sys;
         }

◆ auryn_kernel_init()

void auryn::auryn_kernel_init	(	string	dir = `"."`,
		string	simulation_name = `"default"`
	)

Initalizes the Auryn kernel (used internally)

This function is called as port of auryn_init and is typically called internally. However, it can be used if several simulations are to be run from a single simulation binary. Then manual calles of auryn_kernel_init and auryn_kernel_free can be used to reinitalize the kernel without closing down the MPI environment.

         {
 #ifdef AURYN_CODE_USE_MPI
                 auryn::sys = new System(mpicommunicator); 
 #else
                 auryn::sys = new System(); 
 #endif // AURYN_CODE_USE_MPI
                 sys->set_output_dir(dir);
                 sys->set_simulation_name(simulation_name);
         }

Here is the call graph for this function:

◆ auryn_vector_float_add()

void auryn::auryn_vector_float_add	(	auryn_vector_float *	a,
		auryn_vector_float *	b
	)

Internal version of to add GSL vectors.

Add vectors a and b and store the result in a.

 {
         a->add(b);
 }

Here is the call graph for this function:

◆ auryn_vector_float_add_constant()

void auryn::auryn_vector_float_add_constant	(	auryn_vector_float *	a,
		float	b
	)

Computes a := a + b.

Internal version of auryn_vector_float_add between a constant and a vector

 {
         a->add(b);
 }

Here is the call graph for this function:

◆ auryn_vector_float_alloc()

auryn_vector_float * auryn::auryn_vector_float_alloc ( const NeuronID n )

Allocates an auryn_vector_float

                                                                   {
         return new auryn_vector_float(n);
 }

◆ auryn_vector_float_clip() [1/2]

void auryn::auryn_vector_float_clip	(	auryn_vector_float *	v,
		const float	a,
		const float	b
	)

Internal version to clip all the elements of a vector between [a:b]

                                                                                      {
         v->clip(a, b);
 }

Here is the call graph for this function:

◆ auryn_vector_float_clip() [2/2]

void auryn::auryn_vector_float_clip	(	auryn_vector_float *	v,
		const float	a
	)

Internal version to clip all the elements of a vector between [a:0]

                                                                       {
         v->clip(a,0.0);
 }

Here is the call graph for this function:

◆ auryn_vector_float_copy()

void auryn::auryn_vector_float_copy	(	auryn_vector_float *	src,
		auryn_vector_float *	dst
	)

Copies vector src to dst assuming they have the same size.

Otherwise this will lead to undefined results. No checking of size is performed for performance reasons.

                                                                                     {
         dst->copy(src);
 }

Here is the call graph for this function:

◆ auryn_vector_float_free()

void auryn::auryn_vector_float_free ( auryn_vector_float * v )

Frees an auryn_vector_float

                                                         {
         delete v;
 }

◆ auryn_vector_float_get()

AurynFloat auryn::auryn_vector_float_get	(	auryn_vector_float *	v,
		const NeuronID	i
	)

Auryn vector getter

                                                                                {
         return v->data[i];
 }

◆ auryn_vector_float_mul()

void auryn::auryn_vector_float_mul	(	auryn_vector_float *	a,
		auryn_vector_float *	b
	)

Internal version of auryn_vector_float_mul of gsl operations

 {
         a->mul(b);
 }

Here is the call graph for this function:

◆ auryn_vector_float_ptr()

AurynFloat * auryn::auryn_vector_float_ptr	(	auryn_vector_float *	v,
		const NeuronID	i
	)

Auryn vector gets pointer to designed element.

                                                                                  {
         return v->data+i;
 }

◆ auryn_vector_float_saxpy()

void auryn::auryn_vector_float_saxpy	(	const float	a,
		auryn_vector_float *	x,
		auryn_vector_float *	y
	)

Computes y := a*x+y

Internal SAXPY version

 {
         y->saxpy(a,x);
 }

Here is the call graph for this function:

◆ auryn_vector_float_scale()

void auryn::auryn_vector_float_scale	(	const float	a,
		auryn_vector_float *	b
	)

Internal version to scale a vector with a constant b

 {
         b->scale(a);
 }

Here is the call graph for this function:

◆ auryn_vector_float_set()

void auryn::auryn_vector_float_set	(	auryn_vector_float *	v,
		const NeuronID	i,
		AurynFloat	x
	)

Auryn vector setter

                                                                                        {
         v->data[i] = x;
 }

◆ auryn_vector_float_set_all()

void auryn::auryn_vector_float_set_all	(	auryn_vector_float *	v,
		AurynFloat	x
	)

Sets all elements in an auryn_vector_float to value x

                                                                          {
         v->set_all(x);
 }

Here is the call graph for this function:

◆ auryn_vector_float_set_zero()

void auryn::auryn_vector_float_set_zero ( auryn_vector_float * v )

Initializes an auryn_vector_float with zeros

                                                             {
         v->set_zero();
 }

Here is the call graph for this function:

◆ auryn_vector_float_sub() [1/2]

void auryn::auryn_vector_float_sub	(	auryn_vector_float *	a,
		auryn_vector_float *	b
	)

Computes a := a-b.

Internal version of to subtract GSL vectors.

 {
         a->sub(b);
 }

Here is the call graph for this function:

◆ auryn_vector_float_sub() [2/2]

void auryn::auryn_vector_float_sub	(	auryn_vector_float *	a,
		auryn_vector_float *	b,
		auryn_vector_float *	r
	)

Computes r := a-b.

 {
         r->diff(a,b);
 }

Here is the call graph for this function:

◆ auryn_vector_ushort_alloc()

auryn_vector_ushort * auryn::auryn_vector_ushort_alloc ( const NeuronID n )

Allocates an auryn_vector_ushort

                                                                     {
         return new auryn_vector_ushort(n);
 }

◆ auryn_vector_ushort_copy()

void auryn::auryn_vector_ushort_copy	(	auryn_vector_ushort *	src,
		auryn_vector_ushort *	dst
	)

Copies vector src to dst assuming they have the same size. Otherwise this will lead to undefined results. No checking of size is performed for performance reasons.

                                                                                        {
         for ( NeuronID i = 0 ; i < dst->size ; ++i ) 
                 dst->data[i] = src->data[i];
 }

◆ auryn_vector_ushort_free()

void auryn::auryn_vector_ushort_free ( auryn_vector_ushort * v )

Frees an auryn_vector_ushort

                                                           {
         delete v;
 }

◆ auryn_vector_ushort_get()

unsigned short auryn::auryn_vector_ushort_get	(	auryn_vector_ushort *	v,
		const NeuronID	i
	)

Auryn vector getter

                                                                                      {
         return v->data[i];
 }

◆ auryn_vector_ushort_ptr()

unsigned short * auryn::auryn_vector_ushort_ptr	(	auryn_vector_ushort *	v,
		const NeuronID	i
	)

Auryn vector gets pointer to designed element.

                                                                                        {
         return v->data+i;
 }

◆ auryn_vector_ushort_set()

void auryn::auryn_vector_ushort_set	(	auryn_vector_ushort *	v,
		const NeuronID	i,
		unsigned short	x
	)

Auryn vector setter

                                                                                              {
         v->data[i] = x;
 }

◆ auryn_vector_ushort_set_all()

void auryn::auryn_vector_ushort_set_all	(	auryn_vector_ushort *	v,
		unsigned short	x
	)

Sets all elements in an auryn_vector_ushort to value x

                                                                                {
         v->set_all(x);
 }

Here is the call graph for this function:

◆ auryn_vector_ushort_set_zero()

void auryn::auryn_vector_ushort_set_zero ( auryn_vector_ushort * v )

Initializes an auryn_vector_ushort with zeros

                                                               {
         v->set_zero();
 }

Here is the call graph for this function:

◆ calculate_vector_size()

NeuronID auryn::calculate_vector_size ( NeuronID i )

Rounds vector size to multiple of four to allow using the SSE optimizations.

 {
         #if defined(CODE_USE_SIMD_INSTRUCTIONS_EXPLICITLY)
         if ( i%SIMD_NUM_OF_PARALLEL_FLOAT_OPERATIONS==0 ) 
                 return i;
         NeuronID div = i/SIMD_NUM_OF_PARALLEL_FLOAT_OPERATIONS; // rounds down
         NeuronID new_size = (div+1)*SIMD_NUM_OF_PARALLEL_FLOAT_OPERATIONS; // is multiple of SIMD...
         return new_size;
         #else
         return i;
         #endif
 }

Variable Documentation

◆ auryn_timestep

double auryn::auryn_timestep = 1e-4

Simulation timestep in seconds.

Todo:: For consistency the global variable for auryn_timestep should be moved to either auryn_definitions or into the System class

◆ logger

Logger * auryn::logger

Global pointer to instance of Logger which needs to be initialized in every simulation main program.

◆ mpicommunicator

mpi::communicator * auryn::mpicommunicator

Global pointer to instance of mpi::mpicommunicator which needs to be initialized in every simulation main program.

◆ mpienv

mpi::environment * auryn::mpienv

Global pointer to instance of mpi::environment which needs to be initialized in every simulation main program.

◆ sys

System * auryn::sys

Global pointer to instance of System which needs to be initialized in every simulation main program.

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ AttributeContainer

◆ auryn_vector_float

◆ auryn_vector_ushort

◆ AurynDouble

◆ AurynFloat

◆ AurynInt

◆ AurynLong

◆ AurynState

◆ AurynStateVector

◆ AurynSynStateVector

◆ AurynTime

◆ AurynWeight

◆ BackwardMatrix

◆ ForwardMatrix

◆ NeuronID

◆ SpikeContainer

◆ StateID

◆ string

◆ type_pattern

Enumeration Type Documentation

◆ LogMessageType

◆ NodeDistributionMode

◆ PatternMode

◆ RecordingMode

◆ StimulusGroupModeType

◆ TransmitterType

Function Documentation

◆ auryn_abort()

◆ auryn_AlignOffset()

◆ auryn_env_free()

◆ auryn_env_init()

◆ auryn_free()

◆ auryn_init()

◆ auryn_kernel_free()

◆ auryn_kernel_init()

◆ auryn_vector_float_add()

◆ auryn_vector_float_add_constant()

◆ auryn_vector_float_alloc()

◆ auryn_vector_float_clip() [1/2]

◆ auryn_vector_float_clip() [2/2]

◆ auryn_vector_float_copy()

◆ auryn_vector_float_free()

◆ auryn_vector_float_get()

◆ auryn_vector_float_mul()

◆ auryn_vector_float_ptr()

◆ auryn_vector_float_saxpy()

◆ auryn_vector_float_scale()

◆ auryn_vector_float_set()

◆ auryn_vector_float_set_all()

◆ auryn_vector_float_set_zero()

◆ auryn_vector_float_sub() [1/2]

◆ auryn_vector_float_sub() [2/2]

◆ auryn_vector_ushort_alloc()

◆ auryn_vector_ushort_copy()

◆ auryn_vector_ushort_free()

◆ auryn_vector_ushort_get()

◆ auryn_vector_ushort_ptr()

◆ auryn_vector_ushort_set()

◆ auryn_vector_ushort_set_all()

◆ auryn_vector_ushort_set_zero()

◆ calculate_vector_size()

Variable Documentation

◆ auryn_timestep

◆ logger

◆ mpicommunicator

◆ mpienv

◆ sys