neuron_model_if_trunc.h

Go to the documentation of this file.

/*
 * Copyright (c) 2024 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 _NEURON_MODEL_IF_TRUNC_H_
#define _NEURON_MODEL_IF_TRUNC_H_
 
#include "neuron_model.h"
 
struct neuron_params_t {
    REAL     V_init;
 
    REAL     c_m;
 
    REAL     tau_m;
 
    REAL     I_offset;
 
    REAL     V_reset;
 
    REAL     T_refract_ms;
 
    int32_t  refract_timer_init;
 
    REAL     time_step;
};
 
 
struct neuron_t {
    REAL     V_membrane;
 
    REAL     R_membrane;
 
    REAL     I_offset;
 
    int32_t  refract_timer;
 
    REAL     V_reset;
 
    int32_t  T_refract;
};
 
static inline int32_t lif_ceil_accum(REAL value) {
    int32_t bits = bitsk(value);
    int32_t integer = bits >> 15;
    int32_t fraction = bits & 0x7FFF;
    if (fraction > 0) {
        return integer + 1;
    }
    return integer;
}
 
static inline void neuron_model_initialise(
        neuron_t *state, neuron_params_t *params, uint32_t n_steps_per_timestep) {
    REAL ts = kdivui(params->time_step, n_steps_per_timestep);
    state->V_membrane = params->V_init;
    state->R_membrane = kdivk(params->tau_m, params->c_m);
    state->I_offset = params->I_offset;
    state->refract_timer = params->refract_timer_init;
    state->V_reset = params->V_reset;
    state->T_refract = lif_ceil_accum(kdivk(params->T_refract_ms, ts));
}
 
static inline void neuron_model_save_state(neuron_t *state, neuron_params_t *params) {
    params->V_init = state->V_membrane;
    params->refract_timer_init = state->refract_timer;
}
 
static inline state_t neuron_model_state_update(
        uint16_t num_excitatory_inputs, const input_t *exc_input,
        uint16_t num_inhibitory_inputs, const input_t *inh_input,
        input_t external_bias, REAL current_offset, neuron_t *restrict neuron) {
 
    // If outside of the refractory period
    if (neuron->refract_timer <= 0) {
        REAL total_exc = ZERO;
        REAL total_inh = ZERO;
 
        for (int i=0; i < num_excitatory_inputs; i++) {
            total_exc += exc_input[i];
        }
        for (int i=0; i< num_inhibitory_inputs; i++) {
            total_inh += inh_input[i];
        }
        // Get the input in nA
        input_t input_this_timestep =
                total_exc - total_inh + external_bias + neuron->I_offset + current_offset;
 
        // Simply add on the input scaled by the resistance
        neuron->V_membrane = (input_this_timestep * neuron->R_membrane) + neuron->V_membrane;
 
        // Disallow the membrane going below the reset voltage for simplicity
        if (neuron->V_membrane < neuron->V_reset) {
            neuron->V_membrane = neuron->V_reset;
        }
    } else {
        // countdown refractory timer
        neuron->refract_timer--;
    }
    return neuron->V_membrane;
}
 
static inline void neuron_model_has_spiked(neuron_t *restrict neuron) {
    // reset membrane voltage
    neuron->V_membrane = neuron->V_reset;
 
    // reset refractory timer
    neuron->refract_timer  = neuron->T_refract;
}
 
static inline state_t neuron_model_get_membrane_voltage(const neuron_t *neuron) {
    return neuron->V_membrane;
}
 
static inline void neuron_model_print_state_variables(const neuron_t *neuron) {
    log_info("V membrane    = %11.4k mv", neuron->V_membrane);
    log_info("Refract timer = %u timesteps", neuron->refract_timer);
}
 
static inline void neuron_model_print_parameters(const neuron_t *neuron) {
    log_info("V reset       = %11.4k mv", neuron->V_reset);
 
    log_info("I offset      = %11.4k nA", neuron->I_offset);
    log_info("R membrane    = %11.4k Mohm", neuron->R_membrane);
 
    log_info("T refract     = %u timesteps", neuron->T_refract);
}
 
 
#endif //_NEURON_MODEL_IF_TRUNC_H_