CompositeNeuron.h

Go to the documentation of this file.

#ifndef COMPOSITESPIKINGNEURON_H_
#define COMPOSITESPIKINGNEURON_H_

#include "PCSIMException.h"
#include "SingleThreadSimEngine.h"
#include "SimNetwork.h"
#include "LifNeuron.h"
#include "aEIFNeuron.h"

template<typename BaseNeuron> 
class CompositeNeuron : public BaseNeuron
{
                
public:
        CompositeNeuron(const SimObjectFactory &response)
        {       
                syn_responses.push_back(response.create());
        }
        
        CompositeNeuron(const SimObjectFactory &response,       
                                                 const SimObjectFactory &response2) {
                syn_responses.push_back(response.create());             
                syn_responses.push_back(response2.create());
        }
        
        
        virtual void deepCopy(const SimObject *obj) {
                const CompositeNeuron<BaseNeuron> * comp_nrn = 
                       dynamic_cast<const CompositeNeuron<BaseNeuron> *>(obj);
                syn_responses.clear();
                if (comp_nrn) {         
                        for (unsigned i = 0; i < (unsigned)comp_nrn->getNumberOfSynapses(); ++i) {
                                syn_responses.push_back(comp_nrn->getInnerSynapse(i)->create());
                        }
                }       
                else {
                        throw( PCSIM::Exception( "CompositeNeuron<BaseNeuron>::deepCopy", "Trying to deepCopy a CompositeNeuron<BaseNeuron> SimObject from a SimObject of another type" ) );
                }
        }
        
        virtual ~CompositeNeuron() {
                for (unsigned i = 0; i != (unsigned)syn_responses.size(); ++i) {
                        delete syn_responses[i];
                }
                
        } 
        
        virtual int init(InitializeInfo *ii) {
                for (unsigned i = 0; i < (unsigned)syn_responses.size(); ++i) {
                        syn_responses[i]->outgoing(this);
                        this->incoming(syn_responses[i]);
                }
                return 0;
        }
        
        virtual int reset(double dt)
        {
                for (unsigned i = 0; i < (unsigned)syn_responses.size(); ++i) {
                        syn_responses[i]->reset(dt);                            
                }
                return BaseNeuron::reset(dt);   
        }
        
        virtual int advance(AdvanceInfo const &ai) {
                for (unsigned i = 0 ; i < (unsigned)syn_responses.size(); ++i) {        
                        syn_responses[i]->advance(ai);                  
                }               
                return BaseNeuron::advance(ai);
        }
        
        SimObject *getInnerSynapse(unsigned i) const
        {
                return syn_responses[i];        
        }
        
        unsigned getNumberOfSynapses() const
        {
                return syn_responses.size();    
        }
        
        virtual void insert(const SimObjectFactory & model) {
                syn_responses.push_back(model.create());        
        };
        
        virtual void insert(const SimObjectFactory & model, int n)  {
                for (int i = 0; i < n; ++i)
                        syn_responses.push_back(model.create());
        };
        
        virtual SimObject * getInputTarget(int target_id = 0)
        {
                if (target_id == 0)
                        return this;
                else if (target_id <= (int)syn_responses.size())
                        return syn_responses[target_id - 1];
                else                    
                        return syn_responses[0];
        }
    
    virtual int nSpikeInputPorts() const {return 0;}
    
    virtual int nSpikeOutputPorts() const {return 1;}
    
    virtual int nAnalogInputPorts() const {return 0;}
    
    virtual int nAnalogOutputPorts() const {return 0;}
    
    virtual SimObject::PortType outputPortType(port_t p) const {
        if (p == 0)
                return SimObject::spiking;
        return SimObject::undefined;            
    }
        
protected:
        vector<SimObject *> syn_responses;      
};

#endif /*COMPOSITENEURON_H_*/

---