//genesis
//InputFromFile.g
/*
1. What this file does:
This file has the functions for reading in the input from the file  
into tables in genesis and for connecting these inputs to the synapses
of the cells. The connectInsignalToCell function takes as input
EACH individual cell name (SPcell(1) as oppossed to SPcell) and for that
cell loops through the different synapses in the different compartments
2. What this file does NOT do:
This file does not randomize the connection of the inputs to the synapses.
That function is performed in SimFile.g

NOTE: The files are generated in MATLAB with the ASSUMPTION that we are hooking
up every single input in the network. So at a minimum we must have enough inputs 
for the synapses described in the nsynapses file.

Please note that readInputFromFile assumes that the files are numbered
from 1 and up, whereas the input naming convention starts from 0
*/
////////////////////////////////////////////////////////////////////////////////

//Connect the files for the unique inputs from the MATLAB files to the timetables.

function readInputFromFile(net, inputName, filePath, SynNum, Unique)

    str inputName
    str filePath
    int SynNum
    int Unique
    

  if ({net}=="FS")
     str inputBasePath = "/input"
  else
  end
  if ({net}=="SP")
     str inputBasePath = "/input2" 
  else
  end
    
    int ctr
    
    str inputPath = {inputBasePath}@"/"@{inputName}

    if({tmax} == 0)
//        echo "readInputFromFile: Error, maxTime is set to 0"
        quit
    end

    if(!{exists {inputBasePath}})
        create neutral {inputBasePath}
    end

//    echo "Reading from "{filePath}" files 1 to "{SynNum}
//    echo "Connecting input to "{inputPath}[0]" to "[{{SynNum}-1}]
    
    pushe {inputBasePath}

    for(ctr = 0; ctr < {Unique}; ctr = {ctr + 1})

        create timetable {inputName}[{ctr}]
        setfield {inputName}[{ctr}] maxtime {maxTime} \
                                    method 4 \
                                    act_val 1.0 \ 
                                    fname {filePath}{{ctr}+1}".txt" //connect input from file with filename given in filepath 

        call {inputName}[{ctr}] TABFILL

        create spikegen {inputName}[{ctr}]/spikes

        setfield {inputName}[{ctr}]/spikes \
                 output_amp 1 thresh 0.5 abs_refract 0.0001

        addmsg {inputName}[{ctr}] {inputName}[{ctr}]/spikes \
               INPUT activation
        
    end
   
    pope

end

//Connect the files for the duplicate inputs

function readInputdFromFile(net,inputName, filePath_d, Dups)

    str inputName    
	str filePath_d
	int Dups
   if ({net}=="FS")
     str inputBasePath = "/input"
  else
     str inputBasePath = "/input2" 
  end

    int ctr
//input name has cell number embedded and dup vs unique
    str inputPath = {inputBasePath}@"/"@{inputName}

//echo "Connecting duplicate input to "{inputPath}[0]" to "[{{nAMPA}-1}]

   pushe {inputBasePath}

//input name (inputPath) will not have a cell number
    for(ctr = 0; ctr < {Dups}; ctr = {ctr + 1})
        
        create timetable {inputName}[{ctr}]
        setfield {inputName}[{ctr}] maxtime {maxTime} \
                                    method 4 \
                                    act_val 1.0 \ 
                                    fname {filePath_d}{{ctr}+1}".txt" //Call the files generated to provide duplicate inputs

        call {inputName}[{ctr}] TABFILL

        create spikegen {inputName}[{ctr}]/spikes

        setfield {inputName}[{ctr}]/spikes \
                 output_amp 1 thresh 0.5 abs_refract 0.0001

        addmsg {inputName}[{ctr}] {inputName}[{ctr}]/spikes \
               INPUT activation
        
    end	
  pope

end



//////////////////////////////////////////////////////////////////////////////
//
// Connects insignal objects to the synapses of the cells
//
//////////////////////////////////////////////////////////////////////////////

//Function to randomly select the input file names from the tabchannels

