// $Id: constants.g,v 16.1 2000/03/02 14:43:39 ajay Exp $
// genesis 2.1  
// constants.g  HIPPO Model   -ak

// Constants used in the hippo model.

//*************************************************
// general constatnts
//**************************************************

float	dt = 1.0e-4 // sec. sim-clock-step.
float	refresh_factor 	= 1.0
int	num_seq = 1 // number of sequences presented to network
int	do_recall_in_lrs = 1 // when set to 1, lrs does both learn and recall, else only learn.
float	num_aff_pat	= 5	// number of patterns comprising a sequence
float	aff_input_interval = 100e-3 // 100 ms interval between patterns

float	learn_rate = 200 // 65, 1300 weight_change_rate of AMPA hebbsynchans for pyr_to_pyr connections
float	EC2pyr_learnrate = 5000 // learn_rate for EC_to_pyr synapses (pyr/apical_2/AMPA_channel)
float	EC2pyr_maxweight = 32.8 // 1.345 just subthreshold for tau2 = 100 ms. Peaks in ~10 ms latency.
float	EC2pyr_recall_maxwt_ILN = 0.6 // 0.6 EC_to_pyr (ILN only)  weights set to this just prior to recall
float	EC2pyr_recall_maxwt_bg = 0.6 // 0.6 EC_to_pyr (bg only)  weights set to this just prior to recall
// float non_ILN_learn_rate = 1000
// float ILN_learn_rate = 30000

float	EC_ILN_depol = 0.276e-8 // depol current into ILN cells during recall, ala EC input.
float	ILN_K_A = 8.0e3 // value of K_A of ILN pyr cells
float	expand_recall_time = 145e-3 // additional time for EC input to plateau during recall
float	recall_p2p_syndelay = 0.002 // p_to_p synaptic delay (sec) during recall to reduce jitter 
float	recall_gaba_wt_mult = 0.2 //  pyr_gaba(a,b)_wt multiplied by this factor prior to recall
float	recall_exc_wt_mult = 10.0 //  pyr_ampa_wt of potentiated synapses multiplied by this factor 
				 //  prior to recall
// float	pyr2ILN_maxweight = 5

float	learn_time  = {num_aff_pat * 0.1}  // 100ms learning time for each pattern in sequence
float	recall_time = 0.1 + expand_recall_time
float	gap_time = 0e-3 // time between 2 learn phases in disamb. task. Note, sawtooth depol on.
float	tmax // total simulation time in sec
float	num_ILN // number of pyr cells coding input. 5 per pattern. pyr[0-(num_ILN-1)].

if (num_seq == 1)
  num_ILN = num_aff_pat * 5
  if (do_recall_in_lrs == 1)
    tmax = learn_time + recall_time 
  else
    tmax = learn_time
  end
elif (num_seq == 2) // for disambiguation task
  num_ILN = ((num_aff_pat - 1) * 2 * 5) + (1*5) // for 2 forked sequences, 1-5; 1,6-9. 5cells/pat.
  if (do_recall_in_lrs == 1)
    tmax = {learn_time} + {gap_time} + {learn_time} + {recall_time}
  else
    tmax = learn_time + {gap_time} + {learn_time}
  end
else
  echo num_seq has to be 1 or 2
end
 
float	background_rate = 0 // 20Hz rate should make 10% of all pyr cells fire at any time
float	spike_threshold_value = -15e-3 // -20 mV

float	bg_depol_current = 0.54e-9 // 0.42e-9 max. amp. of current injected to bg neurons during learning
float	bg_depol_plateau_period = 10e-3 // 10e-3 duration (in sec) of plateau period of bg depol current 
float	bg_depol_ramp_period = 13e-3 // 13e-3 duration of ramping current input to bg cells
// float	bg_steady_depol = -70e-3 // initial Vm of bg cells set to this value

//*************************************************************
// performance measure constants
//*************************************************************

// RCL_ACC is main performance measure computed in gpm3 (control.g)
// It measures the accuracy of recalling a stored sequence.
float	RCL_ACC // recall accuracy

// Following 4 are computed in compute_bg_perc and measure variability of background
// firing across the sequence
float	mean_perc_bg // mean of perc_bg_fired across entire sequence
float	SD_perc_bg // SD of above
float	mean_diff_perc_bg // mean of absolute diff of perc_bg_fired between successive epochs in sequence
float	SD_diff_perc_bg // SD of above

//***************************************************
// Pyr cell constants
//***************************************************

float	CA3_SEPX = 20e-6
float	CA3_SEPY = 20e-6
float	CA3_SEPZ = 1e-3
int	CA3_NX = 20
int	CA3_NY = 10
float   CA3_xmin = {-CA3_NX * CA3_SEPX / 2}
float   CA3_ymin = {-CA3_NY * CA3_SEPY / 2}
float   CA3_xmax = {CA3_NX * CA3_SEPX / 2}
float   CA3_ymax = {CA3_NY * CA3_SEPY / 2}
float   CA3_zoffset = {10 * CA3_SEPZ}
int     NPYR = {CA3_NX * CA3_NY}

//***************************************************
// EC cell constants. Each EC cell represents one sequence that is learnt.
// Each EC cell is connected to all ILN pyr cells.
//***************************************************

float	EC_SEPX = 20e-6
float	EC_SEPY = 20e-6
float	EC_SEPZ = 1e-3
int	EC_NX = 2 // max. 2 sequences, EC[0] and EC[1].
int	EC_NY = 1
float   EC_xmin = {-EC_NX * EC_SEPX / 2}
float   EC_ymin = {-EC_NY * EC_SEPY / 2}
float   EC_xmax = {EC_NX * EC_SEPX / 2}
float   EC_ymax = {EC_NY * EC_SEPY / 2}
float   EC_zoffset = {10 * EC_SEPZ}
int     NEC = {EC_NX * EC_NY}

