home *** CD-ROM | disk | FTP | other *** search
/ Collection of Education / collectionofeducationcarat1997.iso / COMPUSCI / NERVES.ZIP / NO87 / DATAMOD.C next >
C/C++ Source or Header  |  1990-12-27  |  17KB  |  805 lines
  1. #include "defn.h"
  2. #include "nsdata.c"
  3. #include "proto.h"
  4.  
  5. void datamod(void) /* allows user to modify/add/delete neuron data */
  6.  {
  7.   enum asc_val asc;
  8.   enum ext_val ext;
  9.   char str[41];
  10.   char *p;
  11.   int newneur;
  12.   FILE *file;
  13.   int i,j,done,line,cc,newcon;
  14.   struct neuron *np,tn;
  15.   struct con *cp,*tc,*cq,*cs;
  16.   struct Iint ti;
  17.   double d;
  18.  
  19.   /* modify data */
  20. start:
  21.   clrscr();
  22.   textattr(BLUE + (LIGHTGRAY<<4));
  23.   gotoxy(1,24);
  24.   cputs(" ^S-Save file   Esc-Main menu                                                   ");
  25.   textattr(LIGHTGRAY);
  26. getname:
  27.   clrline(1);
  28.   gotoxy(1,1);
  29.   cputs("Neuron name: ");
  30.   i = 0;
  31.   while (!i)
  32.    i = bioskey(1);
  33.   asc = i & 0xff;
  34.   if (asc == ESC)
  35.    { /* return to main menu without saving */
  36.     bioskey(0);
  37.     return; /* go to main menu */
  38.    }
  39.   else
  40.    if (asc == CTRLS)
  41.     { /* save file */
  42.      bioskey(0);
  43.      /* count neurons */
  44.      for (i=0, j=0, np=ns; i<nn; i++, np++)
  45.       if (np->name[0])
  46.        j++;
  47.      clrscr();
  48.      if (neurfname[0])
  49.       {
  50.        cprintf("Save to %s? ",neurfname);
  51.        i = toupper(bioskey(0) & 0xff);
  52.       }
  53.      if (!neurfname[0] || i != 'Y')
  54.       {
  55.        gotoxy(1,1);
  56.        cputs("Enter file spec:                                      ");
  57.        gotoxy(18,1);
  58.        str[0] = 38;
  59.        p = cgets(str);
  60.        strcpy(neurfname,p);
  61.       }
  62.      file = fopen(neurfname,"wb");
  63.      fwrite(&j,2,1,file);
  64.      for (i=0, np=ns; i<nn; i++, np++)
  65.       if (np->name[0])
  66.        {
  67.     fwrite(np,27,1,file);
  68.     if (np->Iint)
  69.      j = (int)np->Iint - (int)Iinta + 1;
  70.     else
  71.      j = 0;
  72.     fwrite(&j,2,1,file);
  73.     fwrite(&(np->Isens),18,1,file);
  74.     if (np->con)
  75.      j = (int)np->con - (int)cona + 1;
  76.     else
  77.      j = 0;
  78.     fwrite(&j,2,1,file);
  79.        }
  80.      fwrite(&ni,2,1,file);
  81.      for (i=0; i<ni; i++)
  82.       fwrite(Iinta+i,19,1,file);
  83.      fwrite(&nc,2,1,file);
  84.      for (i=0, cp=cona; i<nc; i++, cp++)
  85.       {
  86.        fwrite(cp,sizeof(struct con)-6,1,file);
  87.        if (cp->next)
  88.     j = (int)cp->next - (int)cona + 1;
  89.        else
  90.     j = 0;
  91.        fwrite(&j,2,1,file);
  92.       }
  93.      fclose(file);
  94.      return; /* go to main menu */
  95.     }
  96.   else
  97.    { /* neuron name input */
  98.     str[0] = 7;
  99.     p = cgets(str);
  100.     if ((*p == '?' || *p == '/') && *(p+1) == 0)
  101.      { /* list neuron names */
  102.       for (np=ns, i=0, j=0; i<nn && j<10; j++)
  103.        for (line=3; line<24 && i<nn; line++, i++, np++)
  104.     {
  105.      gotoxy(1+j*8,line);
  106.      while (!np->name[0] && i<nn)
  107.       {
  108.        np++;
  109.        i++;
  110.       }
  111.      if (i<nn)
  112.       cprintf("%s",np->name);
  113.     }
  114.       goto getname;
  115.      }
  116.     else
  117.      if (!*p)
  118.       goto getname;
  119.      else
  120.       {
  121.        for (np=ns, i=0; i<nn; i++, np++)
  122.     if (!strncmp(p,np->name,6))
  123.      break;
  124.        if (i == nn)
  125.     {
  126.      gotoxy(1,2);
  127.      cputs("Neuron not found; create new neuron? ");
  128.      if (toupper(bioskey(0) & 0xff) != 'Y')
  129.       goto getname;
  130.      newneur = TRUE;
  131.      nn++;
  132.     }
  133.        else
  134.     newneur = FALSE;
  135.       }
  136.     /* save neuron's data in temporary storage */
  137.     tn = *np;
  138.     if (newneur)
  139.      strcpy(tn.name,p);
  140.     if (np->Iint)
  141.      ti = *(np->Iint);
  142.     else
  143.      ti = *(Iinta + ni);
  144.     for (cp=np->con, tc=cona+nc, cc=0; cp!=NULL; cp=cp->next, cc++, tc++)
  145.      *tc = *cp;
  146.     tc = cona+nc;
  147.  
  148.     ndisp(tn,ti,3); /* display neuron's parameters */
  149.  
  150.     /* modify parameters */
  151.     line = 3;
  152.     done = FALSE;
  153.     while(!done)
  154.      {
  155.       i = 0;
  156.       while(!i)
  157.        i = bioskey(1);
  158.       asc = i & 0xff;
  159.       if (asc)
  160.        {
  161.     if (asc < 32)
  162.      {
  163.       bioskey(0);
  164.       switch(asc)
  165.        {
  166.         case CTRLD: /* delete neuron */
  167.          if (!strcmp(tn.name,np->name)) /* if existing neuron, delete */
  168.           np->name[0] = 0;
  169.          if (newneur)
  170.           nn--;
  171.          goto start;
  172.         case CTRLS: /* save neuron */
  173.  
  174.              /* convert to integer values */
  175.          tn.iGmem = tn.Gmem * 1e8 + .5;
  176.          tn.iCmem = tn.Cmem * 1e11 + .5;
  177.          tn.iVt = tn.Vt * 1e6 + fsgn(tn.Vt)*.5;
  178.          tn.iFmin = tn.Fmin * 10000 + .5;
  179.          tn.iGain = tn.Gain * 1e-2 + .5;
  180.          tn.ipI[0] = tn.pI[0] * 1e13 + fsgn(tn.pI[0])*.5;
  181.          tn.ipI[1] = tn.pI[1] * 1e13 + fsgn(tn.pI[1])*.5;
  182.          tn.imconst = tn.mconst * 1e1 + fsgn(tn.mconst)*.5;
  183.          ti.iIL = ti.IL * 1e11 + fsgn(ti.IL)*.5;
  184.          if (ti.type == 0)
  185.           ti.ipL[0] = ti.pL[0] * 1e6 + fsgn(ti.pL[0])*.5;
  186.          else
  187.           ti.ipL[0] = ti.pL[0] * 1e3 + .5;
  188.          ti.ipL[1] = ti.pL[1] * 1e3 + .5;
  189.          ti.ipL[2] = ti.pL[2] * 1e2 + .5;
  190.          ti.iIH = ti.IH * 1e11 + fsgn(ti.IH)*.5;
  191.          ti.ipH[0] = ti.pH[0] * 1e3 + .5;
  192.          ti.ipH[1] = ti.pH[1] * 1e3 + .5;
  193.          for (cq=tc, j=0; j<cc; cq++, j++)
  194.           {
  195.            cq->iIsr = cq->Isr * 1e10 + fsgn(cq->Isr)*.5;
  196.            cq->iIcr = cq->Icr * 1e10 + fsgn(cq->Icr)*.5;
  197.           }
  198.  
  199.          if (!newneur && strcmp(np->name,tn.name))
  200.           { /* copied neuron */
  201.            if (tn.Iint)
  202.         tn.Iint = Iinta+ni;
  203.            np = ns + nn;
  204.            np->Iint = 0;
  205.            np->con = 0;
  206.            nn++;
  207.           }
  208.          if (!np->con)
  209.           newcon = TRUE;
  210.          else
  211.           newcon = FALSE;
  212.          if (!np->Iint && tn.Iint)
  213.           ni++;
  214.          *(np) = tn;
  215.          if (tn.Iint)
  216.           *tn.Iint = ti;
  217.          j = 0;
  218.          cq = tc;
  219.          if (!newcon)
  220.           for (cp=np->con; cp!=NULL && j<cc; cp=cs, cq++, j++)
  221.            {
  222.         cs = cp->next;
  223.         *cp = *cq;
  224.         if (j == cc-1)
  225.          cp->next = NULL;
  226.         else
  227.          if (cs == NULL && j < cc-1)
  228.           cp->next = cona + nc;
  229.          else
  230.           cp->next = cs;
  231.            }
  232.              if (cp == NULL)
  233.           {
  234.            if (j != cc)
  235.         {
  236.          for (cp=cona+nc, i=0; j<cc; cp++, j++, cq++, i++)
  237.           {
  238.            if (!newcon)
  239.             *cp = *cq;
  240.            cp->next = cp + 1;
  241.           }
  242.          (cp-1)->next = NULL;
  243.          if (newcon)
  244.           np->con = cona + nc;
  245.          nc += i;
  246.         }
  247.           }
  248.          goto start;
  249.         case CR:
  250.          switch (line)
  251.           {
  252.            case 8: /* Intrinsic current type */
  253.         if (!tn.Iint)
  254.          {
  255.           tn.Iint = Iinta + ni;
  256.           ti.type = 0;
  257.          }
  258.         else
  259.          if (ti.type == 0)
  260.           ti.type = 1;
  261.          else
  262.           tn.Iint = NULL;
  263.         ndisp(tn,ti,line);
  264.                 break;
  265.            case 16: /* Sensory current function */
  266.         tn.Isens++;
  267.         if (tn.Isens > 6)
  268.          tn.Isens = 0;
  269.         ndisp(tn,ti,line);
  270.         break;
  271.            case 19: /* motor output type */
  272.         tn.mtype++;
  273.         if (tn.mtype > 2)
  274.          tn.mtype = 0;
  275.         ndisp(tn,ti,line);
  276.         break;
  277.            case 20: /* motor output sub type */
  278.         if (tn.mtype == 1)
  279.          {
  280.           tn.mname++;
  281.           if (tn.mname > 2)
  282.            tn.mname = 0;
  283.          }
  284.         else
  285.          if (tn.mtype == 2)
  286.           tn.mname = !tn.mname;
  287.          else
  288.           break;
  289.         ndisp(tn,ti,line);
  290.         break;
  291.            case 22: /* Switch to connections page */
  292.         conmod(tn.name,tc,&cc);
  293.         ndisp(tn,ti,3);
  294.         line = 3;
  295.         break;
  296.            default:
  297.         if (line < 22)
  298.          line++;
  299.         else
  300.          line = 1;
  301.         gotoxy(40,line);
  302.         break;
  303.           }
  304.          break;
  305.         case ESC:
  306.          if (newneur)
  307.           nn--;
  308.          goto start;
  309.         default:
  310.          break;
  311.        }
  312.      }
  313.     else
  314.      { /* process input */
  315.       if (line <= 7 ||
  316.          (tn.Iint && line >= 9 && line <= 15 &&
  317.           !(line == 12 && ti.type == 1)) ||
  318.          (tn.Isens && (line == 17) || (tn.Isens == OS && line == 18)) ||
  319.          (tn.mtype && (line == 21)))
  320.        { /* get numerical input */
  321.         gotoxy(40,line);
  322.         cputs("                   ");
  323.         gotoxy(40,line);
  324.         if (line == 1)
  325.          str[0] = 7;
  326.         else
  327.          str[0] = 15;
  328.         p = cgets(str);
  329.         if (line == 1)
  330.          {
  331.           strcpy(tn.name,p);
  332.           line = 3;
  333.           gotoxy(40,3);
  334.          }
  335.         else
  336.          {
  337.           d = atof(p);
  338.           gotoxy(40,line);
  339.           if (line == 18 || line == 17)
  340.            cprintf("%.4f",d);
  341.           else
  342.            cprintf("%.2f",d);
  343.           switch (line)
  344.            {
  345.         case 3: /* Gmem */
  346.          tn.Gmem = d * 1e-6;
  347.          break;
  348.         case 4: /* Cmem */
  349.          tn.Cmem = d * 1e-9;
  350.          break;
  351.         case 5: /* Vt */
  352.          tn.Vt = d * 1e-3;
  353.          break;
  354.         case 6: /* Fmin */
  355.          tn.Fmin = d;
  356.          break;
  357.         case 7: /* Gain */
  358.          tn.Gain = d * 1e3;
  359.          break;
  360.         case 9: /* IL */
  361.          ti.IL = d * 1e-9;
  362.          break;
  363.         case 10:
  364.          ti.pL[0] = d * 1e-3;
  365.          break;
  366.         case 11:
  367.          ti.pL[1] = d * 1e-3;
  368.          break;
  369.         case 12:
  370.          ti.pL[2] = d