NeuronGroup.cpp

Go to the documentation of this file.

//SpikeStream includes
#include "GlobalVariables.h"
#include "NeuronGroup.h"
#include "SpikeStreamException.h"
#include "Util.h"
using namespace spikestream;

//Qt includes
#include <QDebug>

//Other includes
#include <iostream>
using namespace std;

//Initialize static variables
unsigned NeuronGroup::neuronIDCounter = LAST_NEURON_ID + 1;
//unsigned NeuronGroup::neuronIDCounter = 0;

NeuronGroup::NeuronGroup(const NeuronGroupInfo& info){
        this->info = info;
        neuronMap = new NeuronMap();
        startNeuronID = 0;
        calculateBoundingBox = false;
        positionMapBuilt = false;
}


NeuronGroup::~NeuronGroup(){
        //Deletes neuron map and all its dynamically allocated objects
        if(neuronMap != NULL){
                clearNeurons();
                delete neuronMap;
        }
}


/*--------------------------------------------------------- */
/*-----                PUBLIC METHODS                 ----- */
/*--------------------------------------------------------- */

Neuron* NeuronGroup::addNeuron(float xPos, float yPos, float zPos){
        //Get temporary ID for the neuron - this must be unique and not exist in the current map
        unsigned tmpID = getTemporaryID();

        //Fix start neuron id
        if(neuronMap->isEmpty())
                startNeuronID = tmpID;
        else if(tmpID < startNeuronID)
                startNeuronID = tmpID;

        //Create neuron class
        Neuron* tmpNeuron = new Neuron(tmpID, xPos, yPos, zPos);

        //Store neuron class in ID map
        if(neuronMap->contains(tmpID))
                throw SpikeStreamException("Automatically generated temporary neuron ID clashes with one in the network. New ID=" + QString::number(tmpID));
        (*neuronMap)[tmpID] = tmpNeuron;

        //Finish off
        neuronGroupChanged();
        return tmpNeuron;
}


void NeuronGroup::addLayer(int width, int height, int xPos, int yPos, int zPos){
        for(int x=xPos; x < (xPos + width); ++x){
                for(int y=yPos; y < (yPos + height); ++y){
                        addNeuron(x, y, zPos);
                }
        }
        neuronGroupChanged();
}


void NeuronGroup::buildPositionMap(){
        neuronPositionMap.clear();

        //Work through all neurons
        NeuronMap::iterator mapEnd = neuronMap->end();
        for(NeuronMap::iterator iter=neuronMap->begin(); iter != mapEnd; ++iter){
                //Store link between neuron position and neuron class
                uint64_t tmpKey = getPositionKey(iter.value()->getXPos(), iter.value()->getYPos(), iter.value()->getZPos());
                if(neuronPositionMap.contains(tmpKey))
                        throw SpikeStreamException("Position key clashes with one in the position map. Key=" + QString::number(tmpKey));
                neuronPositionMap[tmpKey] = iter.value();
        }

        //Set flag to record that we have built position map
        positionMapBuilt = true;
}


void NeuronGroup::clearNeurons(){
        NeuronMap::iterator endNeuronMap = neuronMap->end();
        for(NeuronMap::iterator iter = neuronMap->begin(); iter != endNeuronMap; ++iter){
                delete iter.value();
        }
        neuronMap->clear();
        neuronGroupChanged();
}


bool NeuronGroup::contains(unsigned int neurID){
        if(neuronMap->contains(neurID))
                return true;
        return false;
}


bool NeuronGroup::contains(unsigned int neurID, float x, float y, float z){
        if(!neuronMap->contains(neurID))
                return false;;
        if((*neuronMap)[neurID]->getXPos() != x || (*neuronMap)[neurID]->getYPos() != y || (*neuronMap)[neurID]->getZPos() != z)
                return false;
        return true;
}