//********************************************
// int_a constants
//*******************************************

float	INTA_SEPX = 20e-6
float	INTA_SEPY = 20e-6
float	INTA_SEPZ = 1e-3
int	INTA_NX = 10
int	INTA_NY = 4
float   INTA_xmin = {-INTA_NX * INTA_SEPX / 2}
float   INTA_ymin = {-INTA_NY * INTA_SEPY / 2}
float   INTA_xmax = {INTA_NX * INTA_SEPX / 2}
float   INTA_ymax = {INTA_NY * INTA_SEPY / 2}
float   INTA_zoffset = {10 * INTA_SEPZ}
int     NINTA = {INTA_NX * INTA_NY}

//********************************************
// int_b constants
//*******************************************

float	INTB_SEPX = 20e-6
float	INTB_SEPY = 20e-6
float	INTB_SEPZ = 1e-3
int	INTB_NX = 10
int	INTB_NY = 4
float   INTB_xmin = {-INTB_NX * INTB_SEPX / 2}
float   INTB_ymin = {-INTB_NY * INTB_SEPY / 2}
float   INTB_xmax = {INTB_NX * INTB_SEPX / 2}
float   INTB_ymax = {INTB_NY * INTB_SEPY / 2}
float   INTB_zoffset = {10 * INTB_SEPZ}
int     NINTB = {INTB_NX * INTB_NY}

//********************************************
// aff_layer constants
//*******************************************

float	AFF_SEPX = 20e-6   // separation of cells in x direction in meters
float	AFF_SEPY = 20e-6   // separation of cells in y direction in meters
int	AFF_NX = 1   // number of cells in x direction
int	AFF_NY = 75  // for 15 patterns with 5 cells per pattern
float   aff_xmin = {-AFF_NX * AFF_SEPX / 2}
float   aff_ymin = {-AFF_NY * AFF_SEPY / 2}
float   aff_xmax = {AFF_NX * AFF_SEPX / 2}
float   aff_ymax = {AFF_NY * AFF_SEPY / 2}
int	GATE_NX  = 1
int	GATE_NY  = 15   // one gate pulsegen for each group of 5 aff cells


//************************************************************
// Save routine constants
//************************************************************

str datadir = "/export/users/ajay/sim-gen/test2/data" // output directory
float npyr_to_save = 10 // spike activity of pyr[0]-pyr[99] saved
float ninta_to_save = 1 // spike activity of int_a[0] saved
float nintb_to_save = 1 // spike activity of int_b[0] saved

//*****************************************************************
// probability of connections between populations
//*****************************************************************

float  p_to_p = 0.1 // 0.1 pyr_to_pyr
float  p_to_i = 0.3 // 0.3 pyr_to_int_a, pyr_to_int_b
float  i_to_p = 0.3 // 0.3 int_a_to_pyr, int_b_to_pyr
float  i_to_i = 0.0 // 0.0 int_a_to_int_[ab], int_b_to_int_[ab]

//*********************************************************************************
// initial weights of synapses (only ampa onto pyr is changeable through learning)
//*********************************************************************************


float pyr_ampa_wt   = 0.3  // 0.3 ampa synapse onto pyr cell (hebbsynchan)
float pyr_nmda_wt   = 0.01  // 0.025 nmda synapse onto pyr cell
float pyr_gabaa_wt  = 0.1   // 0.1 GABAa synapse onto pyr cell
float pyr_gabab_wt  = 0.001   // 1.0 GABAb synapse onto pyr cell
float pyr_ffi_wt    = 0.0  // ffi synapse onto pyr cell
float pyr_EC_wt	    = 0.0  // EC synapse onto pyr cell

float inta_ampa_wt  = 1.4   // ampa synapse onto int_a cell
float inta_gabaa_wt = 0.0   // GABAa synapse onto int_a cell
float inta_gabab_wt = 0.0   // GABAb synapse onto int_a cell

float intb_ampa_wt  = 1.0 // ampa synapse onto int_b cell
float intb_gabaa_wt = 0.0  // GABAa synapse onto int_b cell
float intb_gabab_wt = 0.0   // GABAb synapse onto int_b cell

float ffi_delay = 10e-3 // delay from ff interneuron to all pyr cells.


//************************************************************
// Synaptic delay constants  (includes axonal conduction time)
//************************************************************

float CABLE_VEL = 0.5  // 0.5 scale factor = 1/(cable velocity) sec/meter (used in planardelay)

// delays reset in control.g to values given below by function init_syn_delays

float p_to_p_syndelay	= 0.002 // 2 ms from pyr to pyr cells. 1 ms for others.
float p_to_i_syndelay	= 0.001
float i_to_p_syndelay	= 0.001 
float i_to_i_syndelay	= 0.001 
float EC_to_p_syndelay	= 0.001 // delay of connection from EC to pyr cells 


//**********************************************
// Channel constants
//***********************************************

float EREST_ACT  = -0.060            // resting potential
float VmSTART = {EREST_ACT - 0.01} // initVm (of pyr cells only) set to this value in pyramidal.g	
float ENA        = 0.115 + EREST_ACT // 0.055
float EK         =-0.015 + EREST_ACT // -0.075
float ECA        = 0.140 + EREST_ACT // 0.080
float SOMA_A     = 3.320e-9          // soma area in square meters

float EK_INT     = EREST_ACT 
float SOMA_A_INT = 1.430e-9          // soma area in square meters