NetworkDaoThread.cpp

Go to the documentation of this file.

//SpikeStream includes
#include "ConfigLoader.h"
#include "Connection.h"
#include "GlobalVariables.h"
#include "NetworkDaoThread.h"
#include "Neuron.h"
#include "PerformanceTimer.h"
#include "SpikeStreamException.h"
#include "SpikeStreamDBException.h"
#include "Util.h"
using namespace spikestream;

#include <iostream>
using namespace std;

#define TIME_PERFORMANCE

//#define DEBUG


NetworkDaoThread::NetworkDaoThread(const DBInfo& dbInfo, const QString& name) : NetworkDao(dbInfo) {
        this->setObjectName(name);
    currentTask = NO_TASK_DEFINED;
    clearError();
    stopThread = true;
        progressMessage = "Not running";

        //Load up configuration parameters
        ConfigLoader configLoader;
        numConBuffers = Util::getInt(configLoader.getParameter("number_insert_connection_buffers"));
        numNeurBuffers = Util::getInt(configLoader.getParameter("number_insert_neuron_buffers"));
}


NetworkDaoThread::~NetworkDaoThread(){
}


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

void NetworkDaoThread::prepareAddConnectionGroup(unsigned int networkID, ConnectionGroup* connGrp){
    //Copy connection group into a list and call the mai nconnection group adding method
    QList<ConnectionGroup*> tmpConGrpList;
    tmpConGrpList.append(connGrp);
    prepareAddConnectionGroups(networkID, tmpConGrpList);
}


void NetworkDaoThread::prepareAddConnectionGroups(unsigned int networkID, QList<ConnectionGroup*>& connGrpList){
    //Store necessary variables
    this->networkID = networkID;
    this->connectionGroupList = connGrpList;

    //Set the task that will run when the thread starts
    currentTask = ADD_CONNECTION_GROUPS_TASK;

    //Record the total number of steps that the task involves
    totalNumberOfSteps = 1;
}


void NetworkDaoThread::prepareAddNeuronGroup(unsigned int networkID, NeuronGroup* neurGrp){
    //Copy neuron group into a list and call the main method to add neuron groups
    QList<NeuronGroup*> tmpNeurGrpList;
    tmpNeurGrpList.append(neurGrp);
    prepareAddNeuronGroups(networkID, tmpNeurGrpList);
}


void NetworkDaoThread::prepareAddNeuronGroups(unsigned int networkID, QList<NeuronGroup*>& neurGrpList){
        //Store necessary variables
    this->networkID = networkID;
    this->neuronGroupList = neurGrpList;

    //Set the task that will run when the thread starts
    currentTask = ADD_NEURON_GROUPS_TASK;

    //Record the total number of steps that the task involves
    totalNumberOfSteps = 1;
}


void NetworkDaoThread::prepareDeleteConnectionGroups(unsigned int networkID, QList<unsigned int>& conGrpList){
        //Store necessary variables
        this->networkID = networkID;
        this->connectionGroupIDList = conGrpList;

        //Set the task that will run when the thread starts
        currentTask = DELETE_CONNECTION_GROUPS_TASK;

        //Record the total number of steps that the task involves
        totalNumberOfSteps = 1;
        progressMessage = "Deleting connection groups.";
}


void NetworkDaoThread::prepareDeleteNeuronGroups(unsigned int networkID, QList<unsigned int>& neurGrpList){
        //Store necessary variables
        this->networkID = networkID;
        this->neuronGroupIDList = neurGrpList;

        //Set the task that will run when the thread starts
        currentTask = DELETE_NEURON_GROUPS_TASK;

        //Record the total number of steps that the task involves
        totalNumberOfSteps = 1;
        progressMessage = "Deleting neuron groups.";
}


void NetworkDaoThread::prepareLoadConnections(const QList<ConnectionGroup*>& connGrpList){
    //Store necessary variables
    this->connectionGroupList = connGrpList;

    //Set the taks that will run when the thread starts
    currentTask = LOAD_CONNECTIONS_TASK;
        progressMessage = "Loading connections";
}


void NetworkDaoThread::prepareLoadConnections(ConnectionGroup* connGrp){
    //Store necessary variables
    connectionGroupList.clear();
    connectionGroupList.append(connGrp);

    //Set the task that will run when the thread starts
    currentTask = LOAD_CONNECTIONS_TASK;
        progressMessage = "Loading connections";
}


void NetworkDaoThread::prepareLoadNeurons(const QList<NeuronGroup*>& neurGrpList){
    //Store necessary variables
    this->neuronGroupList = neurGrpList;

    //Set the task that will run when the thread starts
    currentTask = LOAD_NEURONS_TASK;
        progressMessage = "Loading neurons";
}


