nemo.h

Go to the documentation of this file.

#ifndef NEMO_H
#define NEMO_H

/* Copyright 2010 Imperial College London
 *
 * This file is part of NeMo.
 *
 * This software is licenced for non-commercial academic use under the GNU
 * General Public Licence (GPL). You should have received a copy of this
 * licence along with NeMo. If not, see <http://www.gnu.org/licenses/>.
 */

#ifdef __cplusplus
extern "C" {
#endif


#include <stddef.h> // for size_t
#include <nemo/config.h>
#include <nemo/types.h>



/* Dummy classes */
struct nemo_network_class;
struct nemo_simulation_class;
struct nemo_configuration_class;

typedef nemo_network_class* nemo_network_t;
typedef nemo_simulation_class* nemo_simulation_t;
typedef nemo_configuration_class* nemo_configuration_t;

typedef int nemo_status_t;


NEMO_DLL_PUBLIC
const char* nemo_version();


//-----------------------------------------------------------------------------
// HARDWARE CONFIGURATION
//-----------------------------------------------------------------------------


NEMO_DLL_PUBLIC
nemo_status_t
nemo_cuda_device_count(unsigned* count);


NEMO_DLL_PUBLIC
nemo_status_t
nemo_cuda_device_description(unsigned device, const char**);


//-----------------------------------------------------------------------------
// CONFIGURATION
//-----------------------------------------------------------------------------

/* \{ */ // begin configuration

NEMO_DLL_PUBLIC
nemo_configuration_t nemo_new_configuration();


NEMO_DLL_PUBLIC
void nemo_delete_configuration(nemo_configuration_t);


NEMO_DLL_PUBLIC
nemo_status_t nemo_log_stdout(nemo_configuration_t);

NEMO_DLL_PUBLIC
nemo_status_t
nemo_set_stdp_function(nemo_configuration_t,
        float prefire_fn[], size_t prefire_len,
        float postfire_fn[], size_t postfire_len,
        float min_excitatory_weight,
        float max_excitatory_weight,
        float min_inhibitory_weight,
        float max_inhibitory_weight);


NEMO_DLL_PUBLIC
nemo_status_t
nemo_set_cpu_backend(nemo_configuration_t, int thread_count);


NEMO_DLL_PUBLIC
nemo_status_t
nemo_cpu_thread_count(nemo_configuration_t conf, int* thread_count);


NEMO_DLL_PUBLIC
nemo_status_t
nemo_set_cuda_backend(nemo_configuration_t conf, int dev);


NEMO_DLL_PUBLIC
nemo_status_t
nemo_cuda_device(nemo_configuration_t conf, int* dev);


NEMO_DLL_PUBLIC
nemo_status_t
nemo_backend(nemo_configuration_t conf, backend_t* backend);


NEMO_DLL_PUBLIC
nemo_status_t
nemo_backend_description(nemo_configuration_t conf, const char** descr);


NEMO_DLL_PUBLIC
nemo_status_t
nemo_set_write_only_synapses(nemo_configuration_t conf);



/* \} */ // end configuration



//-----------------------------------------------------------------------------
// NETWORK CONSTRUCTION
//-----------------------------------------------------------------------------

NEMO_DLL_PUBLIC
nemo_network_t nemo_new_network();


NEMO_DLL_PUBLIC
void nemo_delete_network(nemo_network_t);



NEMO_DLL_PUBLIC
nemo_status_t
nemo_add_neuron_type(nemo_network_t,
        const char* name,
        unsigned* neuron_type);


NEMO_DLL_PUBLIC
nemo_status_t
nemo_add_neuron_iz(nemo_network_t,
        unsigned idx,
        float a, float b, float c, float d,
        float u, float v, float sigma);



NEMO_DLL_PUBLIC
nemo_status_t
nemo_add_neuron(nemo_network_t, unsigned type, unsigned idx,
        unsigned nargs, float args[]);



/* Add a single synapse to network
 *
 * \a id
 *      Unique id of this synapse (which can be used for run-time queries). Set
 *      to NULL if this is not required.
 */
NEMO_DLL_PUBLIC
nemo_status_t
nemo_add_synapse(nemo_network_t,
        unsigned source,
        unsigned target,
        unsigned delay,
        float weight,
        unsigned char is_plastic,
        synapse_id* id);



NEMO_DLL_PUBLIC
nemo_status_t
nemo_neuron_count(nemo_network_t net, unsigned* ncount);




/* \} */ // end construction group



//-----------------------------------------------------------------------------
// SIMULATION
//-----------------------------------------------------------------------------

NEMO_DLL_PUBLIC
nemo_simulation_t nemo_new_simulation(nemo_network_t, nemo_configuration_t);


NEMO_DLL_PUBLIC
void nemo_delete_simulation(nemo_simulation_t);


NEMO_DLL_PUBLIC
nemo_status_t
nemo_step(nemo_simulation_t,
        unsigned fstim_nidx[], size_t fstim_count,
        unsigned istim_nidx[], float istim_current[], size_t istim_count,
        unsigned* fired[], size_t* fired_count);


NEMO_DLL_PUBLIC
nemo_status_t
nemo_apply_stdp(nemo_simulation_t, float reward);


//-----------------------------------------------------------------------------
// QUERIES
//-----------------------------------------------------------------------------

NEMO_DLL_PUBLIC
nemo_status_t
nemo_get_membrane_potential(nemo_simulation_t sim, unsigned neuron, float* v);



NEMO_DLL_PUBLIC
nemo_status_t
nemo_get_neuron_state_n(nemo_network_t net, unsigned neuron, unsigned var, float* val);



NEMO_DLL_PUBLIC
nemo_status_t
nemo_get_neuron_parameter_n(nemo_network_t net, unsigned neuron, unsigned param, float* val);



NEMO_DLL_PUBLIC
nemo_status_t
nemo_get_neuron_state_s(nemo_simulation_t sim, unsigned neuron, unsigned var, float* val);



NEMO_DLL_PUBLIC
nemo_status_t
nemo_get_neuron_parameter_s(nemo_simulation_t sim, unsigned neuron, unsigned param, float* val);



NEMO_DLL_PUBLIC
nemo_status_t
nemo_get_synapse_source_n(nemo_network_t, synapse_id synapse, unsigned* source);



NEMO_DLL_PUBLIC
nemo_status_t
nemo_get_synapse_source_s(nemo_simulation_t, synapse_id synapse, unsigned* source);



NEMO_DLL_PUBLIC
nemo_status_t
nemo_get_synapse_target_n(nemo_network_t, synapse_id synapse, unsigned* target);


NEMO_DLL_PUBLIC
nemo_status_t
nemo_get_synapse_target_s(nemo_simulation_t, synapse_id synapse, unsigned* target);


NEMO_DLL_PUBLIC
nemo_status_t
nemo_get_synapse_delay_n(nemo_network_t, synapse_id synapse, unsigned* delay);


NEMO_DLL_PUBLIC
nemo_status_t
nemo_get_synapse_delay_s(nemo_simulation_t, synapse_id synapse, unsigned* delay);


NEMO_DLL_PUBLIC
nemo_status_t
nemo_get_synapse_weight_n(nemo_network_t, synapse_id synapse, float* weight);


NEMO_DLL_PUBLIC
nemo_status_t
nemo_get_synapse_weight_s(nemo_simulation_t, synapse_id synapse, float* weight);


NEMO_DLL_PUBLIC
nemo_status_t
nemo_get_synapse_plastic_n(nemo_network_t, synapse_id synapse, unsigned char* plastic);


NEMO_DLL_PUBLIC
nemo_status_t
nemo_get_synapse_plastic_s(nemo_simulation_t, synapse_id synapse, unsigned char* plastic);


NEMO_DLL_PUBLIC
nemo_status_t
nemo_get_synapses_from_n(nemo_network_t, unsigned source, synapse_id *synapses[], size_t* len);


NEMO_DLL_PUBLIC
nemo_status_t
nemo_get_synapses_from_s(nemo_simulation_t, unsigned source, synapse_id *synapses[], size_t* len);



/* \} */ // end simulation group


//-----------------------------------------------------------------------------
// MODIFYING THE NETWROK
//-----------------------------------------------------------------------------

NEMO_DLL_PUBLIC
nemo_status_t
nemo_set_neuron_n(nemo_network_t, unsigned idx, unsigned nargs, float args[]);


NEMO_DLL_PUBLIC
nemo_status_t
nemo_set_neuron_s(nemo_simulation_t, unsigned idx, unsigned nargs, float args[]);


NEMO_DLL_PUBLIC
nemo_status_t
nemo_set_neuron_iz_n(nemo_network_t net,
        unsigned idx,
        float a, float b, float c, float d,
        float u, float v, float sigma);


NEMO_DLL_PUBLIC
nemo_status_t
nemo_set_neuron_iz_s(nemo_simulation_t sim,
        unsigned idx,
        float a, float b, float c, float d,
        float u, float v, float sigma);


NEMO_DLL_PUBLIC
nemo_status_t
nemo_set_neuron_state_n(nemo_network_t net, unsigned neuron, unsigned var, float val);


NEMO_DLL_PUBLIC
nemo_status_t
nemo_set_neuron_parameter_n(nemo_network_t net, unsigned neuron, unsigned param, float val);


NEMO_DLL_PUBLIC
nemo_status_t
nemo_set_neuron_state_s(nemo_simulation_t sim, unsigned neuron, unsigned var, float val);


NEMO_DLL_PUBLIC
nemo_status_t
nemo_set_neuron_parameter_s(nemo_simulation_t sim, unsigned neuron, unsigned param, float val);


/* \} */ // end modification group


//-----------------------------------------------------------------------------
// TIMERS
//-----------------------------------------------------------------------------




NEMO_DLL_PUBLIC
nemo_status_t nemo_elapsed_wallclock(nemo_simulation_t, unsigned long*);

NEMO_DLL_PUBLIC
nemo_status_t nemo_elapsed_simulation(nemo_simulation_t, unsigned long*);

NEMO_DLL_PUBLIC
nemo_status_t nemo_reset_timer(nemo_simulation_t);

/* \} */ // end timing section




//-----------------------------------------------------------------------------
// ERROR HANDLING
//-----------------------------------------------------------------------------



NEMO_DLL_PUBLIC
const char* nemo_strerror();
  //end error group




#ifdef __cplusplus
}
#endif

#endif

---