Network model with neocortical architecture (Anderson et al 2007,2012; Azhar et al 2012)

 Download zip file 
Help downloading and running models
Accession:141507
Architecturally realistic neocortical model using seven classes of excitatory and inhibitory single compartment Hodgkin-Huxley cells. This is an addendum to ModelDB Accession # 98902, Studies of stimulus parameters for seizure disruption (Anderson et al. 2007). Wiring is adapted from the minicolumn hypothesis and incorporates visual and neocortical wiring data. Simulation demonstrates spontaneous bursting onset and cessation. This activity can be induced by random fluctuations in the surrounding background input.
References:
1 . Anderson WS, Kudela P, Cho J, Bergey GK, Franaszczuk PJ (2007) Studies of stimulus parameters for seizure disruption using neural network simulations. Biol Cybern 97:173-94 [PubMed]
2 . Anderson WS, Kudela P, Weinberg S, Bergey GK, Franaszczuk PJ (2009) Phase-dependent stimulation effects on bursting activity in a neural network cortical simulation. Epilepsy Res 84:42-55 [PubMed]
3 . Anderson WS, Azhar F, Kudela P, Bergey GK, Franaszczuk PJ (2012) Epileptic seizures from abnormal networks: why some seizures defy predictability. Epilepsy Res 99:202-13 [PubMed]
4 . Azhar F, Anderson WS (2012) Predicting single-neuron activity in locally connected networks. Neural Comput 24:2655-77 [PubMed]
Model Information (Click on a link to find other models with that property)
Model Type: Realistic Network;
Brain Region(s)/Organism:
Cell Type(s): Neocortex V1 L6 pyramidal corticothalamic GLU cell; Neocortex V1 L2/6 pyramidal intratelencephalic GLU cell; Neocortex V1 interneuron basket PV GABA cell; Neocortex fast spiking (FS) interneuron;
Channel(s): I A; I K; I K,leak; I K,Ca; I Sodium; I Calcium;
Gap Junctions:
Receptor(s): AMPA; Gaba;
Gene(s):
Transmitter(s):
Simulation Environment: C or C++ program;
Model Concept(s): Bursting; Epilepsy; Vision;
Implementer(s):
Search NeuronDB for information about:  Neocortex V1 L6 pyramidal corticothalamic GLU cell; Neocortex V1 L2/6 pyramidal intratelencephalic GLU cell; Neocortex V1 interneuron basket PV GABA cell; AMPA; Gaba; I A; I K; I K,leak; I K,Ca; I Sodium; I Calcium;
/
AndersonEtAl2011
readme.txt
0.net
0.par *
0.stim
0.sub
Ca_sum.c
clust_cn.c
clust_cn.h *
crl.c *
jhist.c *
link_sort.c *
lnet.h
mkhist.c *
mklink.c
mknode.c
mkpar.c *
Movie1.mpg
netclustwacnmdadiff.c
nodes.16
rnetcolumn *
rnetcolumn.txt *
sublink.c *
                            
#define RISC
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <time.h>
//#include <curses.h>
#include "lnet.h"

#define randomm(num) (int)((double)num*(double)rand()/((double)(RAND_MAX+1.0)))
#define randomize()     srand((unsigned)time(NULL))

#define randoml(num) (int)((double)num*drand48())
#define randomizel()     srand48((long int)time(NULL))


long filelength(int handle)
{
   FILE *fp;
   long int curpos, length;
   if((fp=fdopen(handle,"r+"))==NULL)
    return(-1);
   curpos = ftell(fp);
   fseek(fp, 0L, SEEK_END);
   length = ftell(fp);
   fseek(fp, curpos, SEEK_SET);
   return length;
}

long filelengthf(char *fil)
{
   FILE *fp;
   long int curpos, length;
   if((fp=fopen(fil,"r+"))==NULL)
    return(-1);
   curpos = ftell(fp);
   fseek(fp, 0L, SEEK_END);
   length = ftell(fp);
   fseek(fp, curpos, SEEK_SET);
   return length;
}