void NetworkDaoThread::prepareLoadNeurons(NeuronGroup* neurGrp){
        //Store necessary variables
        neuronGroupList.clear();
        neuronGroupList.append(neurGrp);

        //Set the task that will run when the thread starts
        currentTask = LOAD_NEURONS_TASK;
        progressMessage = "Loading neurons";
}


void NetworkDaoThread::clearError(){
    errorMessage = "";
    error = false;
}


void NetworkDaoThread::run(){
    stopThread = false;
    clearError();
    numberOfCompletedSteps = 0;
    try{
        //Connect to the database now that we are in a separate thread
                connectToDatabase();

                switch(currentTask){
                        case ADD_NEURON_GROUPS_TASK:
                                addNeuronGroups();
                        break;
                        case ADD_CONNECTION_GROUPS_TASK:
                                addConnectionGroups();
                        break;
                        case DELETE_CONNECTION_GROUPS_TASK:
                                deleteConnectionGroups();
                        break;
                        case DELETE_NETWORK_TASK:
                                deleteConnectionGroups();
                                deleteNeuronGroups();
                                deleteNetwork();
                        break;
                        case DELETE_NEURON_GROUPS_TASK:
                                deleteNeuronGroups();
                        break;
                        case LOAD_CONNECTIONS_TASK:
                                loadConnections();
                        break;
                        case LOAD_NEURONS_TASK:
                                loadNeurons();
                        break;
                        case SAVE_NETWORK_TASK:
                                saveNetwork();
                        break;
                        case SAVE_TEMP_WEIGHTS_TASK:
                                saveTempWeights();
                        break;
                        default:
                                setError("NetworkDaoThread started without defined task.");
                }

                //Database connection can be closed
                closeDatabaseConnection();
    }
    catch(SpikeStreamException& ex){
                setError("NetworkDaoThread: SpikeStreamException thrown carrying out current task: " + ex.getMessage());
    }
    catch(...){
                setError("Unrecognized exception thrown carrying out current task.");
    }

    //Current task is complete
        neuronGroupIDList.clear();
        neuronGroupList.clear();
        connectionGroupIDList.clear();
        connectionGroupList.clear();
        networkID = 0;
    currentTask = NO_TASK_DEFINED;
    stopThread = true;
}


void NetworkDaoThread::startDeleteNetwork(unsigned networkID){
        this->networkID = networkID;
        //Store list of connection group IDs
        connectionGroupIDList.clear();
        QList<ConnectionGroupInfo> conGrpInfoList;
        getConnectionGroupsInfo(networkID, conGrpInfoList);
        foreach(ConnectionGroupInfo conGrpInfo, conGrpInfoList)
                connectionGroupIDList.append(conGrpInfo.getID());

        //Store list of neuron group IDs
        neuronGroupIDList.clear();
        QList<NeuronGroupInfo> neurGrpInfoList;
        getNeuronGroupsInfo(networkID, neurGrpInfoList);
        foreach(NeuronGroupInfo neurGrpInfo, neurGrpInfoList)
                neuronGroupIDList.append(neurGrpInfo.getID());

        //Prepare and start task
        currentTask = DELETE_NETWORK_TASK;
        progressMessage = "Deleting network";
        start();
}


void NetworkDaoThread::startSaveNetwork(unsigned networkID, QList<NeuronGroup*> newNeuronGroups, QList<ConnectionGroup*> newConnectionGroups, QList<unsigned> deleteNeuronGroupIDs, QList<unsigned> deleteConnectionGroupIDs, QList<ConnectionGroup*> volatileConnectionGroups){
        //Store data
        this->networkID = networkID;
        this->neuronGroupList = newNeuronGroups;
        this->connectionGroupList = newConnectionGroups;
        this->neuronGroupIDList = deleteNeuronGroupIDs;
        this->connectionGroupIDList = deleteConnectionGroupIDs;
        this->volatileConnectionGroupList = volatileConnectionGroups;

        //Start thread running
        currentTask = SAVE_NETWORK_TASK;
        progressMessage = "Saving network";
        start();
}


void NetworkDaoThread::startSaveTempWeights(QList<ConnectionGroup*>& connectionGroupList){
        //Store data
        this->volatileConnectionGroupList = connectionGroupList;

        //Start thread running
        currentTask = SAVE_TEMP_WEIGHTS_TASK;
        numberOfCompletedSteps = 0;
        totalNumberOfSteps = 0;
        progressMessage = "Saving temporary weights";
        start();
}


void NetworkDaoThread::stop(){
    stopThread = true;
}


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

