#ifndef _HPP_NORMALIZE
#define _HPP_NORMALIZE

#include "simelement.hpp"
#include "libcsim.hpp"
#include "connection.hpp"

/*! \brief AbstractNormalize
 *
 */
class AbstractNormalize: public SimElement
{
protected:
     bool RewiringOn;
     float IncommingConnectivity; // for rewiring
     float SynDelThreshold; // for rewiring
     float InitialWeights; // for rewiring
public: 
     AbstractNormalize();
     virtual void SetRewiring(float IncommingConnectivity, float SynDelThreshold, float InitialWeights);
     virtual void SetRewiringOff();
};


/*! \brief Normalize
 *
 */
class Normalize: public AbstractNormalize
{
protected:
     layer* Target;
     TconnectionList ConList;
     int NTarget;
public:
     Normalize();
     virtual int AddConnection(connection* newcon);
     virtual int proceede(int =0);
     virtual int prepare(int =0);          
     virtual int WriteSimInfo(fstream &fw);
     virtual int WriteSimInfo(fstream &fw, const string &ChildInfo);
};

/*! \brief FiringRateNormalize
 *
 */
class FiringRateNormalize: public Normalize
{
protected:
     float* PostSynFirePot;
     int* PostSynLastFirings;
     float Tau;
     float NormThreshold;
     float NormFactor;
public:
     FiringRateNormalize(float _NormThresh=1, float _NormFactor=1, float _Tau=40);
     virtual int AddConnection(connection* newcon);
     virtual int proceede(int =0);
     virtual int prepare(int =0);          
};

/*! \brief FiringRateNormalize2
 *
 */
class FiringRateNormalize2: public Normalize
{
protected:
     int* PostSynLastFirings;
     float Tau;
     float* NormLut;
     int NormLutN;
     float MaxNormFactor;
     float NormDeltaT;
     float NormFactor;
     float NormFrequency;
public:
     FiringRateNormalize2(float NormFrequency=1, float NormFactor=0.001, float MaxNormFactor=10);
     virtual int AddConnection(connection* newcon);
     virtual int proceede(int =0);
     virtual int prepare(int =0);          
     virtual int WriteSimInfo(fstream &fw);
};


/*! \brief ConstSFNormalize
 *
 */
class ConstSFNormalize: public Normalize
{
protected:
     float* PostSynFirePot;
     int* PostSynLastFirings;
     float Tau;
     float NormThreshold;
     float NormFactor;
     float DesiredFirePot;
public:
     ConstSFNormalize(float _DesiredSpikeFreq=30, float _NormFactor=0.01, float _Tau=40);
     virtual int AddConnection(connection* newcon);
     virtual int proceede(int =0);
     virtual int prepare(int =0);          
     virtual int WriteSimInfo(fstream &fw);
};


/*! \brief ConstSumNormalize
 *
 */
class ConstSumNormalize: public Normalize
{
protected:
     float* PostSynWeightSum;
     float WeightSum;
     int* PostSynLastFirings;
     bool quadratic;
public:
     ConstSumNormalize(float _WeightSum=1, bool _quadratic=false);
//     virtual int AddConnection(connection* newcon);
     virtual int proceede(int =0);
     int NormalizeAll();     
     void CalcInitWeightSum();  //calculate weight sum from initial weight distribution
     float GetWeightSum();
     int SetWeightSum(float NewWeightSum);
     virtual int WriteSimInfo(fstream &fw);
     //    virtual int prepare(int =0);          
};

/*! \brief NormalizePsp
 *
 */
class NormalizePsp: public Normalize
{
protected:
     int* PostSynLastFirings;
     float* PspPot;
     float NormThreshold;
     float NormFactor;
public:
     NormalizePsp(float _NormThresh=1, float _NormFactor=0.95);
     virtual int AddConnection(connection* newcon);
     virtual int proceede(int =0);
     virtual int WriteSimInfo(fstream &fw);
};

#endif /*_HPP_NORMALIZE */