char konfig[5];


int main(int argc, char *argv[])
{

FILE *fp;
int fo,i,k,rez,update=0;
int kk;
long len;
struct PARAMETERS *par;
PARAMETER_INDEX N_class;
char opc[9], buf[100];
float   dt = 1000*DELTA_T;
//static VAR dt=.01;
static VAR onset_exc=0.5,decay_exc=3.0;
static VAR onset_inh=0.5,decay_inh=3.0;
VAR tau_o_exc[NEXCCLASS],tau_d_exc[NEXCCLASS];
VAR tau_o_inh[NINHCLASS],tau_d_inh[NINHCLASS];
VAR tmax_exc[NEXCCLASS],tmax_inh[NINHCLASS],Imax_exc[NEXCCLASS],Imax_inh[NINHCLASS];
VAR robol;
SPIKE_INTERVAL *tab_del=NULL;
VAR delay_ms=1.0;
char str[10]="";
char name[5],choose;
char *file_name;
VAR Amp=0.00655;

int get_cfg(char *);
int get_par(char *,int);

VAR improve_par(char *,VAR, char *);

file_name=calloc(1,sizeof(char));

if(argc<2)
 {
  printf("cfg file? : ");
  scanf("%s",file_name);
  getchar();
 }
else
  strcpy(file_name,argv[1]);

if(get_cfg(file_name)==-1)
 {printf("cannot read config from %s.cfg\n",file_name);return(-1);}
if((rez=get_par(file_name,1))<0)
 {
  printf("cannot read the number of neurons from %s.cfg\n",file_name);
  return(-1);
 }
if(rez>0)
 N_class=(PARAMETER_INDEX)rez;
 else
 {
  printf("Number of classes ?: ");
  scanf("%c",&N_class);
  N_class-='0';
  printf(" N_class = %d\n",N_class);
 }
if((fp=fopen(strcat(strcpy(name,file_name),".cfg"),"r"))==NULL)
 {
  printf("Error opening %5s file\n",name);
  return(-1);
 }

tab_del=malloc(sizeof(SPIKE_INTERVAL)*N_class);   /*tablica delayow*/
printf("number of classes is %d\n",N_class);
fseek(fp,0L,SEEK_SET);

fscanf(fp,"%8s",opc);
if(strncmp(&opc[0],"ONSET",5)==0)          /* nie potrzebne */

/* cfg file not needed anymore*/
fclose(fp);

if((fo=open(strcat(strcpy(name,file_name),".par"),O_RDWR|O_CREAT,S_IREAD|S_IWRITE|S_IRGRP|S_IROTH))==-1)
 {
  printf("Error opening %5s file\n",name);
   free(tab_del);
     return(-1);
 }
len = filelengthf(strcat(strcpy(name,file_name),".par"));

par=calloc(N_class,sizeof(struct PARAMETERS));

if( ( N_class >= 1 )&&( len > 0 ) )
 len-=N_class*(N_class*sizeof(SPIKE_INTERVAL));

if( ( N_class*sizeof(struct PARAMETERS))==len )
 {
  printf("update %s ?",name);
  fflush(stdin);
  choose=getchar();
  if((choose=='n')||(choose=='N'))
   {
    free(tab_del);
      free(par);
	close(fo);
	  return(0);
    }
  update=1;
  dt = improve_par("dt step ",dt,"6.4");
  for(k=0;k<N_class;k++ )    /* czytam istniejacy zbior */
   {
   rez=read(fo,par+k,sizeof(struct PARAMETERS));
    if(rez!=sizeof(struct PARAMETERS))
     {
      printf("Update: error reading %5s file\n",name);
	free(tab_del);
	  free(par);
	    close(fo);
	      return(-1);
     }

   rez=read(fo,tab_del,sizeof(SPIKE_INTERVAL)*N_class);
    if(rez!=(sizeof(SPIKE_INTERVAL)*N_class))
     {
      printf("Update: error reading delay tab from %s file\n",name);
	 free(tab_del);
	    free(par);
	      close(fo);
		return(-1);
     }
   }
 }
else 
 {
  if(len==0 )
   {
    for(k=0;k<N_class;k++ )
    {

    for (kk=0;kk<NEXCCLASS;kk++){	
	 tau_o_exc[kk]=onset_exc/dt;
         tau_d_exc[k]=decay_exc/dt;
         tmax_exc[kk]=(tau_o_exc[kk]*tau_d_exc[kk]*log(tau_o_exc[kk]/tau_d_exc[kk]))/(tau_o_exc[kk]-tau_d_exc[kk]);
         Imax_exc[kk]=exp(-tmax_exc[kk]/tau_d_exc[kk])-exp(tmax_exc[kk]/tau_o_exc[kk]);
         (par+k)->de_o[kk]=onset_exc;
         (par+k)->de_d[kk]=decay_exc;
    }

    for (kk=0;kk<NINHCLASS;kk++){
	 tau_o_inh[kk]=onset_inh/dt;	
         tau_d_inh[kk]=decay_inh/dt;
	 tmax_inh[kk]=(tau_o_inh[kk]*tau_d_inh[kk]*log(tau_o_inh[kk]/tau_d_inh[kk]))/(tau_o_inh[kk]-tau_d_inh[kk]);
	 Imax_inh[kk]=exp(-tmax_inh[kk]/tau_d_inh[kk])-exp(tmax_inh[kk]/tau_o_inh[kk]); 
         (par+k)->di_o[kk]=onset_inh;
         (par+k)->di_d[kk]=decay_inh;
    }


    (par+k)->V_L= -50.; 
    (par+k)->V_Na=55.;
    (par+k)->V_K=-72.;
#ifdef CALCIUM
    (par+k)->V_Ca=124.;
    (par+k)->G_Ca=1.0*dt;
    (par+k)->G_K_Ca=3.5*dt;
    (par+k)->G_a=12.5*dt;
    (par+k)->Kp=0.0002;
    (par+k)->Kd=0.5;
    (par+k)->Kc=2.;
    (par+k)->R=0.006*dt;
    (par+k)->tau_x=25.0/dt;
    (par+k)->tau_b=10./dt;
    (par+k)->Utot=100;
    (par+k)->Utot0=100;
    (par+k)->Utot1=100;
    (par+k)->Utot2=100;
    (par+k)->Utot3=100;
    (par+k)->Utot4=100;
    (par+k)->Utot5=100;
    (par+k)->dr=0.0005;
    (par+k)->Rsh0=0.017;
    (par+k)->Rsh1=(par+k)->Rsh0+(par+k)->dr;
    (par+k)->Rsh2=(par+k)->Rsh1+(par+k)->dr;
    (par+k)->Rsh3=(par+k)->Rsh2+(par+k)->dr;
    (par+k)->Rsh4=(par+k)->Rsh3+(par+k)->dr;
    (par+k)->Rsh5=(par+k)->Rsh4+(par+k)->dr;
    (par+k)->Rsh=(par+k)->Rsh5+(par+k)->dr;
    (par+k)->back=0.1*dt;
    (par+k)->forw=0.3*dt;
    (par+k)->PCa=0.15*dt;
    (par+k)->Cao=2;
    (par+k)->gpump=1.6*dt;
    (par+k)->Kpump=0.75;
    (par+k)->D=0.000000006;
#endif
    (par+k)->G_Na=120.*dt; 
    (par+k)->G_L=0.3*dt;
    (par+k)->G_K_s=15.0*dt;
    (par+k)->i_ext=15.0*dt;
    (par+k)->Esyn_i=-72.;
    (par+k)->Esyn_e=-10.;

    for (kk=0;kk<NEXCCLASS;kk++){

         (par+k)->Aep[kk]=(Amp/Imax_exc[kk])*dt;

    }

    for (kk=0;kk<NINHCLASS;kk++){

         (par+k)->Aip[kk]=(Amp/Imax_inh[kk])*dt;

    }

    (par+k)->An=120*Amp*dt;
    *(tab_del+k)=100;
    }

   } /*end if len==0*/
  else
   {
     printf("Size of %s = %ld and siezeof(struct PARAMETERS) = %d are different\n",name,len,sizeof(struct PARAMETERS));
     choose=getchar();
     fflush(stdin);
     if((choose=='n')||(choose=='N'))
      {
       free(tab_del);
	free(par);
	  close(fo);
	    return(-1);
      }
   }

 }
printf("dt time step is %5.3f ms\n",dt);

for(k=0;k<N_class;k++ )    /*petla ustawiania parametrow po N_class*/
{
 printf(" << class : %d\n",k+1);
 delay_ms=(VAR)(*(tab_del+k))*dt;
 printf(" \n");
 printf("synaptic delay = %6.2lf ms; ",delay_ms);
 printf(" \n");
 fflush(stdin);
 /* gets() works better than fgets() */
 gets(str);
 if((isdigit(str[0]))||(str[0]=='.'))
  {
  delay_ms=(VAR)atof(str);
  }
 (par+k)->del=tab_del;
 robol=delay_ms/dt;
 *((par+k)->del+k)=robol;
  
  for (kk=0;kk<NEXCCLASS;kk++){

       onset_exc=(par+k)->de_o[kk];
 
       printf("\nEPSP from class #(0- %d) %d\n",NEXCCLASS-1,kk);
       onset_exc=improve_par("onset EPSPs rise time       tau_o = ",onset_exc,"6.4");
 
       tau_o_exc[kk]=onset_exc/dt;

       (par+k)->de_o[kk]=onset_exc;

       decay_exc=(par+k)->de_d[kk];

       printf("\nEPSP from class #(0- %d) %d\n",NEXCCLASS-1,kk);
       decay_exc=improve_par("decay EPSPs fall time        tau_d = ",decay_exc,"6.4");

       tau_d_exc[kk]=decay_exc/dt;

       (par+k)->de_d[kk]=decay_exc;

  }

  for (kk=0;kk<NINHCLASS;kk++){

       onset_inh=(par+k)->di_o[kk];

       printf("\nIPSP from class #(%d - %d) %d\n",NEXCCLASS,NUMCLASS-1,kk+NEXCCLASS);
       onset_inh=improve_par("onset IPSPs decrement       tau_o = ",onset_inh,"6.4");

       tau_o_inh[kk]=onset_inh/dt;
       (par+k)->di_o[kk]=onset_inh;

       decay_inh=(par+k)->di_d[kk];

       printf("\nIPSP from class #(%d - %d) %d\n",NEXCCLASS,NUMCLASS-1,kk+NEXCCLASS);
       decay_inh=improve_par("decay IPSPs fall time       tau_d = ",decay_inh,"6.4");

       tau_d_inh[kk]=decay_inh/dt;
       (par+k)->di_d[kk]=decay_inh;

  }


if(update)
{

  for (kk=0;kk<NEXCCLASS;kk++){

       tmax_exc[kk]=(tau_o_exc[kk]*tau_d_exc[kk]*log(tau_o_exc[kk]/tau_d_exc[kk]))/(tau_o_exc[kk]-tau_d_exc[kk]);
       Imax_exc[kk]=exp(-tmax_exc[kk]/tau_d_exc[kk])-exp(-tmax_exc[kk]/tau_o_exc[kk]);

       /* (par+k)->Aep[kk]=(Amp/Imax_exc[kk])*dt; */

  }

  for (kk=0;kk<NINHCLASS;kk++){

       tmax_inh[kk]=(tau_o_inh[kk]*tau_d_inh[kk]*log(tau_o_inh[kk]/tau_d_inh[kk]))/(tau_o_inh[kk]-tau_d_inh[kk]);
       Imax_inh[kk]=exp(-tmax_inh[kk]/tau_d_inh[kk])-exp(-tmax_inh[kk]/tau_o_inh[kk]);

       /* (par+k)->Aip[kk]=(Amp/Imax_inh[kk])*dt; */

  }

}

(par+k)->V_L  =improve_par("equilibrium potential         V_L = ",(par+k)->V_L,"6.4");
(par+k)->V_Na =improve_par("                             V_Na = ",(par+k)->V_Na,"6.4");
(par+k)->V_K  =improve_par("                             V_K = ",(par+k)->V_K,"6.4");
#ifdef CALCIUM
(par+k)->V_Ca =improve_par("                             V_Ca = ",(par+k)->V_Ca,"6.4");
#endif
(par+k)->G_Na =improve_par("conductance                  G_Na = ",(par+k)->G_Na/dt,"6.4")*dt;
(par+k)->G_L  =improve_par("                              G_L = ",(par+k)->G_L/dt,"6.4")*dt;
(par+k)->G_K_s=improve_par("                              G_K = ",(par+k)->G_K_s/dt,"6.4")*dt;
#ifdef CALCIUM
(par+k)->G_Ca =improve_par("                             G_Ca = ",(par+k)->G_Ca/dt,"6.4")*dt;
(par+k)->G_K_Ca=improve_par("                          G_K(Ca) = ",(par+k)->G_K_Ca/dt,"6.4")*dt;
(par+k)->G_a  =improve_par("                              G_A = ",(par+k)->G_a/dt,"6.4")*dt;
(par+k)->Kp   =improve_par("parameter                      Kp = ",(par+k)->Kp,"6.4");
(par+k)->Kd   =improve_par("                               Kd = ",(par+k)->Kd,"6.4");
(par+k)->Kc   =improve_par("                               Kc = ",(par+k)->Kc,"6.4");
(par+k)->R    =improve_par("                                R = ",(par+k)->R/dt,"6.4")*dt;
(par+k)->tau_x=improve_par("                            tau_x = ",(par+k)->tau_x*dt,"6.4")/dt;
(par+k)->tau_b=improve_par("                            tau_b = ",(par+k)->tau_b*dt,"6.4")/dt;
(par+k)->Utot =improve_par("                             Utot = ",(par+k)->Utot,"6.4");
(par+k)->Utot0=improve_par("                            Utot0 = ",(par+k)->Utot0,"6.4");
(par+k)->Utot1=improve_par("                            Utot1 = ",(par+k)->Utot1,"6.4");
(par+k)->Utot2=improve_par("                            Utot2 = ",(par+k)->Utot2,"6.4");
(par+k)->Utot3=improve_par("                            Utot3 = ",(par+k)->Utot3,"6.4");
(par+k)->Utot4=improve_par("                            Utot4 = ",(par+k)->Utot4,"6.4");
(par+k)->Utot5=improve_par("                            Utot5 = ",(par+k)->Utot5,"6.4");
(par+k)->dr   =improve_par("                               dr = ",(par+k)->dr,"6.5");
(par+k)->Rsh0 =improve_par("                             Rsh0 = ",(par+k)->Rsh0,"6.4");
//(par+k)->Rsh =improve_par("                             Rsh  = ",(par+k)->Rsh,"6.4");
(par+k)->Rsh1=(par+k)->Rsh0+(par+k)->dr;
(par+k)->Rsh2=(par+k)->Rsh1+(par+k)->dr;
(par+k)->Rsh3=(par+k)->Rsh2+(par+k)->dr;
(par+k)->Rsh4=(par+k)->Rsh3+(par+k)->dr;
(par+k)->Rsh5=(par+k)->Rsh4+(par+k)->dr;
(par+k)->Rsh=(par+k)->Rsh5+(par+k)->dr;
/*
for(i=0;i<6;i++)
{
sprintf(buf,"                          Utot[%i] = ",i);
(par+k)->Utot[i]=improve_par(buf,(par+k)->Utot[i],"6.4");
}
for(i=0;i<6;i++)
{
sprintf(buf,"                           Rsh[%i] = ",i);    
(par+k)->Rsh[i]=improve_par(buf,(par+k)->Rsh[i],"6.4");
}
*/
(par+k)->back =improve_par("                             back = ",(par+k)->back/dt,"6.4")*dt;
(par+k)->forw =improve_par("                             forw = ",(par+k)->forw/dt,"6.4")*dt;
(par+k)->PCa  =improve_par("                              PCa = ",(par+k)->PCa/dt,"6.4")*dt;
(par+k)->Cao  =improve_par("                              Cao = ",(par+k)->Cao,"6.4");
(par+k)->gpump=improve_par("                            gpump = ",(par+k)->gpump/dt,"6.4")*dt;
(par+k)->Kpump=improve_par("                            Kpump = ",(par+k)->Kpump,"6.4");
(par+k)->D    =improve_par("                                D = ",(par+k)->D,"12.11");
#endif  /* endif CALCIUM */
(par+k)->i_ext = improve_par("external current amplitude  i_ext = ",(par+k)->i_ext/dt,"6.4")*dt;
(par+k)->Esyn_e=improve_par("EPSP equilibrium potential Esyn_e = ",(par+k)->Esyn_e,"6.4");
(par+k)->Esyn_i=improve_par("IPSP equilibrium potential Esyn_i = ",(par+k)->Esyn_i,"6.4");

for (kk=0;kk<NEXCCLASS;kk++){

      printf("\nEPSP from class #(0- %d) %d\n",NEXCCLASS-1,kk);
      (par+k)->Aep[kk]=improve_par("EPSP amplitude                Aep = ",(par+k)->Aep[kk]/dt,"6.4")*dt;
      printf(" \n");

}

for (kk=0;kk<NINHCLASS;kk++){

      printf("\nIPSP from class #(%d - %d) %d\n",NEXCCLASS,NUMCLASS-1,kk+NEXCCLASS);
      (par+k)->Aip[kk]=improve_par("IPSP amplitude                Aip = ",(par+k)->Aip[kk]/dt,"6.4")*dt;
      printf(" \n");

}

(par+k)->An=improve_par("\nnoise amplitude                An = ",(par+k)->An/dt,"6.4")*dt;

/*for(j=0;j<TAB_SIZE;j++)
{
i=(int)((j-V_INT_OFFSET)/10.0);
robol=(1.+exp(-2.*0.065*((VAR)i+31)));
(par+k)->G_Na_m[j]=(par+k)->G_Na/(robol*robol*robol);
(par+k)->tau[j]=(1./(0.08*(exp(0.055*((VAR)i+35.))+exp(-0.055*((VAR)i+35.)))))/dt;
#ifdef CALCIUM
(par+k)->W_inf[j]=1./(1.+exp(-2.*0.055*((VAR)i+35.)));
(par+k)->X_inf[j]=1./(1.+exp(-2.*2*((VAR)i+45.)));
(par+k)->A_inf[j]=1./(1.+exp(-2.*0.02*((VAR)i+20.)));
(par+k)->B_inf[j]=1./(1.+exp(-2.*-0.1*((VAR)i+70.)));
#endif 
}*/

printf("\n >>class %d parameters :",k+1);
printf("\nsynaptic delay:         del[%d]  %6.2f",k+1,(*((par)->del+k))*dt);

for (kk=0;kk<NEXCCLASS;kk++){

     printf("\nEPSP from class #(0- %d) %d\n",NEXCCLASS-1,kk);
     printf("\nRise Time EPSPs de_o    %6.2f",(par+k)->de_o[kk]);
     printf("\nFall Time EPSPs de_d    %6.2f",(par+k)->de_d[kk]);

}

for (kk=0;kk<NINHCLASS;kk++){

     printf("\nIPSP from class #(%d - %d) %d\n",NEXCCLASS,NUMCLASS-1,kk+NEXCCLASS);
     printf("\n            onset IPSPs di_o    %6.2f",(par+k)->di_o[kk]);
     printf("\n            decay IPSPs di_d    %6.2f",(par+k)->di_d[kk]);

}

printf("\nequilibrium potentials: V_L     %6.2f",(par+k)->V_L);
printf("\n                        V_Na    %6.2f",(par+k)->V_Na);
printf("\n                        V_K     %6.2f",(par+k)->V_K);
#ifdef CALCIUM
printf("\n                        V_Ca    %6.2f",(par+k)->V_Ca);
#endif
printf("\nmembrane conductances:  G_Na    %6.2f",(par+k)->G_Na/dt);
printf("\n                        G_L     %6.2f",(par+k)->G_L/dt);
printf("\n                        G_K_s   %6.2f",(par+k)->G_K_s/dt);
#ifdef CALCIUM
printf("\n                        G_Ca    %6.2f",(par+k)->G_Ca/dt);
printf("\n                        G_K_Ca  %6.2f",(par+k)->G_K_Ca/dt);
printf("\n                        G_a     %6.2f",(par+k)->G_a/dt);
printf("\n                        Kd      %6.2f",(par+k)->Kd);
printf("\n                        Kp      %6.5f",(par+k)->Kp);
printf("\n                        Kc      %6.2f",(par+k)->Kc);
printf("\n                        R       %6.5f",(par+k)->R/dt);
printf("\n                        tau_x   %6.2f",(par+k)->tau_x*dt);
printf("\n                        tau_b   %6.2f",(par+k)->tau_b*dt);
printf("\n                        Utot    %6.2f",(par+k)->Utot);
printf("\n                        back    %6.2f",(par+k)->back/dt);
printf("\n                        forw    %6.2f",(par+k)->forw/dt);
printf("\n                        PCa     %6.2f",(par+k)->PCa/dt);
printf("\n                        Cao     %6.2f",(par+k)->Cao);
printf("\n                      gpump     %6.2f",(par+k)->gpump/dt);
printf("\n                      Kpump     %6.2f",(par+k)->Kpump);
printf("\n                       Utot     %6.2f",(par+k)->Utot);
printf("\n                       Utot0    %6.2f",(par+k)->Utot0);
printf("\n                       Utot1    %6.2f",(par+k)->Utot1);
printf("\n                       Utot2    %6.2f",(par+k)->Utot2);
printf("\n                       Utot3    %6.2f",(par+k)->Utot3);
printf("\n                       Utot4    %6.2f",(par+k)->Utot4);
printf("\n                       Utot5    %6.2f",(par+k)->Utot5);
printf("\n                          dr    %6.5f",(par+k)->dr);
printf("\n                        Rsh0    %6.5f",(par+k)->Rsh0);
printf("\n                        Rsh     %6.5f",(par+k)->Rsh);
printf("\n                          D     %12.11f",(par+k)->D);

#endif
printf("\nI_ext current amlitude: i_ext   %6.2f",(par+k)->i_ext/dt);
printf("\nPSPs equilibrium pot.:  Esyn_e  %6.2f",(par+k)->Esyn_e);
printf("\n                        Esyn_i  %6.2f\n",(par+k)->Esyn_i);

for (kk=0;kk<NEXCCLASS;kk++){

     printf("\nEPSP from class #(0- %d) %d\n",NEXCCLASS-1,kk);
     printf("\nPSPs amplitudes:  EPSPs Aep     %6.4f",(par+k)->Aep[kk]/dt);
     printf(" \n");

}

for (kk=0;kk<NINHCLASS;kk++){

     printf("\nIPSP from class #(%d - %d) %d\n",NEXCCLASS,NUMCLASS-1,kk+NEXCCLASS);
     printf("\n                  IPSPs Aip     %6.4f",(par+k)->Aip[kk]/dt);
     printf(" \n");

}

printf("\n                  noise An      %6.4f",(par+k)->An/dt);
printf("\n\nall parameters OK?");
choose=getchar();
fflush(stdin);
if((choose=='N')||(choose=='n')){ --k; getchar();}
}
/*
koniec pentli ustawiania parametrow po N_class
*/

lseek(fo,0L,SEEK_SET);

for(k=0;k<N_class;k++)
{
rez=write(fo,par+k,sizeof(struct PARAMETERS));
if((rez<0)||((rez!=sizeof(struct PARAMETERS))&&(rez!=0)))
 {
  printf("Error writing %5s file\n",name);
    free(tab_del);
      free(par);
	return(-1);
 }

 rez=write(fo,(par+k)->del,sizeof(SPIKE_INTERVAL)*N_class);
  if((rez<0)||((rez!=(sizeof(SPIKE_INTERVAL)*N_class))&&(rez!=0)))
   {
    printf("Error writing delay tab into %s file\n",name);
      free(tab_del);
	free(par);
	  return(-1);
   }

}
free(tab_del);
free(par);
close(fo);
return 1;
}