void NetworkDaoThread::addConnectionGroups(){
        //Reset progress measure
        numberOfCompletedSteps = 0;
        totalNumberOfSteps = connectionGroupList.size();
        progressMessage = "Adding Connections";

    //Work through the list of connection groups
        for(QList<ConnectionGroup*>::iterator iter = connectionGroupList.begin(); iter != connectionGroupList.end() && !stopThread; ++iter){
                //Get a pointer to the connection group
                ConnectionGroup* connectionGroup = *iter;

                //Get a copy of the information about the connection group
                ConnectionGroupInfo connGrpInfo = connectionGroup->getInfo();

                //Build query string
                QString queryStr = "INSERT INTO ConnectionGroups (NetworkID, Description, FromNeuronGroupID, ToNeuronGroupID, Parameters, SynapseTypeID ) VALUES (";
                queryStr += QString::number(networkID) + ", ";
                queryStr += "'" + connGrpInfo.getDescription() + "', ";
                queryStr += QString::number(connGrpInfo.getFromNeuronGroupID()) + ", ";
                queryStr += QString::number(connGrpInfo.getToNeuronGroupID()) + ", ";
                queryStr += "'" + connGrpInfo.getParameterXML() + "', ";
                queryStr += QString::number(connGrpInfo.getSynapseTypeID()) + ")";
                QSqlQuery query = getQuery(queryStr);
                executeQuery(query);

                //Check id is correct and add to connection group info if it is
                int lastInsertID = query.lastInsertId().toInt();
                if(lastInsertID >= START_CONNECTIONGROUP_ID)
                        connectionGroup->setID(lastInsertID);
                else{
                        throw SpikeStreamException("Insert ID for ConnectionGroup is invalid.");
                }

                //Add entry for connection group parameters
                //Get name of table
                SynapseType synapseType = getSynapseType(connGrpInfo.getSynapseTypeID());

                //Add parameter table entry for this connection group
                executeQuery( "INSERT INTO " + synapseType.getParameterTableName() + "(ConnectionGroupID) VALUES (" + QString::number(connectionGroup->getID()) + ")" );

                //Set synapse parameters to default values if they have not been set
                if(!connectionGroup->parametersSet()){
                        QHash<QString, double> tmpParamMap = getDefaultSynapseParameters(connectionGroup->getSynapseTypeID());
                        connectionGroup->setParameters(tmpParamMap);
                }

                //Copy parameters from connection group into parameter table
                QHash<QString, double> tmpParamMap = connectionGroup->getParameters();
                setSynapseParameters(connectionGroup->getInfo(), tmpParamMap);

                #ifdef TIME_PERFORMANCE
                        PerformanceTimer timer;
                #endif//TIME_PERFORMANCE

                //Build query
                query = getQuery();
                queryStr = "INSERT INTO Connections ( ConnectionGroupID, FromNeuronID, ToNeuronID, Delay, Weight) VALUES ";
                for(int i=0; i<numConBuffers-1; ++i)
                        queryStr += "(?, ?, ?, ?, ?),";
                queryStr += "(?, ?, ?, ?, ?)";
                query.prepare(queryStr);

                //Add connections to database
                int conCntr = 0, offset = 0, conAddedCntr = 0;
                QList<Connection*> tmpConList;
                ConnectionIterator endConGrp = connectionGroup->end();
                for(ConnectionIterator iter = connectionGroup->begin(); iter != endConGrp && !stopThread; ++iter){
                        offset = 5 * (conCntr % numConBuffers);

                        //Bind values to query
                        tmpConList.append(&(*iter));
                        query.bindValue(0 + offset, connectionGroup->getID());
                        query.bindValue(1 + offset, iter->getFromNeuronID());
                        query.bindValue(2 + offset, iter->getToNeuronID());
                        query.bindValue(3 + offset, iter->getDelay());
                        query.bindValue(4 + offset, iter->getWeight());

                        //Execute query
                        if(conCntr % numConBuffers == numConBuffers-1){
                                executeQuery(query);

                                //Add connection id to connection - last insert id is the id of the first connection in the list of value entries
                                int lastInsertID = query.lastInsertId().toInt();
                                if( (lastInsertID + tmpConList.size()) > LAST_CONNECTION_ID )
                                        throw SpikeStreamException("Database generated connection ID is out of range: " + QString::number(lastInsertID + tmpConList.size()) + ". It must be less than or equal to " + QString::number(LAST_CONNECTION_ID));
                                if(lastInsertID < START_CONNECTION_ID)
                                        throw SpikeStreamException("Insert ID for Connection is invalid.");
                                if(tmpConList.size() != numConBuffers)
                                        throw SpikeStreamException("Temporary connection list size " + QString::number(tmpConList.size()) + " does not match number of buffers: " + QString::number(numConBuffers));

                                //Set connection ID in connection groups
                                for(int i=0; i<tmpConList.size(); ++i){
                                        tmpConList.at(i)->setID(lastInsertID + i);
                                }

                                //Count number of connections that have been added
                                conAddedCntr += numConBuffers;

                                //Clear up list
                                tmpConList.clear();
                        }

                        //Keep track of the number of connections
                        ++conCntr;
                }

                //Add remaining connections individually
                if(!tmpConList.isEmpty() && !stopThread){
                        query = getQuery();
                        query.prepare("INSERT INTO Connections ( ConnectionGroupID, FromNeuronID, ToNeuronID, Delay, Weight) VALUES (?, ?, ?, ?, ?)");
                        for(QList<Connection*>::iterator iter = tmpConList.begin(); iter != tmpConList.end(); ++iter){
                                query.bindValue(0, connectionGroup->getID());
                                query.bindValue(1, (*iter)->getFromNeuronID());
                                query.bindValue(2, (*iter)->getToNeuronID());
                                query.bindValue(3, (*iter)->getDelay());
                                query.bindValue(4, (*iter)->getWeight());

                                //Execute query
                                executeQuery(query);

                                //Add connection id to connection
                                int lastInsertID = query.lastInsertId().toInt();
                                if( lastInsertID > LAST_CONNECTION_ID )
                                        throw SpikeStreamException("Database generated connection ID is out of range: " + QString::number(lastInsertID) + ". It must be less than or equal to " + QString::number(LAST_CONNECTION_ID));
                                if(lastInsertID < START_CONNECTION_ID)
                                        throw SpikeStreamException("Insert ID for Connection is invalid.");
                                (*iter)->setID(lastInsertID);

                                //Count number of connections that have been added
                                ++conAddedCntr;
                        }
                }

                //Check that we have added all the connections
                if(!stopThread && (connectionGroup->size() != conAddedCntr) )
                        throw SpikeStreamException("Number of connections added to database: " + QString::number(conAddedCntr) + " does not match size of connection group: " + QString::number(connectionGroup->size()));

                //Update progress
                ++numberOfCompletedSteps;

                #ifdef TIME_PERFORMANCE
                        timer.printTime("Number of buffers: " + QString::number(numConBuffers) + ". Number of connections remaining: " + QString::number(tmpConList.size()) + ". Adding " + QString::number(conCntr) + " connections");
                #endif//TIME_PERFORMANCE
    }

        //Clean up connection groups if task was cancelled.
        if(stopThread){
                connectionGroupIDList.clear();
                foreach(ConnectionGroup* conGrp, connectionGroupList)
                        connectionGroupIDList.append(conGrp->getID());
                deleteConnectionGroups();
        }
}


