clizSorter.h

Go to the documentation of this file.

// clizSorter.h -   ClusterLizard header file - Module: Sorter

// Copyright (C) 2013, 2014 Simeon Knieling, M.Sc.
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
//

//Sorter Class

#pragma once
#ifndef _INCLUDE_CLIZSORTER
#define _INCLUDE_CLIZSORTER

#include "clizSave.h"

namespace cliz
{

    class Cluster
    {
    public:
        int             ID;                 //Cluster ID number
        unsigned int    nspk;               //Number of spikes in cluster
        unsigned int    *indices;           //Indices of spikes in cluster
        float           *features;          //All features of spikes in cluster
        float           *representative;    //Representative of cluster (mean features)
        uint64_t        *timestamps;        //Timestamps of spikes in cluster

        Cluster(float *&iRepresentative, int iID, float *&iFeatures, unsigned int *&iIndices, uint64_t *&iTimestamps, unsigned int iNspk);

        void destroy(MemoryManager &memMan);
    };

    struct ClusterArray
    {
        std::vector<Cluster>    cluster;
    };

    struct SorterHandle
    {
        unsigned int                    numSpikesToConsider;                //number of spikes for moving window calculations
        float                           fusionCriteriaParams[10];           //thresholds for fusion criteria of adolescent clusters
        float                           adultFusionCriteriaParams[10];      //thresholds for fusion criteria of adult clusters
        unsigned int                    minSpikes2AdultCluster;             //Number of spikes that a cluster needs to be considered adult
        unsigned int                    numFeatures;                        //Number of features for sorting
        unsigned int                    corrPadding;
        unsigned int                    numAllFeatures;                     //Number of all available features
        uint64_t                        timeUntilForcing;                   //In sample points!
        uint64_t                        forcingDelay;                       //Should forcing be used? If so, at what time (in datapoints) should it start?
        unsigned int                    maxNspk4Forcing;                    //Clusters with more spikes will not be forced into other clusters
        float                           maxDist4Forcing;                    //If the representative of a cluster has a greater distance to the representative of its closest adult cluster, it will not be fused.
        unsigned int                    min_clusters;                       //Minimal number of clusters the algorithm will produce (due to the many small clusters of 1 or 2 spikes, this number doesn't really do much)
    };

    class Sorter
    {
    private:
        SorterHandle                                handle;                 //Parameter handle
        std::vector<IndicesStruct>                  indicesOut;             //Which Modules that receive output from this module need which output?
        std::vector<Save*>                          inputSaveVec;           //Input Saves
        std::vector<Save*>                          outputSaveVec;          //Output Saves

        ClusterArray                                clusArray;              //Array of clusters

        float                                       *featureStd;            //Current Std of all features
        float                                       *featureWeights;        //Current weights of all features
        unsigned int                                *featureIDs;            //Indices of currently selected features

        unsigned int                                *killList;              //List of clusters to kill
        unsigned int                                killListCount;          //Number of clusters in killList
        unsigned int                                nspk;                   //Number of spikes
        unsigned int                                numClusterFusions;      //Number of cluster fusions
        unsigned int                                *clusterFusions;        //Cluster fusions
        unsigned int                                *clusterIDs;            //Cluster IDs

        uint64_t                                    lastSpikeTimestamp;     //Timestamp of last spike
        uint64_t                                    currentTime;            //Current time
        MemoryManager                               memMan;

    public:
        Sorter(SorterHandle iHandle, std::vector<Save*>  &iInputSaveVec, std::vector<Save*> &iOutputSaveVec, std::vector<IndicesStruct> iIndicesOut);

        inline  void    calcDist(float &oDist, unsigned int cluster1, unsigned int cluster2);

        int     fusionPossible(unsigned int idMaster, unsigned int idSlave, float diffCrit);

        void    feedSpikeFeatures(float *iFeatures, uint64_t *iTimestamps, int iNspk);

        void    clusteringLoop(unsigned int newClusters);
        
        void    fuseCluster(unsigned int idMaster, unsigned int idSlave);
        
        void    killCluster(unsigned int iClusterIndex);
        
        void    killTheList();
        
        void    getClusterCount(int &oClusterCount);

        void    threadFunc();

        ~Sorter()
        {
            memMan.free(featureIDs);
            memMan.free(featureStd);
            memMan.free(featureWeights);
            memMan.free(killList);
        }
    };

}

#endif