VAR improve_par(char *str_out, VAR x, char *lng)
{
 char str_in[20];
 char format[10]; 
 printf("%s",str_out);
 sprintf(format,"%%%s",lng);
 strcat(format,"f; ");
 //printf("%6.4f",x);
 printf(format,x);
 fflush(stdin);
 /* using gets may be dangerous! 
    but here gets() works better than fgets() */ 
 gets(str_in); 
  if( (isdigit(str_in[0]))||(str_in[0]=='.')||(str_in[0]=='-') )
    return((VAR)atof(str_in));
   else 
    return(x);
}

int get_par(char * file_name ,int d) /*wyciaga parametr o nr.d (liczac od pojawienia sie pierwszej cyfry-*/
{             	                     /*  - w zbiorze z *.cfg)  */
FILE *fp;
int i=0,j,k,l=0;
char name[5];
if((fp=fopen(strcat(strcpy(name,file_name),".cfg"),"r"))==NULL)
 {
 printf("Error opening %5s file\n",name);
 return(-1);
 }
while(i==0)
 {
  k=getc(fp);
  i=isdigit(k);
  ++l;
  if(l>70)
   return(0);
 }
if(d<=6)
 {
  for(l=0;l<=d-1;l++)
  fscanf(fp,"%d",&j);
  fclose(fp);
  return(j);
 }
else
 {
  while(i!=',')
    {
     k=getc(fp);
     i=k;
    }
  for(l=0;l<=d-7;l++)
  fscanf(fp,"%d",&j);
  fclose(fp);
  return(j);
 }
}
int get_cfg(char * file_name)
{
 int i;
 FILE *fp;
 extern char konfig[5];
 char konf[5],tym[8],rez=' ';
 long curpos;
 char name[5];
 if((fp=fopen(strcat(strcpy(name,file_name),".cfg"),"r"))==NULL)
  {
   printf("Error opening %5s file\n",name);
   return(-1);
  }
 for(i=0;i<=4;i++)
  konfig[i]=0;
 fscanf(fp,"%8s",tym);
 if(strncmp(&tym[0],"ONE_KIND",8)!=0)fseek(fp,0L,SEEK_SET);
 curpos=ftell(fp);
 fscanf(fp,"%8s",tym);
 if(strncmp(&tym[0],"ONSET",5)!=0)fseek(fp,curpos,SEEK_SET);
 curpos=ftell(fp);
 if(strncmp(&tym[0],"SAME_DELAY",5)!=0)fseek(fp,curpos,SEEK_SET);
 curpos=ftell(fp);
 if(strncmp(&tym[0],"FULL",4)!=0)fseek(fp,curpos,SEEK_SET);
 curpos=ftell(fp);
 if(strncmp(&tym[0],"FAST",4)!=0)fseek(fp,curpos,SEEK_SET);
 rez=getc(fp);
 do
  {
   switch(rez)
    {
     case 'O':
      konf[0]='1';
      break;
     case 'N':
      konf[1]='1';
      break;
     case 'H':
      konf[2]='1';
      break;
     case 'I':
      konf[3]='1';
      break;
     case 'V':
      konf[4]='1';
      break;
     case EOF:
     return(-1);
    }
  }while((rez=getc(fp))!='$');
 for(i=0;i<=4;i++)
 *(konfig+i)=*(konf+i);
 if(fclose(fp)!=EOF)
   return(0);
  else
   return(-1);
}

Loading data, please wait...