void NetworkDaoThread::addNeuronGroups(){
        //Reset progress measure
        numberOfCompletedSteps = 0;
        totalNumberOfSteps = neuronGroupList.size();
        progressMessage = "Adding Neurons";

    //Check that parameters have been set correctly
    if(networkID == 0){
                setError("Network ID has not been set.");
                return;
    }
    //Work through the list of neuron groups
        for(QList<NeuronGroup*>::iterator neurGrpIter = neuronGroupList.begin(); neurGrpIter != neuronGroupList.end() && !stopThread; ++neurGrpIter){
                //User friendly pointer to group
                NeuronGroup* neuronGroup = *neurGrpIter;

                //Get information about the neuron group
                NeuronGroupInfo neurGrpInfo = neuronGroup->getInfo();

                //Add the neuron group first
                QString queryStr = "INSERT INTO NeuronGroups (NetworkID, Name, Description, Parameters, NeuronTypeID ) VALUES (";
                queryStr += QString::number(networkID) + ", ";
                queryStr += "'" + neurGrpInfo.getName() + "', '" + neurGrpInfo.getDescription() + "', '" + neurGrpInfo.getParameterXML() + "', ";
                queryStr += QString::number(neurGrpInfo.getNeuronTypeID()) + ")";
                QSqlQuery query = getQuery(queryStr);
                executeQuery(query);

                //Check id is correct and add to neuron group info if it is
                int lastInsertID = query.lastInsertId().toInt();
                if(lastInsertID >= START_NEURONGROUP_ID)
                        neuronGroup->setID(lastInsertID);//Set this on neuron group, not on the copied info
                else{
                        setError("Insert ID for NeuronGroup is invalid.");
                        return;
                }

                //Add entry for neuron group parameters
                //Get name of table
                NeuronType neurType = getNeuronType(neurGrpInfo.getNeuronTypeID());

                //Add parameter table entry for this neuron group
                executeQuery( "INSERT INTO " + neurType.getParameterTableName() + "(NeuronGroupID) VALUES (" + QString::number(neuronGroup->getID()) + ")" );

                //Check neuron group has parameters set and add default parameters if not
                if(!neuronGroup->parametersSet()){
                        QHash<QString, double> tmpParamMap = getDefaultNeuronParameters(neuronGroup->getNeuronTypeID());
                        neuronGroup->setParameters(tmpParamMap);
                }

                //Copy parameters from neuron group into parameter table
                QHash<QString, double> tmpParamMap = neuronGroup->getParameters();
                setNeuronParameters(neuronGroup->getInfo(), tmpParamMap);

                #ifdef TIME_PERFORMANCE
                        PerformanceTimer timer;
                #endif//TIME_PERFORMANCE

                //Build query
                query = getQuery();
                queryStr = "INSERT INTO Neurons (NeuronGroupID, X, Y, Z) VALUES ";
                for(int i=0; i<numNeurBuffers-1; ++i)
                        queryStr += "(?, ?, ?, ?),";
                queryStr += "(?, ?, ?, ?)";
                query.prepare(queryStr);

                //Add neurons to database
                int neurCntr = 0, offset = 0, neurAddedCntr = 0, tmpNeurGrpID = neuronGroup->getID();
                NeuronMap* newNeurMap = new NeuronMap();
                QList<Neuron*> tmpNeurList;
                NeuronIterator endNeurGrp = neuronGroup->end();
                for(NeuronIterator neurIter = neuronGroup->begin(); neurIter != endNeurGrp && !stopThread; ++neurIter){
                        offset = 4 * (neurCntr % numNeurBuffers);

                        //Bind values to query
                        tmpNeurList.append(neurIter.value());
                        query.bindValue(0 + offset, tmpNeurGrpID);
                        query.bindValue(1 + offset, neurIter.value()->getXPos());
                        query.bindValue(2 + offset, neurIter.value()->getYPos());
                        query.bindValue(3 + offset, neurIter.value()->getZPos());

                        //Execute query if we have added a whole number of buffers
                        if(neurCntr % numNeurBuffers == numNeurBuffers-1){
                                executeQuery(query);

                                //Add neuron id to neuron - last insert id is the id of the first neuron in the list of value entries
                                int lastInsertID = query.lastInsertId().toInt();
                                if( (lastInsertID + tmpNeurList.size()) > LAST_NEURON_ID )
                                        throw SpikeStreamException("Database generated neuron ID is out of range: " + QString::number(lastInsertID + tmpNeurList.size()) + ". It must be less than or equal to " + QString::number(LAST_NEURON_ID));
                                if(lastInsertID < START_NEURON_ID)
                                        throw SpikeStreamException("Insert ID for Neuron is invalid.");
                                if(tmpNeurList.size() != numNeurBuffers)
                                        throw SpikeStreamException("Temporary neuron list size " + QString::number(tmpNeurList.size()) + " does not match number of buffers: " + QString::number(numNeurBuffers));

                                //Set neuron IDs and add neurons to new map with the new ID
                                for(int i=0; i<tmpNeurList.size(); ++i){
                                        tmpNeurList.at(i)->setID(lastInsertID + i);
                                        (*newNeurMap)[lastInsertID + i] = tmpNeurList.at(i);
                                }

                                //Count number of neurons that have been added
                                neurAddedCntr += numNeurBuffers;

                                //Clear up list
                                tmpNeurList.clear();
                        }

                        //Keep track of the number of neurons
                        ++neurCntr;
                }

                //Add remaining neurons individually
                if(!tmpNeurList.isEmpty()){
                        query = getQuery();
                        query.prepare("INSERT INTO Neurons ( NeuronGroupID, X, Y, Z) VALUES (?, ?, ?, ?)");
                        for(QList<Neuron*>::iterator neurListIter = tmpNeurList.begin(); neurListIter != tmpNeurList.end(); ++neurListIter){
                                query.bindValue(0, tmpNeurGrpID);
                                query.bindValue(1, (*neurListIter)->getXPos());
                                query.bindValue(2, (*neurListIter)->getYPos());
                                query.bindValue(3, (*neurListIter)->getZPos());

                                //Execute query
                                executeQuery(query);

                                //Add neuron id to neuron
                                int lastInsertID = query.lastInsertId().toInt();
                                if( (lastInsertID) > LAST_NEURON_ID )
                                        throw SpikeStreamException("Database generated neuron ID is out of range: " + QString::number(lastInsertID) + ". It must be less than or equal to " + QString::number(LAST_NEURON_ID));
                                if(lastInsertID < START_NEURON_ID)
                                        throw SpikeStreamException("Insert ID for Neuron is invalid.");
                                (*neurListIter)->setID(lastInsertID);
                                (*newNeurMap)[lastInsertID] = *neurListIter;

                                //Count number of neurons that have been added
                                ++neurAddedCntr;
                        }
                }

                //Check that we have added all the neurons
                if(!stopThread && (neuronGroup->size() != neurAddedCntr))
                        throw SpikeStreamException("Number of neurons added to database: " + QString::number(neurAddedCntr) + " does not match size of neuron group: " + QString::number(neuronGroup->size()));

                //Set the start ID of the neuron group
                NetworkDao networkDao(this->getDBInfo());
                neuronGroup->setStartNeuronID( networkDao.getStartNeuronID(tmpNeurGrpID) );

                #ifdef TIME_PERFORMANCE
                        timer.printTime("Adding neurons. Number of buffers: " + QString::number(numNeurBuffers) + ". Number of neurons remaining: " + QString::number(tmpNeurList.size()) + ". Added " + QString::number(neurAddedCntr) + " neurons");
                #endif//TIME_PERFORMANCE

                //Add the new map to the neuron group. This should also clean up the old map
                neuronGroup->setNeuronMap(newNeurMap);

                //Track progress
                ++numberOfCompletedSteps;
    }

        //Clean up neuron groups if task was cancelled.
        if(stopThread){
                neuronGroupIDList.clear();
                foreach(NeuronGroup* neurGrp, neuronGroupList)
                        neuronGroupIDList.append(neurGrp->getID());
                deleteNeuronGroups();
        }
}