Box NeuronGroup::getBoundingBox(){
        //Return current box if nothing has changed about the neuron group
        if(!calculateBoundingBox)
                return boundingBox;

        //Calculate the bounding box
        Neuron* tmpNeuron;
        bool firstTime = true;
        NeuronMap::iterator mapEnd = neuronMap->end();//Saves accessing this function multiple times
        for(NeuronMap::iterator iter=neuronMap->begin(); iter != mapEnd; ++iter){
                tmpNeuron = iter.value();
                if(firstTime){//Take first neuron as starting point
                        boundingBox = Box(tmpNeuron->getXPos(), tmpNeuron->getYPos(), tmpNeuron->getZPos(),
                                                                tmpNeuron->getXPos(), tmpNeuron->getYPos(), tmpNeuron->getZPos()
                                                        );
                        firstTime = false;
                }
                else{//Expand box to include subsequent neurons
                        if(tmpNeuron->getXPos() < boundingBox.x1)
                                boundingBox.x1 = tmpNeuron->getXPos();
                        if(tmpNeuron->getYPos() < boundingBox.y1)
                                boundingBox.y1 = tmpNeuron->getYPos();
                        if(tmpNeuron->getZPos() < boundingBox.z1)
                                boundingBox.z1 = tmpNeuron->getZPos();

                        if(tmpNeuron->getXPos() > boundingBox.x2)
                                boundingBox.x2 = tmpNeuron->getXPos();
                        if(tmpNeuron->getYPos() > boundingBox.y2)
                                boundingBox.y2 = tmpNeuron->getYPos();
                        if(tmpNeuron->getZPos() > boundingBox.z2)
                                boundingBox.z2 = tmpNeuron->getZPos();
                }
        }

        //Return calculated box
        calculateBoundingBox = false;
        return boundingBox;
}


unsigned NeuronGroup::getID(){
        return info.getID();
}


Neuron* NeuronGroup::getNearestNeuron(const Point3D& point){
        double minDist = 0, tmpDist;
        bool firstTime;
        Neuron* closestNeuron = NULL;
        NeuronMap::iterator mapEnd = neuronMap->end();//Saves accessing this function multiple times
        for(NeuronMap::iterator iter=neuronMap->begin(); iter != mapEnd; ++iter){
                tmpDist = iter.value()->getLocation().distance(point);
                if(firstTime){
                        minDist = tmpDist;
                        closestNeuron = iter.value();
                        firstTime = false;
                }
                else{
                        if(tmpDist < minDist){
                                minDist = tmpDist;
                                closestNeuron = iter.value();
                        }
                }
        }
        return closestNeuron;
}


unsigned int NeuronGroup::getNeuronIDAtLocation(const Point3D& point){
        NeuronMap::iterator mapEnd = neuronMap->end();//Saves accessing this function multiple times
        for(NeuronMap::iterator iter=neuronMap->begin(); iter != mapEnd; ++iter){
                if(iter.value()->getLocation() == point)
                        return iter.key();
        }
        throw SpikeStreamException("No neuron at location "+ point.toString());
}


Point3D& NeuronGroup::getNeuronLocation(unsigned int neuronID){
        if(!neuronMap->contains(neuronID)){
                this->print();
                throw SpikeStreamException("Neuron ID '" + QString::number(neuronID) + "' could not be found.");
        }
        return (*neuronMap)[neuronID]->getLocation();
}


QList<Neuron*> NeuronGroup::getNeurons(const Box& box){
        QList<Neuron*> tmpList;
        NeuronMap::iterator mapEnd = neuronMap->end();
        for(NeuronMap::iterator iter=neuronMap->begin(); iter != mapEnd; ++iter){
                if( box.contains(iter.value()->getLocation()) )
                        tmpList.append(iter.value());
        }
        return tmpList;
}


unsigned NeuronGroup::getNeuronTypeID(){
        return getInfo().getNeuronTypeID();
}


double NeuronGroup::getParameter(const QString &key){
        if(!parameterMap.contains(key))
                throw SpikeStreamException("Cannot find parameter with key: " + key + " in neuron group with ID " + QString::number(info.getID()));
        return  parameterMap[key];
}


