synapse_types_semd_impl.h

Go to the documentation of this file.

/*
 * Copyright (c) 2017 The University of Manchester
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef _SYNAPSE_TYPES_SEMD_IMPL_H_
#define _SYNAPSE_TYPES_SEMD_IMPL_H_
 
//---------------------------------------
// Macros
//---------------------------------------
#define SYNAPSE_TYPE_BITS 2
#define SYNAPSE_TYPE_COUNT 3
 
#define NUM_EXCITATORY_RECEPTORS 2
#define NUM_INHIBITORY_RECEPTORS 1
 
#include <debug.h>
#include "synapse_types.h"
#include "exp_synapse_utils.h"
 
//---------------------------------------
// Synapse parameters
//---------------------------------------
 
struct synapse_types_params_t {
    exp_params_t exc;           
    exp_params_t exc2;          
    exp_params_t inh;           
    input_t multiplicator_init;
    input_t exc2_old_init;
    input_t scaling_factor;
    REAL timestep_ms;
};
 
struct synapse_types_t {
    exp_state_t exc;           
    exp_state_t exc2;          
    exp_state_t inh;           
    input_t multiplicator;
    input_t exc2_old;
    input_t scaling_factor;
};
 
typedef enum {
    EXCITATORY_ONE,             
    EXCITATORY_TWO,             
    INHIBITORY,                 
} synapse_semd_input_buffer_regions;
 
 
//---------------------------------------
// Synapse shaping inline implementation
//---------------------------------------
 
static inline void synapse_types_initialise(synapse_types_t *state,
        synapse_types_params_t *params, uint32_t n_steps_per_timestep) {
    decay_and_init(&state->exc, &params->exc, params->timestep_ms, n_steps_per_timestep);
    decay_and_init(&state->exc2, &params->exc2, params->timestep_ms, n_steps_per_timestep);
    decay_and_init(&state->inh, &params->inh, params->timestep_ms, n_steps_per_timestep);
    state->multiplicator = params->multiplicator_init;
    state->exc2_old = params->exc2_old_init;
    state->scaling_factor = params->scaling_factor;
}
 
static void synapse_types_save_state(synapse_types_t *state, synapse_types_params_t *params) {
    params->exc.init_input = state->exc.synaptic_input_value;
    params->exc2.init_input = state->exc2.synaptic_input_value;
    params->inh.init_input = state->inh.synaptic_input_value;
    params->multiplicator_init = state->multiplicator;
    params->exc2_old_init = state->exc2_old;
}
 
static inline void synapse_types_shape_input(synapse_types_t *parameters) {
    exp_shaping(&parameters->exc);
    exp_shaping(&parameters->exc2);
    exp_shaping(&parameters->inh);
}
 
static inline void synapse_types_add_neuron_input(
        index_t synapse_type_index, synapse_types_t *parameter,
        input_t input) {
    switch (synapse_type_index) {
    case EXCITATORY_ONE:
        add_input_exp(&parameter->exc, input);
        break;
    case EXCITATORY_TWO:
        add_input_exp(&parameter->exc2, input);
        break;
    case INHIBITORY:
        add_input_exp(&parameter->inh, input);
        break;
    }
}
 
static inline input_t *synapse_types_get_excitatory_input(
        input_t *excitatory_response, synapse_types_t *parameters) {
    if (parameters->exc2.synaptic_input_value >= 0.001k
            && parameters->multiplicator == ZERO
            && parameters->exc2_old == ZERO) {
        parameters->multiplicator = parameters->exc.synaptic_input_value;
    } else if (parameters->exc2.synaptic_input_value < 0.001k) {
        parameters->multiplicator = ZERO;
    }
 
    parameters->exc2_old = parameters->exc2.synaptic_input_value;
 
    excitatory_response[0] = ZERO;
    excitatory_response[1] =
            parameters->exc2.synaptic_input_value * parameters->multiplicator
            * parameters->scaling_factor;
    return &excitatory_response[0];
}
 
static inline input_t *synapse_types_get_inhibitory_input(
        input_t *inhibitory_response, synapse_types_t *parameters) {
    inhibitory_response[0] = parameters->inh.synaptic_input_value;
    return &inhibitory_response[0];
}
 
static inline const char *synapse_types_get_type_char(
        index_t synapse_type_index) {
    switch (synapse_type_index) {
    case EXCITATORY_ONE:
        return "X1";
    case EXCITATORY_TWO:
        return "X2";
    case INHIBITORY:
        return "I";
    default:
        log_debug("did not recognise synapse type %i", synapse_type_index);
        return "?";
    }
}
 
static inline void synapse_types_print_input(synapse_types_t *parameters) {
    log_info("%12.6k + %12.6k - %12.6k",
            parameters->exc.synaptic_input_value,
            parameters->exc2.synaptic_input_value,
            parameters->inh.synaptic_input_value);
    log_info("multiplicator = %11.4k\n", parameters->multiplicator);
    log_info("exc2_old      = %11.4k\n", parameters->exc2_old);
}
 
static inline void synapse_types_print_parameters(synapse_types_t *parameters) {
    log_info("exc_decay  = %11.4k\n", parameters->exc.decay);
    log_info("exc_init   = %11.4k\n", parameters->exc.init);
    log_info("exc2_decay = %11.4k\n", parameters->exc2.decay);
    log_info("exc2_init  = %11.4k\n", parameters->exc2.init);
    log_info("inh_decay  = %11.4k\n", parameters->inh.decay);
    log_info("inh_init   = %11.4k\n", parameters->inh.init);
    log_info("gsyn_excitatory_initial_value = %11.4k\n",
            parameters->exc.synaptic_input_value);
    log_info("gsyn_excitatory2_initial_value = %11.4k\n",
            parameters->exc2.synaptic_input_value);
    log_info("gsyn_inhibitory_initial_value = %11.4k\n",
            parameters->inh.synaptic_input_value);
    log_info("scaling_factor = %11.4k\n", parameters->scaling_factor);
}
 
#endif  // _SYNAPSE_TYPES_SEMD_IMPL_H_