void NetworkDaoThread::deleteConnectionGroups(){
        numberOfCompletedSteps = 0;
        totalNumberOfSteps = connectionGroupIDList.size();
        progressMessage = "Deleting connection groups";

        //Check that network ID is valid
        if(networkID == 0){
                setError("Network ID has not been set.");
                return;
        }

        //Work through the list of connection groups
        foreach(unsigned int conGroupID, connectionGroupIDList){
                executeQuery("DELETE FROM Connections WHERE ConnectionGroupID=" + QString::number(conGroupID) );
                executeQuery("DELETE FROM ConnectionGroups WHERE NetworkID="+ QString::number(networkID) + " AND ConnectionGroupID=" + QString::number(conGroupID) );
                ++numberOfCompletedSteps;
        }

        //Reset list
        connectionGroupIDList.clear();
}


void NetworkDaoThread::deleteNetwork(){
        numberOfCompletedSteps = 0;
        totalNumberOfSteps = 1;
        progressMessage = "Deleting network.";
        executeQuery("DELETE FROM Networks WHERE NetworkID = " + QString::number(networkID));
        networkID = 0;
        numberOfCompletedSteps = 1;
}


void NetworkDaoThread::deleteNeuronGroups(){
        numberOfCompletedSteps = 0;
        totalNumberOfSteps = neuronGroupIDList.size();
        progressMessage = "Deleting neuron groups";

        //Check that network id is valid
        if(networkID == 0){
                setError("Network ID has not been set.");
                return;
        }

        //Work through the list of neuron groups
        foreach(unsigned int neuronGroupID, neuronGroupIDList){
                executeQuery("DELETE FROM Neurons WHERE NeuronGroupID=" + QString::number(neuronGroupID) );
                executeQuery("DELETE FROM NeuronGroups WHERE NetworkID="+ QString::number(networkID) + " AND NeuronGroupID=" + QString::number(neuronGroupID) );
                ++numberOfCompletedSteps;
        }

        //Reset list
        neuronGroupIDList.clear();
}