uint64_t NeuronGroup::getPositionKey(int xPos, int yPos, int zPos){
        if(xPos < 0 || yPos < 0 || zPos < 0)
                throw SpikeStreamException("This method currently only works with positive positions.");

        //Check positions are in range for this type of encoding
        if(xPos > 2097151 || yPos > 2097151 || zPos > 2097151)
                throw SpikeStreamException("X, Y or Z position out of range. Must be less than or equal to 2097151.");

        //Create key
        uint64_t newKey = xPos;
        newKey <<= 21;
        newKey |= yPos;
        newKey <<= 21;
        newKey |= zPos;
        return newKey;
}


Point3D NeuronGroup::getPointFromPositionKey(uint64_t positionKey){
        uint64_t keyExtractor = 2097151;
        float tmpZPos = (float) (positionKey & keyExtractor);
        positionKey >>= 21;
        float tmpYPos = (float) (positionKey & keyExtractor);
        positionKey >>= 21;
        float tmpXPos = (float) (positionKey & keyExtractor);
        return Point3D(tmpXPos, tmpYPos, tmpZPos);
}


bool NeuronGroup::isWeightless(){
        if(info.getNeuronType().getDescription().toUpper() == "WEIGHTLESS NEURON")
                return true;
        return false;
}


bool NeuronGroup::parametersSet(){
        if(getInfo().getNeuronType().getParameterCount() == parameterMap.size())
                return true;
        return false;
}


void NeuronGroup::print(){
        cout<<"------------- Neuron Group: id="<<info.getID()<<"; description="<<info.getDescription().toStdString();
        cout<<" "<<info.getNeuronType().getDescription().toStdString()<<" -------------"<<endl;
        NeuronMap::iterator mapEnd = neuronMap->end();
        for(NeuronMap::iterator iter=neuronMap->begin(); iter != mapEnd; ++iter){
                iter.value()->print();
        }
}


NeuronPositionIterator NeuronGroup::positionBegin(){
        if(!positionMapBuilt)
                buildPositionMap();
        return neuronPositionMap.begin();
}


NeuronPositionIterator NeuronGroup::positionEnd(){
        if(!positionMapBuilt)
                buildPositionMap();
        return neuronPositionMap.end();
}


void NeuronGroup::setID(unsigned int id){
        info.setID(id);
}


void NeuronGroup::setDescription(const QString& description){
        info.setDescription(description);
}


void NeuronGroup::setName(const QString& name){
        info.setName(name);
}


void NeuronGroup::setNeuronMap(NeuronMap* newMap){
        delete neuronMap;
        this->neuronMap = newMap;
        neuronGroupChanged();
}


void NeuronGroup::setParameters(QHash<QString, double>& paramMap){
        //Get the neuron type associated with this neuron group
        NeuronType neurType = getInfo().getNeuronType();
        QList<ParameterInfo> paramInfoList = neurType.getParameterInfoList();
        if(paramInfoList.size() != paramMap.size())
                throw SpikeStreamException("NeuronGroup: failed to set parameters. Mismatch between number of parameters.");
        foreach(ParameterInfo paramInfo, paramInfoList){
                if(!paramMap.contains(paramInfo.getName()))
                        throw SpikeStreamException("NeuronGroup: failed to set parameters. Missing parameter: " + paramInfo.getName());
        }

        //Parameters are ok - store map.
        this->parameterMap = paramMap;
}


int NeuronGroup::size(){
        return neuronMap->size();
}


/*--------------------------------------------------------- */
/*-----                PRIVATE METHODS                ----- */
/*--------------------------------------------------------- */

unsigned NeuronGroup::getTemporaryID(){
        return ++neuronIDCounter;
}


void NeuronGroup::neuronGroupChanged(){
        calculateBoundingBox = true;
        positionMapBuilt = false;
}