---

layer.h

/***************************************************************************
                          layer.h  -  description
                             -------------------
    begin                : Wed Apr 11 2001
    copyright            : (C) 2001 by Matt Grover
    email                : mgrover@amygdala.org
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef LAYER_H
#define LAYER_H


using namespace std;
#include <vector>
#include <string>
#include <amygdala/neuron.h>
#include <amygdala/network.h>
#include <amygdala/types.h>

class Network;
class Neuron;



class Layer {
public:
    Layer();
    ~Layer();

    friend class Network;

    void AddNeuron(Neuron* nrn);

    void AddNeuronVector(vector<Neuron*> nrnVec);
    
    void LayerName(string name) { layerName = name; }
    
    string LayerName() { return layerName; }
    
    void SetLayerId(unsigned int id) { layerId = id; }
    
    unsigned int LayerId() { return layerId; }
    
    void SetLayerType(LayerType ltype) { layerType = ltype; }
    
    LayerType GetLayerType() { return layerType; }
    
    void SetPercentInhibitory( float percent );
    
    bool ConnectLayers(Layer* output, UniConnectType parms, float pctInhibitory = 0.0);
    
    bool ConnectLayers(Layer* output, GaussConnectType parms, float pctInhibitory = 0.0);
    
    bool SetLayerConstants(LayerConstants lconst);
    
    LayerConstants GetLayerConstants();
    
    void SetSynapticDelay(AmTimeInt delay) { synapticDelay = delay; }

    AmTimeInt GetSynapticDelay() const { return synapticDelay; }

    /*
     * Types and members refering to vector
     */
    
    unsigned int size() { return nrnLayer.size(); }

    typedef vector<Neuron*>::iterator iterator;
    typedef vector<Neuron*>::const_iterator const_iterator;
    typedef vector<Neuron*>::reverse_iterator reverse_iterator;
    typedef vector<Neuron*>::const_reverse_iterator const_reverse_iterator;

    iterator begin() { return nrnLayer.begin(); }
    iterator end() { return nrnLayer.end(); }
    const_iterator begin() const { return nrnLayer.begin(); }
    const_iterator end() const { return nrnLayer.end(); }
    reverse_iterator rbegin() { return nrnLayer.rbegin(); }
    reverse_iterator rend() { return nrnLayer.rend(); }
    const_reverse_iterator rbegin() const { return nrnLayer.rbegin(); }
    const_reverse_iterator rend() const { return nrnLayer.rend(); }

    Neuron* operator[](unsigned int& index) { return nrnLayer[index]; }
    
protected:
    void SetLayerParent(Network* parent);
    inline bool ConnectionInhibitory(float& pctInhibitory);
    
    vector<Neuron*> nrnLayer;
    Network* parentNet;
    string layerName;
    LayerType layerType;
    unsigned int layerId;

    // Defaults for member neurons
    float learningConst;
    float memTimeConst;
    float synTimeConst;
    float restPtnl;
    float thresholdPtnl;

    bool constantsSet;
    float percentInhib;
    AmTimeInt synapticDelay;

};

#endif

---