Synapse
Axon::getSynapse(nidx_t source, id32_t id) const
{
if(id >= size()) {
throw nemo::exception(NEMO_INVALID_INPUT, "synapse id out or range");
}
return Synapse(source, m_delays[id],
AxonTerminal(id, m_targets[id], m_weights[id], m_plastic[id]));
}
void SingleAN(double *px, double cf, int nrep, double tdres, int totalstim, double fibertype, double noiseType, double implnt, double *meanrate, double *varrate, double *psth)
{
/*variables for the signal-path, control-path and onward */
double *synouttmp,*sptime;
int i,nspikes,ipst;
double I,spont;
double sampFreq = 10e3; /* Sampling frequency used in the synapse */
/* Declarations of the functions used in the program */
double Synapse(double *, double, double, int, int, double, double, double, double, double *);
int SpikeGenerator(double *, double, int, int, double *);
/* Allocate dynamic memory for the temporary variables */
synouttmp = (double*)mxCalloc(totalstim*nrep,sizeof(double));
sptime = (double*)mxCalloc((long) ceil(totalstim*tdres*nrep/0.00075),sizeof(double));
/* Spontaneous Rate of the fiber corresponding to Fibertype */
if (fibertype==1) spont = 0.1;
if (fibertype==2) spont = 4.0;
if (fibertype==3) spont = 100.0;
/*====== Run the synapse model ======*/
I = Synapse(px, tdres, cf, totalstim, nrep, spont, noiseType, implnt, sampFreq, synouttmp);
/* Wrapping up the unfolded (due to no. of repetitions) Synapse Output */
for(i = 0; i<I ; i++)
{
ipst = (int) (fmod(i,totalstim));
meanrate[ipst] = meanrate[ipst] + synouttmp[i]/nrep;
};
/* Synapse Output taking into account the Refractory Effects (Vannucci and Teich, 1978) */
for(i = 0; i<totalstim ; i++)
{
varrate[i] = meanrate[i]/pow((1+0.75e-3*meanrate[i]),3); /* estimated instananeous variance in the discharge rate */
meanrate[i] = meanrate[i]/(1+0.75e-3*meanrate[i]); /* estimated instantaneous mean rate */
};
/*====== Spike Generations ======*/
nspikes = SpikeGenerator(synouttmp, tdres, totalstim, nrep, sptime);
for(i = 0; i < nspikes; i++)
{
ipst = (int) (fmod(sptime[i],tdres*totalstim) / tdres);
psth[ipst] = psth[ipst] + 1;
};
/* Freeing dynamic memory allocated earlier */
mxFree(sptime); mxFree(synouttmp);
} /* End of the SingleAN function */
void Network::createMultiLayer(int M, int N, double weight, double parameter)
{
// clear previous network
_synapses.clear();
_neurons.clear();
_ptrInputNeurons.clear();
_ptrOutputNeurons.clear();
// reserve memory to store all neurons and synapses
// otherwise reallocation and invalid pointers
_neurons.reserve(M*M);
_synapses.reserve(M*M*M);
// add input neurons
for (int i=0; i<M; i++)
{
_neurons.push_back(Neuron());
_neurons[i].init(parameter);
_ptrInputNeurons.push_back(&_neurons[i]);
}
// add other neurons and add synapse
// for all layer
for (int i=M,k=0; i>N; i--)
{
// for all neurons of the sub-layer
for (int j=0; j<i-1; j++)
{
// add a neuron
_neurons.push_back(Neuron());
_neurons.back().init(parameter);
// add synapses from neurons of the main layer to the new neuron
for (int l=0; l<i; l++)
{
_synapses.push_back(Synapse());
_synapses.back().init(&_neurons[k+l], &_neurons.back(), weight);
}
}
k += i;
}
// get output neurons
for (int i=0; i<N; i++)
{
_ptrOutputNeurons.push_back(&_neurons[_neurons.size()-N+i]);
}
}
void Neuron::addSynapse(Neuron *n, double w, double d){
synapses.push_back(Synapse(n, w, d));
}
Phenotype *PhenotypeFactory::createPhenotype(Genotype const &genome) {
NeuronMap neurons;
std::unordered_map<size_t, std::vector<size_t>> terminals;
std::unordered_map<size_t, size_t> sources;
NeuronList inputs, hiddens, outputs;
std::queue<size_t> peninsulas;
struct h {
size_t operator()(std::pair<size_t, size_t> const &p) const {
return std::hash<size_t>()(p.first) ^ std::hash<size_t>()(p.second);
}
};
struct e {
size_t operator()(std::pair<size_t, size_t> const &p1,
std::pair<size_t, size_t> const &p2) const {
return (p1.first == p2.first) && (p1.second == p2.second);
}
};
std::unordered_set<std::pair<size_t, size_t>, h, e> graph, visited;
// Create neurons
for (auto const &g : genotypeManager->neurons) {
Neuron *n = new Neuron(g.second.type);
neurons.insert({g.first, n});
terminals.insert({g.first, std::vector<size_t>()});
sources.insert({g.first, 0});
if (n->type == NeuronGene::NEURON_INPUT) {
inputs.push_back(n);
peninsulas.push(g.first);
} else if (n->type == NeuronGene::NEURON_OUTPUT)
outputs.push_back(n);
//else
// hiddens.push_back(n);
}
// Connect neurons
for (auto const &g : genome.synapses) {
SynapseGene const &sg = g.second;
if (sg.isEnabled()) {
Neuron *const &from = neurons.at(sg.from);
Neuron *const &to = neurons.at(sg.to);
from->synapses.push_back(Synapse(to, sg.getWeight()));
sources.at(sg.to) += 1;
terminals.at(sg.from).push_back(sg.to);
graph.insert({sg.from, sg.to});
}
}
while (!peninsulas.empty()) {
std::cout << "Next: " << peninsulas.front() << std::endl;
size_t const ni = peninsulas.front();
Neuron *const &n = neurons.at(ni);
if (n->type == NeuronGene::NEURON_HIDDEN)
hiddens.push_back(n);
for (size_t const &nj : terminals.at(ni)) {
visited.insert({ni, nj});
std::cout << nj << " " << sources.at(nj) << std::endl;
if ((sources.at(nj) -= 1) == 0) {
peninsulas.push(nj);
std::cout << nj << " pushed" << std::endl;
}
}
peninsulas.pop();
}
std::cout << "Edges: " << visited.size() << std::endl;
std::cout << "OK? " << (visited.size() == graph.size()) << std::endl;
if (visited.size() == graph.size())
return new Phenotype(inputs, hiddens, outputs);
return nullptr;
}
int UpdateMuscleLoop(double *loopState, double *mnPoolState, double *snPoolState, double *synPoolState, double *loopParam)
{
// PARAM LOAD
double digSpikeSize = loopParam[1]; //????
double timeInterval = loopParam[2];
double reset = loopParam[8];
// *** Izh alpha motoneuron pool :: I (nanoAmp) -> spike
double iniMNVolt = loopParam[9];
double iniMNRecov = loopParam[10];
double iniMNSpike = loopParam[11];
double mnState[NUM_MN_STATES];
double mnInput[3];
mnInput[0] = loopParam[0]; // current input to alpha
mnInput[1] = digSpikeSize; // spike ? mnInput[1] : 0.0
mnInput[2] = timeInterval; // dt
double mnSpikeCount = 0.0;
if(reset > 0.01) // RESET -> initialize all motoneuron pool
{
for (int i = 0; i < NUM_MN; i++)
{
memcpy(mnState, mnPoolState + NUM_MN_STATES * i, NUM_MN_STATES * sizeof(double));
Izhikevich(mnState, mnInput);
if (mnState[2] > 0)
{
mnSpikeCount += 1.0; //the number of spikes
}
memcpy(mnPoolState + NUM_MN_STATES * i, mnState, NUM_MN_STATES * sizeof(double));
}
}
else
{
for (int i = 0; i < NUM_MN; i++)
{
mnPoolState[3*i] = iniMNVolt;
mnPoolState[3*i+1] = iniMNRecov;
mnPoolState[3*i+2] = iniMNSpike;
}
}
// *** Muscle Fiber:: spikes (accumulated) -> Force
double musDrive = loopParam[5];
double musTimeConst = loopParam[6];
double musPeakForce = loopParam[7];
double nowF = loopState[3];
double preF = loopState[4];
double C = musTimeConst;
double P = musPeakForce;
double h = timeInterval; //???? CHECK it out
double fiberState[3];
fiberState[0] = C/(exp(1)*P*h*h)-1/(exp(1)*P*h); // define the discretization of the ODE
fiberState[1] = -2*C/(exp(1)*P*h*h)+1/(exp(1)*P*C);
fiberState[2] = C/(exp(1)*P*h*h)+1/(exp(1)*P*h);
double u;
double f;
u = musDrive/h;
f = (u- fiberState[0]* preF - fiberState[1] * nowF)/fiberState[2];
preF = nowF;
nowF = f;
// *** Spindle :: (Lce, Gd, Gs) -> Ia firing rate (pps)
double spindleState[14];
double spindleInput[4];
spindleInput[0] = loopParam[3]; //gd
spindleInput[1] = loopParam[14]; //lce
spindleInput[2] = timeInterval / (double) CYCLES_OF_INT; //a tenth of dt
spindleInput[3] = loopParam[4];; //gs
//Bag I
spindleState[0] = loopState[3]; // x0
spindleState[1] = loopState[4]; // x1
spindleState[2] = loopState[5]; // x2
spindleState[3] = loopState[6]; // Ia firing rate
spindleState[4] = loopState[10]; // dx0
spindleState[5] = loopState[11]; // dx1
spindleState[6] = loopState[12]; // dx2
//Bag II
spindleState[7] = loopState[13]; // x3
spindleState[8] = loopState[14]; // x4
spindleState[9] = loopState[15]; // x5
spindleState[10] = loopState[16]; // IIa firing rate
spindleState[11] = loopState[17]; // dx3
spindleState[12] = loopState[18]; // dx4
spindleState[13] = loopState[19]; // dx5
for (int j = 0; j < 10; j++)
{
Spindle(spindleState, spindleInput);
}
// *** Ia Sensory Neuron :: Ia postsyn current -> Ia_spike
double snState[NUM_SN_STATES];
double snInput[3];
snInput[0] = loopParam[13]; // current input to sensory neuron
snInput[1] = digSpikeSize; // spike size
snInput[2] = timeInterval; // dt
//TODO ADD THE OTHER VAR
double snSpikeCount = 0.0;
if(reset > 0.01) // RESET -> initialize all motoneuron pool
{
for (int i = 0; i < NUM_SN; i++)
{
memcpy(snState, snPoolState + NUM_SN_STATES * i, NUM_SN_STATES * sizeof(double));
Izhikevich(snState, snInput);
if (snState[2] > 0)
{
snSpikeCount += 1.0; //the number of spikes
}
memcpy(snPoolState + NUM_SN_STATES * i, snState, NUM_SN_STATES* sizeof(double));
}
}
else
{
for (int i = 0; i < NUM_SN; i++)
{
snPoolState[3*i] = iniMNVolt;
snPoolState[3*i+1] = iniMNRecov;
snPoolState[3*i+2] = iniMNSpike;
}
}
// *** synapse :: Ia_firingrate -> Ia_postsyn current
double synState[NUM_SYNAPSE_STATES];
double synInput[1];
if(reset > 0.01) // RESET -> initialize all sensory pool
{
for (int i = 0; i < NUM_SYN; i++)
{
memcpy(synState, synPoolState + NUM_SYNAPSE_STATES * i, NUM_SYNAPSE_STATES*sizeof(double));
synInput[0]= snPoolState[NUM_SN_STATES * i + 2];
Synapse(synState, synInput);
memcpy(synPoolState + NUM_SYNAPSE_STATES * i, mnState, NUM_SYNAPSE_STATES*sizeof(double));
}
}
if(reset > 0.01)
{
loopState[2] = mnSpikeCount; //the number of spikes
loopState[3] = nowF; //
loopState[4] = preF ; //
//Bag I
loopState[5] = spindleState[0] ; // x0
loopState[6] = spindleState[1] ;// x1
loopState[7] = spindleState[2] ; // x2
loopState[8] = spindleState[3] ;// Ia firing rate
loopState[9] = spindleState[4] ; //d x0
loopState[10] = spindleState[5] ;// dx1
loopState[11] = spindleState[6] ; // dx2
//Bag II
loopState[12] = spindleState[7] ; // x3
loopState[13] = spindleState[8] ; // x4
loopState[14] = spindleState[9] ; // x5
loopState[15] = spindleState[10]; // IIa firing rate
loopState[16] = spindleState[11]; // dx3
loopState[17] = spindleState[12]; // dx4
loopState[18] = spindleState[13]; // dx5
loopState[19] = snSpikeCount; //the number of spikes
loopState[20] = synState[0]; //synapse output
}
else //?????
{
loopState[2] = 0.0; //the number of spikes
loopState[3] = 0.0; //
loopState[4] = 0.0 ; //
//Bag I
loopState[5] = 0.0 ; // x0
loopState[6] = 0.9579 ;// x1
loopState[7] = 0.0 ; // x2
loopState[8] = 0.0 ;// Ia firing rate
loopState[9] = 0.0 ; //d x0
loopState[10] = 0.0 ;// dx1
loopState[11] = 0.0 ; // dx2
//Bag II
loopState[12] = 0.0 ; // x3
loopState[13] = 0.9579 ; // x4
loopState[14] = 0.0 ; // x5
loopState[15] = 0.0; // IIa firing rate
loopState[16] = 0.0; // dx3
loopState[17] = 0.0; // dx4
loopState[18] = 0.0; // dx5
loopState[19] = 0.0;
loopState[20] = 0.0; //synapse output
}
return 0;
}