void NetworkDaoThread::loadConnections(){
        //Reset progress
        numberOfCompletedSteps = 0;
        totalNumberOfSteps = getConnectionCount(connectionGroupList);

    //Work through all the connections to be loaded
    for(QList<ConnectionGroup*>::iterator iter = connectionGroupList.begin(); iter != connectionGroupList.end(); ++iter){

                //Empty current connections in group
                (*iter)->clearConnections();

                //Load connections into group
                unsigned int tmpConGrpID = (*iter)->getID();
                QSqlQuery query = getQuery("SELECT ConnectionID, FromNeuronID, ToNeuronID, Delay, Weight FROM Connections WHERE ConnectionGroupID = " + QString::number(tmpConGrpID));
                executeQuery(query);
                while ( query.next() ) {
                        (*iter)->addConnection(
                                        query.value(0).toUInt(),//ID
                                        query.value(1).toUInt(),//FromNeuronID
                                        query.value(2).toUInt(),//ToNeuronID
                                        query.value(3).toString().toFloat(),//Delay
                                        query.value(4).toString().toFloat()//Weight
                        );

                        //Track progress
                        ++numberOfCompletedSteps;

                        //Quit if user cancels
                        if(stopThread)
                                return;
                }

                //Load parameters in connection group
                QHash<QString, double> tmpParamMap = getSynapseParameters( (*iter)->getInfo());
                (*iter)->setParameters(tmpParamMap);
    }
}