function rannum_unique (tablename)
  
  str tablename
  int i
  int last={getfield {tablename} X_A->xmax}  //get the index of last element from the value of xmax
  //echo "last=" {last}
  int index={ round {rand -0.499 {last+0.499}} }  //choose a random index
  int filenum={getfield {tablename} X_A->table[{index}]}  //return filenum associated with index selected above
  setfield {tablename} X_A->table[{filenum}] {getfield {tablename} X_A->table[{last}]} //replace selected filenum with last element
  setfield {tablename} X_A->xmax {last-1} //set xmax to be {last-1}
  return {filenum}

end

//connects the timetable input to the SP network

function connectInsignalToCell(net,NetworkName,InsignaluName,InsignaldName,channelType,nu,nd,f_weight,s_weight)
  
    str NetworkName, InsignaluName, InsignaldName, channelType, compName, compN
    int insignalCtr = 0, dCtr, nsyn, nu, nd, i, tablemax, nsyn_allowed, f_weight, s_weight, nu_syn
    if ({net}=="FS")
    str inputBasePath = "/input"
    else
    str inputBasePath = "/input2"
    end
    // str networkBasePath = "/{net}network" 
    //input name has cell number embedded and dup vs unique
    str InsignaluPath = {inputBasePath}@"/"@{InsignaluName}
    str InsignaldPath = {inputBasePath}@"/"@{InsignaldName}
    //str NetworkPath =  {networkBasePath}@"/"@{NetworkName}
    str NetworkPath =  {NetworkName}   

//      echo "The function connectInsignal has been called"
//      echo "Networkname=" {NetworkName} {InsignaluName} {InsignaldName}
 
   create tabchannel inp  //create a table to contain the indices of the filenames
   disable inp
   if ({channelType}=="NR2A")
      tablemax = {getglobal nAMPA_{net}}
   else
      tablemax = {getglobal n{channelType}_{net}}  //set tablemax to be number of synaptic inputs
   end
   call inp TABCREATE X {{tablemax}-1} 0 {{tablemax}-1}
   for (i=0; i<{nu}; i={i+1})
       setfield inp X_A->table[{i}] {i} //indices of unique filenames
       setfield inp X_B->table[{i}] 0  //0 represents unique indices
   end
 
   for (i=0; i<{nd}; i={i+1})
       setfield inp X_A->table[{i+nu}] {i}  //indices of duplicate filenames
       setfield inp X_B->table[{i+nu}] 1    //1 represents duplicate indices
   end 
  
    // Connect to all compartments till we reach synapse number
                 int c=0
                 foreach compName ({el {NetworkPath}/##[TYPE=compartment]}) 
                      
                        c = {c}+1
                        compN = {getpath {compName} -tail}
                        nsyn = {getfield {compName}/{channelType} nsynapses}
                        if ({channelType}=="AMPA" || {channelType}=="NR2A")
                           nsyn_allowed = {getfield {compName} nsynallowed_a} 
                        elif ({channelType}=="GABA")
                           nsyn_allowed = {getfield {compName} nsynallowed_g}
                        else
                        end
                       // echo "compartment="{compN}
                        while ({nsyn}<{nsyn_allowed})
                                //echo "nsyn="{nsyn}
                               // echo "nsyn_allowed="{nsyn_allowed} 
                                insignalCtr = {rannum_unique inp}  //select index randomly using function above
				if ({getfield inp X_B->table[{insignalCtr}]}==1) //if duplicate then addmsg from duplicate filenames
                                     addmsg {InsignaldPath}[{insignalCtr}]/spikes {compName}/{channelType} SPIKE
				else
                                     addmsg {InsignaluPath}[{insignalCtr}]/spikes {compName}/{channelType}  SPIKE //or unique
                                end  
                                nsyn = {getfield {compName}/{channelType} nsynapses}  //update nsyn for while check
                                nu_syn={nsyn}-1
                                if ({channelType}=="GABA")   
                                    setfield {compName}/{channelType} synapse[{nu_syn}].weight {f_weight}
                                else
                                    setfield {compName}/{channelType} synapse[{nu_syn}].weight {getglobal weight_C_{net}}
                                end
			end
                if ({c}==(1+{getglobal prim_dend_num_{net}}+{getglobal sec_dend_num_{net}}+{getglobal tert_dend_num_{net}}))
                  c=0
                else
                end
                end
call inp TABDELETE
delete inp
//reclaim    //reclaim occupied space
end                    

function connectInsignalToCell_SP(net,NetworkName,InsignaluName,InsignaldName, channelType,nu,nd,f_weight,s_weight)
  
     str NetworkName, InsignaluName, InsignaldName, channelType, compName, compN
    int insignalCtr = 0, dCtr, nsyn, nu, nd, i, tablemax, nsyn_allowed, f_weight, s_weight, nu_syn
    if ({net}=="FS")
    str inputBasePath = "/input"
    else
    str inputBasePath = "/input2"
    end
    // str networkBasePath = "/{net}network" 
    //input name has cell number embedded and dup vs unique
    str InsignaluPath = {inputBasePath}@"/"@{InsignaluName}
    str InsignaldPath = {inputBasePath}@"/"@{InsignaldName}
    //str NetworkPath =  {networkBasePath}@"/"@{NetworkName}
    str NetworkPath =  {NetworkName}   

//      echo "The function connectInsignal has been called"
//      echo "Networkname=" {NetworkName} {InsignaluName} {InsignaldName}
 
   create tabchannel inp  //create a table to contain the indices of the filenames
   disable inp
   if ({channelType}=="NR2A")
      tablemax = {getglobal nAMPA_{net}}
   else
      tablemax = {getglobal n{channelType}_{net}}  //set tablemax to be number of synaptic inputs
   end
   call inp TABCREATE X {{tablemax}-1} 0 {{tablemax}-1}
   for (i=0; i<{nu}; i={i+1})
       setfield inp X_A->table[{i}] {i} //indices of unique filenames
       setfield inp X_B->table[{i}] 0  //0 represents unique indices
   end
 
   for (i=0; i<{nd}; i={i+1})
       setfield inp X_A->table[{i+nu}] {i}  //indices of duplicate filenames
       setfield inp X_B->table[{i+nu}] 1    //1 represents duplicate indices
   end 
  
    // Connect to all compartments till we reach synapse number
                 int c=0
                 foreach compName ({el {NetworkPath}/##[TYPE=compartment]}) 
                      
                        c = {c}+1
                        compN = {getpath {compName} -tail}
                        nsyn = {getfield {compName}/{channelType} nsynapses}
                        if ({channelType}=="AMPA" || {channelType}=="NR2A")
                           nsyn_allowed = {getfield {compName} nsynallowed_a} 
                        elif ({channelType}=="GABA")
                           nsyn_allowed = {getfield {compName} nsynallowed_g}
                        else
                        end
                       // echo "compartment="{compN}
                        while ({nsyn}<{nsyn_allowed})
                                //echo "nsyn="{nsyn}
                               // echo "nsyn_allowed="{nsyn_allowed} 
                                insignalCtr = {rannum_unique inp}  //select index randomly using function above
				if ({getfield inp X_B->table[{insignalCtr}]}==1) //if duplicate then addmsg from duplicate filenames
                                     addmsg {InsignaldPath}[{insignalCtr}]/spikes {compName}/{channelType} SPIKE
				else
                                     addmsg {InsignaluPath}[{insignalCtr}]/spikes {compName}/{channelType}  SPIKE //or unique
                                end  
                                nsyn = {getfield {compName}/{channelType} nsynapses}  //update nsyn for while check
                                nu_syn={nsyn}-1
                                if ({channelType}=="GABA")   
                                    setfield {compName}/{channelType} synapse[{nu_syn}].weight {f_weight}
                                else
                                    setfield {compName}/{channelType} synapse[{nu_syn}].weight {getglobal weight_C_{net}}
                                end
			end
                if ({c}==(1+{getglobal prim_dend_num_{net}}+{getglobal sec_dend_num_{net}}+{getglobal tert_dend_num_{net}}))
                  c=0
                else
                end
                end
call inp TABDELETE
delete inp
//reclaim    //reclaim occupied space
end          

//////////////////////////////////////////////////////////////////////////////