void NetworkDaoThread::loadNeurons(){
        //Reset progress measure
        numberOfCompletedSteps = 0;
        totalNumberOfSteps = getNeuronCount(neuronGroupList);

    //Work through all the neurons to be loaded
    for(QList<NeuronGroup*>::iterator iter = neuronGroupList.begin(); iter != neuronGroupList.end(); ++iter){

                //Empty current connections in group
                (*iter)->clearNeurons();

                //Get pointer to neuron map
                NeuronMap* tmpNeurMap = (*iter)->getNeuronMap();

                //Load neurons into group
                bool firstTime = true;
                QSqlQuery query = getQuery("SELECT NeuronID, X, Y, Z FROM Neurons WHERE NeuronGroupID = " + QString::number((*iter)->getID()) + " ORDER BY NeuronID");
                executeQuery(query);
                while ( query.next() ) {
                        Neuron* tmpNeuron = new Neuron(
                                        query.value(0).toUInt(),//ID
                                        query.value(1).toString().toFloat(),//X
                                        query.value(2).toString().toFloat(),//Y
                                        query.value(3).toString().toFloat()//Z
                                        );
                        (*tmpNeurMap)[query.value(0).toUInt()] = tmpNeuron;

                        //Store the start neuron id - useful when neurons are stored continuously, which is usually but not always the case
                        if(firstTime){
                                (*iter)->setStartNeuronID(query.value(0).toUInt());
                                firstTime = false;
                        }

                        //Track progress
                        ++numberOfCompletedSteps;

                        //Quit if user cancels
                        if(stopThread)
                                return;
                }

                //Load parameters in neuron group
                QHash<QString, double> tmpParamMap = getNeuronParameters( (*iter)->getInfo());
                (*iter)->setParameters(tmpParamMap);
    }
}


void NetworkDaoThread::setError(const QString& msg){
    errorMessage = msg;
    error = true;
    stopThread = true;
}


void NetworkDaoThread::saveNetwork(){
        #ifdef DEBUG
                cout<<"Saving network."<<endl;
                if(!neuronGroupIDList.isEmpty()){
                        cout<<"Deleting neuron groups with IDs: ";
                        foreach(unsigned int neuronGroupID, neuronGroupIDList){
                                cout<<neuronGroupID<<" ";
                        }
                        cout<<endl;
                }
                if(!connectionGroupIDList.isEmpty()){
                        cout<<"Deleting connection groups with IDs: ";
                        foreach(unsigned int neuronGroupID, connectionGroupIDList){
                                cout<<neuronGroupID<<" ";
                        }
                        cout<<endl;
                }
                if(!neuronGroupList.isEmpty()){
                        cout<<"Adding neuron groups with temporary IDs: ";
                        foreach(NeuronGroup* neuronGroup, neuronGroupList){
                                cout<<neuronGroup->getID()<<" ";
                        }
                        cout<<endl;
                }
                if(!connectionGroupList.isEmpty()){
                        cout<<"Adding connection groups with temporary IDs: ";
                        foreach(ConnectionGroup* conGroup, connectionGroupList){
                                cout<<conGroup->getID()<<" ";
                        }
                        cout<<endl;
                }
        #endif//DEBUG

        progressMessage = "Saving network";

        //Delete neuron and connection groups that have been deleted from the prototype
        deleteNeuronGroups();
        deleteConnectionGroups();

        /* Store link between old IDs and neurons in the groups that we are going to add.
           Also store link between old neuron group IDs and neuron group IDs */
        QHash<unsigned, Neuron*> oldIDNeurMap;
        QHash<unsigned, NeuronGroup*> oldIDNeurGrpMap;
        foreach(NeuronGroup* tmpNeurGrp, neuronGroupList){
                //Store old neuron group ID
                oldIDNeurGrpMap[tmpNeurGrp->getID()] = tmpNeurGrp;

                //Store old neuron IDS
                QHash<unsigned, Neuron*>::iterator endNeurGrp = tmpNeurGrp->end();
                for(QHash<unsigned, Neuron*>::iterator neurIter = tmpNeurGrp->begin(); neurIter != endNeurGrp; ++neurIter){
                        oldIDNeurMap[neurIter.key()] = neurIter.value();
                }
        }

        //Add neuron groups to database, the new IDs wil be stored in the neurons and neuron groups
        addNeuronGroups();

        //Update connections with the new IDs
        foreach(ConnectionGroup* tmpConGrp, connectionGroupList){
                //Update FROM neuron group ID and FROM neuron IDs
                if(oldIDNeurGrpMap.contains(tmpConGrp->getFromNeuronGroupID())){
                        tmpConGrp->setFromNeuronGroupID(oldIDNeurGrpMap[tmpConGrp->getFromNeuronGroupID()]->getID());
                        ConnectionIterator endConGrp = tmpConGrp->end();
                        for(ConnectionIterator conIter = tmpConGrp->begin(); conIter!= endConGrp; ++conIter){
                                //Check FROM neuron ID exists
                                if(oldIDNeurMap.contains(conIter->getFromNeuronID()))
                                        conIter->setFromNeuronID(oldIDNeurMap[conIter->getFromNeuronID()]->getID());
                                else
                                        throw SpikeStreamException("FROM neuron ID missing from old ID neuron map: " + QString::number(conIter->getFromNeuronID()));
                        }
                }
                //Update TO neuron group ID and TO neuron IDs
                if(oldIDNeurGrpMap.contains(tmpConGrp->getToNeuronGroupID())){
                        tmpConGrp->setToNeuronGroupID(oldIDNeurGrpMap[tmpConGrp->getToNeuronGroupID()]->getID());
                        ConnectionIterator endConGrp = tmpConGrp->end();
                        for(ConnectionIterator conIter = tmpConGrp->begin(); conIter!= endConGrp; ++conIter){
                                //Check TO neuron ID exists
                                if(oldIDNeurMap.contains(conIter->getToNeuronID()))
                                        conIter->setToNeuronID(oldIDNeurMap[conIter->getToNeuronID()]->getID());
                                else
                                        throw SpikeStreamException("TO neuron ID missing from old ID neuron map: " + QString::number(conIter->getToNeuronID()));
                        }
                }
        }

        //Add connection groups to the database, the new IDs will be stored in the connection groups
        addConnectionGroups();

        //Store volatile connection groups
        saveTempWeights();
}


void NetworkDaoThread::saveTempWeights(){
        //Reset progress measure
        numberOfCompletedSteps = 0;
        progressMessage = "Saving temporary weights";

        //Calculate number of steps
        for(QList<ConnectionGroup*>::iterator conGrpIter = volatileConnectionGroupList.begin(); conGrpIter != volatileConnectionGroupList.end() && !stopThread; ++conGrpIter)
                totalNumberOfSteps += (*conGrpIter)->size();

        //Work through the list of connection groups
        for(QList<ConnectionGroup*>::iterator conGrpIter = volatileConnectionGroupList.begin(); conGrpIter != volatileConnectionGroupList.end() && !stopThread; ++conGrpIter){
                //Get a pointer to the connection group
                ConnectionGroup* tmpConGrp = *conGrpIter;

                #ifdef TIME_PERFORMANCE
                        PerformanceTimer timer;
                #endif//TIME_PERFORMANCE

                //Build query
                QSqlQuery query = getQuery();
                QString queryStr;
                for(int i=0; i<numConBuffers; ++i)
                        queryStr += "UPDATE Connections SET Weight= ? WHERE ConnectionID = ?;";
                query.prepare(queryStr);

                //Work through the connections
                int conCntr = 0, offset = 0, conAddedCntr = 0;
                QList<Connection*> tmpConList;
                ConnectionIterator endConGrp = tmpConGrp->end();
                for(ConnectionIterator conIter = tmpConGrp->begin(); conIter != endConGrp && !stopThread; ++conIter){
                        offset = 2 * (conCntr % numConBuffers);

                        //Bind values to query
                        tmpConList.append(&(*conIter));
                        query.bindValue(0 + offset, conIter->getTempWeight());
                        query.bindValue(1 + offset, conIter->getID());

                        //Execute query
                        if(conCntr % numConBuffers == numConBuffers-1){
                                executeQuery(query);

                                //Count number of connections that have been added
                                conAddedCntr += numConBuffers;
                                numberOfCompletedSteps = conAddedCntr;

                                //Clear up list
                                tmpConList.clear();
                        }

                        //Keep track of the number of connections
                        ++conCntr;
                }

                //Add remaining connections individually
                if(!tmpConList.isEmpty() && !stopThread){
                        query = getQuery();
                        query.prepare("UPDATE Connections SET Weight= ? WHERE ConnectionID = ?");
                        for(QList<Connection*>::iterator conIter = tmpConList.begin(); conIter != tmpConList.end(); ++conIter){
                                query.bindValue(0, (*conIter)->getTempWeight());
                                query.bindValue(1, (*conIter)->getID());

                                //Execute query
                                executeQuery(query);

                                //Count number of connections that have been added
                                ++conAddedCntr;
                                numberOfCompletedSteps = conAddedCntr;
                        }
                }

                //Check that we have added all the connections
                if(!stopThread && (tmpConGrp->size() != conAddedCntr) )
                        throw SpikeStreamException("Number of connections added to database: " + QString::number(conAddedCntr) + " does not match size of connection group: " + QString::number(tmpConGrp->size()));

                #ifdef TIME_PERFORMANCE
                        timer.printTime("Number of buffers: " + QString::number(numConBuffers) + ". Number of connections remaining: " + QString::number(tmpConList.size()) + ". Adding " + QString::number(conCntr) + " connections");
                #endif//TIME_PERFORMANCE
        }

        //Clean up
        volatileConnectionGroupList.clear();
}