ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/freemol/trunk/smi23d/src/mengine/readprm.c
(Generate patch)
# Line 11 | Line 11
11  
12   FILE * fopen_path ( char * , char * , char * ) ;
13   void zero_data(void);
14 void read_datafiles(char *);
14   void readpid(char *);
15 + void read_datafiles(char *);
16   void readmmxdata(char *);
17   void torphase(int, float *, int *);
18 < void read_parameterfile(char *);
18 > void read_parameterfile(char **);
19   void numeral(int, char *, int);
20   void message_alert(char *, char *);
21   int FetchRecord(FILE *, char *);
# Line 1602 | Line 1602
1602      return FALSE;
1603   }        
1604   /* =============================================  */
1605 < void read_datafiles(char *datafile)
1605 > void read_datafiles(char *pfile)
1606   {
1607 + /*
1608      char filename[256];
1609      
1610         char *ev = NULL;
# Line 1616 | Line 1617
1617         } else
1618            strcpy(filename,datafile);
1619      read_parameterfile(filename);
1620 + */
1621 + #include "mmxconst.h"
1622 + #include "mmff94.h"
1623 +    if (!strncmp(pfile, "mmxconst",8)) {
1624 +     read_parameterfile(mmxconst);
1625 +    } else if (!strncmp(pfile, "mmff94",6))  {
1626 +     read_parameterfile(mmff94);
1627 +    }
1628      return;
1629   }
1630   // =================================================
1631 < void read_parameterfile(char *string)
1631 > void read_parameterfile(char **parray)
1632   {
1633 <        char line[151], dumm[21], iptemp[21];
1633 >        char dumm[21], iptemp[21];
1634          char pa[4],pb[4],pt[7];
1635          char pc[4],pd[4],pang[10],ptor[13];
1636          int iz;
# Line 1635 | Line 1644
1644          float charge, fchrg,tchrg;
1645          int i, iatm1, iatm2, ii, ja,
1646           jb, kk, kp1, kp2, kp3, kp4, kt1, kt2, kt3;
1638        FILE *datafile;
1647  
1648 +        int irec=0;
1649 +        char *line;
1650  
1651 + /*
1652 +        FILE *datafile;
1653          datafile = fopen(string, "rt");
1654  
1655          if (datafile == NULL)
# Line 1651 | Line 1663
1663           }
1664  
1665           while ( FetchRecord(datafile,line))
1666 + */
1667 +        while (strlen(parray[irec]))
1668           {
1669 +            line = parray[irec];
1670 +            ++irec;
1671              sscanf(line,"%s",iptemp);
1672          /*  force field descriptors   */
1673              if (strcmp(iptemp,"forcefield") == 0)
# Line 1777 | Line 1793
1793                  {
1794                       message_alert("Error - Too many atom types","Read Parameter");
1795                       fprintf(stderr,"Maximum number of atom types exceeded. Others will be ignored\n");
1796 <                     fclose(datafile);
1796 >                     //fclose(datafile);
1797                       return;
1798                  }
1799                  
# Line 1801 | Line 1817
1817                  if (metaldata.nmetal > 200)
1818                  {
1819                      message_alert("Error-Too many metals in Parameter file","Read Parameter");
1820 <                    fclose(datafile);
1820 >                    //fclose(datafile);
1821                      return;
1822                  }
1823                  sscanf(line,"%s %d %s %f %f",dumm,&metaldata.type[metaldata.nmetal], metaldata.name[metaldata.nmetal],&metaldata.radius[metaldata.nmetal],
# Line 1813 | Line 1829
1829                  {
1830                       message_alert("Error - Too many bond constants","Read Parameter");
1831                       fprintf(stderr,"Maximum number of bond constants exceeded. Others will be ignored\n");
1832 <                     fclose(datafile);
1832 >                     //fclose(datafile);
1833                       return;
1834                  }
1835                          
# Line 1831 | Line 1847
1847                  {
1848                       message_alert("Error - Too many bond3 constants","Read Parameter");
1849                       fprintf(stderr,"Maximum number of bond3 constants exceeded. Others will be ignored\n");
1850 <                     fclose(datafile);
1850 >                     //fclose(datafile);
1851                       return;
1852                  }
1853                          
# Line 1850 | Line 1866
1866                  {
1867                       message_alert("Error - Too many bond4 constants","Read Parameter");
1868                       fprintf(stderr,"Maximum number of bond4 constants exceeded. Others will be ignored\n");
1869 <                     fclose(datafile);
1869 >                     //fclose(datafile);
1870                       return;
1871                  }
1872                          
# Line 1869 | Line 1885
1885                  {
1886                       message_alert("Error - Too many bond5 constants","Read Parameter");
1887                       fprintf(stderr,"Maximum number of bond5 constants exceeded. Others will be ignored\n");
1888 <                     fclose(datafile);
1888 >                     //fclose(datafile);
1889                       return;
1890                  }
1891                          
# Line 1887 | Line 1903
1903                  {
1904                       message_alert("Error - Too many delocalized bond constants","Read Parameter");
1905                       fprintf(stderr,"Maximum number of delocalized bond constants exceeded. Others will be ignored\n");
1906 <                     fclose(datafile);
1906 >                     //fclose(datafile);
1907                       return;
1908                  }
1909                          
# Line 1919 | Line 1935
1935                  {
1936                       message_alert("Error - Too many piatom constants","Read Parameter");
1937                       fprintf(stderr,"Maximum number of piatom constants exceeded. Others will be ignored\n");
1938 <                     fclose(datafile);
1938 >                     //fclose(datafile);
1939                       return;
1940                  }
1941                  sscanf(line,"%s %d %f %f %f %f %f %f %f %f %d", dumm, &piatomk.kat[piatomk.npiatom],
# Line 2191 | Line 2207
2207                  {
2208                      message_alert("Error - Too many bond dipoles","Read Parameter");
2209                      fprintf(stderr,"Maximum number of bond dipole constants exceeded. Others will be ignored\n");
2210 <                    fclose(datafile);
2210 >                    //fclose(datafile);
2211                      return;
2212                  }
2213                  sscanf( line,"%s %d %d %f",dumm, &ii, &kk, &radius);
# Line 2207 | Line 2223
2223                  {
2224                      message_alert("Error - Too many atom charges","Read Parameter");
2225                      fprintf(stderr,"Maximum number of atom charge constants exceeded. Others will be ignored\n");
2226 <                    fclose(datafile);
2226 >                    //fclose(datafile);
2227                      return;
2228                  }
2229                  sscanf( line,"%s %d %f", dumm, &charge_k.type[charge_k.ncharge], &charge_k.charge[charge_k.ncharge]);
# Line 2218 | Line 2234
2234                  {
2235                      message_alert("Error - Too many opls charges","Read Parameter");
2236                      fprintf(stderr,"Maximum number of opls charge constants exceeded. Others will be ignored\n");
2237 <                    fclose(datafile);
2237 >                    //fclose(datafile);
2238                      return;
2239                  }
2240                  sscanf(line,"%s %d %f %s\n",dumm,&oplschrg_k.type[oplschrg_k.ncharge],&oplschrg_k.chrg[oplschrg_k.ncharge],
# Line 2230 | Line 2246
2246                  {
2247                      message_alert("Error - Too many amber charges","Read Parameter");
2248                      fprintf(stderr,"Maximum number of amber charge constants exceeded. Others will be ignored\n");
2249 <                    fclose(datafile);
2249 >                    //fclose(datafile);
2250                      return;
2251                  }
2252                  for (iz=0;iz < 25; iz++) descript[iz] = ' ';
# Line 2300 | Line 2316
2316                  {
2317                      message_alert("Error - Too many atom charges","Read Parameter");
2318                     fprintf(stderr,"Maximum number of atom charge constants exceeded. Others will be ignored\n");
2319 <                    fclose(datafile);
2319 >                    //fclose(datafile);
2320                      return;
2321                  }
2322                  sscanf( line,"%s %d %f %f %f", dumm, &i, &charge, &fchrg, &tchrg);
# Line 2314 | Line 2330
2330                  {
2331                      message_alert("Error - Too many bond charges","Read Parameter");
2332                     fprintf(stderr,"Maximum number of bond charge constants exceeded. Others will be ignored\n");
2333 <                    fclose(datafile);
2333 >                    //fclose(datafile);
2334                      return;
2335                  }
2336                  sscanf(line,"%s %d %d %f",dumm,&kp1,&kp2,&charge_k.bchargedel[charge_k.nbndchrgdel]);
# Line 2326 | Line 2342
2342                  {
2343                      message_alert("Error - Too many bond charges","Read Parameter");
2344                     fprintf(stderr,"Maximum number of bond charge constants exceeded. Others will be ignored\n");
2345 <                    fclose(datafile);
2345 >                    //fclose(datafile);
2346                      return;
2347                  }
2348                  sscanf(line,"%s %d %d %f",dumm,&kp1,&kp2,&charge_k.bcharge[charge_k.nbndchrg]);
# Line 2338 | Line 2354
2354                  {
2355                      message_alert("Error - Too many vdw constants","Read Parameter");
2356                     fprintf(stderr,"Maximum number of vdw constants exceeded. Others will be ignored\n");
2357 <                    fclose(datafile);
2357 >                    //fclose(datafile);
2358                      return;
2359                  }
2360                  sscanf( line, "%s %d %f %f %f %f %s", dumm, &i, &alpha, &ntmp, &atmp, &gtmp, symbol);
# Line 2354 | Line 2370
2370                  {
2371                      message_alert("Error - Too many vdw constants","Read Parameter");
2372                     fprintf(stderr,"Maximum number of vdw constants exceeded. Others will be ignored\n");
2373 <                    fclose(datafile);
2373 >                    //fclose(datafile);
2374                      return;
2375                  }
2376                  sscanf( line, "%s %d %f %f %d %d %d", dumm, &i, &radius, &epsilon, &lpde, &ihtype, &ihdonor);
# Line 2373 | Line 2389
2389                   {
2390                        message_alert("Error - Too many torsion 4 constants","Read Parameter");
2391                       fprintf(stderr,"Maximum number of torsion 4 constants exceeded. Others will be ignored\n");
2392 <                      fclose(datafile);
2392 >                      //fclose(datafile);
2393                        return;
2394                   }
2395                  for(i=0; i < 6; i++)
# Line 2404 | Line 2420
2420                   {
2421                        message_alert("Error - Too many torsion 5 constants","Read Parameter");
2422                       fprintf(stderr,"Maximum number of torsion 5 constants exceeded. Others will be ignored\n");
2423 <                      fclose(datafile);
2423 >                      //fclose(datafile);
2424                        return;
2425                   }
2426                  for(i=0; i < 6; i++)
# Line 2434 | Line 2450
2450                   {
2451                        message_alert("Error - Too many delocalized torsion  constants","Read Parameter");
2452                       fprintf(stderr,"Maximum number of delocalized torsion  constants exceeded. Others will be ignored\n");
2453 <                      fclose(datafile);
2453 >                      //fclose(datafile);
2454                        return;
2455                   }
2456                  for(i=0; i < 6; i++)
# Line 2464 | Line 2480
2480                  {
2481                      message_alert("Error - Too many torsion constants","Read Parameter");
2482                     fprintf(stderr,"Maximum number of torsion constants exceeded. Others will be ignored\n");
2483 <                    fclose(datafile);
2483 >                    //fclose(datafile);
2484                      return;
2485                  }
2486                  for(i=0; i < 6; i++)
# Line 2527 | Line 2543
2543                  {
2544                      message_alert("Error - Too many improper torsion constants","Read Parameter");
2545                     fprintf(stderr,"Maximum number of improper torsion constants exceeded. Others will be ignored\n");
2546 <                    fclose(datafile);
2546 >                    //fclose(datafile);
2547                      return;
2548                  }
2549                  sscanf( line, "%s %d %d %d %d %f %d %f %d %f %d", dumm,
# Line 2556 | Line 2572
2572                  {
2573                      message_alert("Error - Too many improper torsion constants","Read Parameter");
2574                     fprintf(stderr,"Maximum number of improper torsion constants exceeded. Others will be ignored\n");
2575 <                    fclose(datafile);
2575 >                    //fclose(datafile);
2576                      return;
2577                  }
2578                  sscanf( line, "%s %d %d %d %d %f %f", dumm,
# Line 2576 | Line 2592
2592                    {
2593                       message_alert("Error - Too many UreyBrad constants","Read Parameter");
2594                      fprintf(stderr,"Maximum number of ureybradley constants exceeded. Others will be ignored\n");
2595 <                     fclose(datafile);
2595 >                     //fclose(datafile);
2596                       return;
2597                    }
2598                    sscanf(line, "%s %d %d %d %f %f",dumm,
# Line 2605 | Line 2621
2621                   {
2622                       message_alert("Error - Too many angle 5 constants","Read Parameter");
2623                      fprintf(stderr,"Maximum number of angle 5 constants exceeded. Others will be ignored\n");
2624 <                     fclose(datafile);
2624 >                     //fclose(datafile);
2625                       return;
2626                   }
2627                   sscanf( line, "%s %d %d %d %f %f %f %f", dumm,
# Line 2623 | Line 2639
2639                   {
2640                       message_alert("Error - Too many angle 4 constants","Read Parameter");
2641                      fprintf(stderr,"Maximum number of angle 4 constants exceeded. Others will be ignored\n");
2642 <                     fclose(datafile);
2642 >                     //fclose(datafile);
2643                       return;
2644                   }
2645                   sscanf( line, "%s %d %d %d %f %f %f %f", dumm,
# Line 2641 | Line 2657
2657                  {
2658                      message_alert("Error - Too many angle 3 constants","Read Parameter");
2659                     fprintf(stderr,"Maximum number of angle 3 constants exceeded. Others will be ignored\n");
2660 <                    fclose(datafile);
2660 >                    //fclose(datafile);
2661                      return;
2662                  }
2663                  sscanf( line, "%s  %d %d %d %f %f %f %f", dumm,
# Line 2659 | Line 2675
2675                 {
2676                    message_alert("Error - Too many angle constants","Read Parameter");
2677                   fprintf(stderr,"Maximum number of angle constants exceeded. Others will be ignored\n");
2678 <                  fclose(datafile);
2678 >                  //fclose(datafile);
2679                    return;
2680                 }
2681                 sscanf( line, "%s  %d %d %d %f %f %f %f", dumm,
# Line 2677 | Line 2693
2693                 {
2694                    message_alert("Error - Too many delocalized angle constants","Read Parameter");
2695                   fprintf(stderr,"Maximum number of delocalized angle constants exceeded. Others will be ignored\n");
2696 <                  fclose(datafile);
2696 >                  //fclose(datafile);
2697                    return;
2698                 }
2699                 sscanf( line, "%s  %d %d %d %f %f %f %f", dumm,
# Line 2695 | Line 2711
2711                 {
2712                    message_alert("Error - Too many delocalized angle constants","Read Parameter");
2713                   fprintf(stderr,"Maximum number of delocalized angle constants exceeded. Others will be ignored\n");
2714 <                  fclose(datafile);
2714 >                  //fclose(datafile);
2715                    return;
2716                 }
2717                 sscanf( line, "%s  %d %d %d %f %f %f %f", dumm,
# Line 2713 | Line 2729
2729                 {
2730                    message_alert("Error - Too many delocalized angle constants","Read Parameter");
2731                   fprintf(stderr,"Maximum number of delocalized angle constants exceeded. Others will be ignored\n");
2732 <                  fclose(datafile);
2732 >                  //fclose(datafile);
2733                    return;
2734                 }
2735                 sscanf( line, "%s  %d %d %d %f %f %f %f", dumm,
# Line 2731 | Line 2747
2747                 {
2748                    message_alert("Error - Too many out of plane bending constants","Read Parameter");
2749                   fprintf(stderr,"Maximum number of out of plane bend constants exceeded. Others will be ignored\n");
2750 <                  fclose(datafile);
2750 >                  //fclose(datafile);
2751                    return;
2752                 }
2753                 sscanf( line, "%s %d %d %d %d %f", dumm, &kp1, &kp2, &kp3,&kp4,
# Line 2749 | Line 2765
2765                {
2766                    message_alert("Error - Too many str bend constants","Read Parameter");
2767                   fprintf(stderr,"Maximum number of str bend constants exceeded. Others will be ignored\n");
2768 <                  fclose(datafile);
2768 >                  //fclose(datafile);
2769                    return;
2770                }
2771                kp4 = 0;
# Line 2770 | Line 2786
2786                {
2787                    message_alert("Error - Too many ang ang constants","Read Parameter");
2788                   fprintf(stderr,"Maximum number of ang ang constants exceeded. Others will be ignored\n");
2789 <                  fclose(datafile);
2789 >                  //fclose(datafile);
2790                    return;
2791                }
2792                sscanf(line,"%s %d %f %f %f",dumm, &crossterm_k.ang_ang[crossterm_k.nangang],
# Line 2784 | Line 2800
2800                {
2801                    message_alert("Error - Too many str tor constants","Read Parameter");
2802                   fprintf(stderr,"Maximum number of str tor constants exceeded. Others will be ignored\n");
2803 <                  fclose(datafile);
2803 >                  //fclose(datafile);
2804                    return;
2805                }
2806                sscanf(line,"%s %d %d %f",dumm, &kt1, &kt2, &crossterm_k.str_torcon[crossterm_k.nstrtor]);
# Line 2799 | Line 2815
2815                {
2816                    message_alert("Error - Too many vdwpr constants","Read Parameter");
2817                   fprintf(stderr,"Maximum number of vdwpr constants exceeded. Others will be ignored\n");
2818 <                  fclose(datafile);
2818 >                  //fclose(datafile);
2819                    return;
2820                }
2821                sscanf(line,"%s %d %d %f %f",dumm, &ii, &kk, &vdwpr_k.radius[vdwpr_k .nvdwpr],
# Line 2816 | Line 2832
2832                 if (ehpara.neheat >= 220)
2833                 {
2834                    fprintf(stderr,"Maximum number of BDHF constants exceeded. Others will be ignored\n");
2835 <                   fclose(datafile);
2835 >                   //fclose(datafile);
2836                     return;
2837                 }
2838                 sscanf( line, "%s %d %d %20c %f %f %f", dumm, &ja, &jb,
# Line 2829 | Line 2845
2845                 if (ehpara.nevhf >= 155)
2846                 {
2847                    fprintf(stderr,"Maximum number of EVHF constants exceeded. Others will be ignored\n");
2848 <                   fclose(datafile);
2848 >                   //fclose(datafile);
2849                     return;
2850                 }
2851                 sscanf( line, "%s %d %d %d %d %d %20c %f %f", dumm, &ehpara.cent[ehpara.nevhf],
# Line 2847 | Line 2863
2863                 if (epiheat.npihf >= 125)
2864                 {
2865                    fprintf(stderr,"Maximum number of PIHF constants exceeded. Others will be ignored\n");
2866 <                   fclose(datafile);
2866 >                   //fclose(datafile);
2867                     return;
2868                 }
2869                 sscanf( line, "%s %d %d %20c %f %f %f %f ", dumm,
# Line 2858 | Line 2874
2874            }
2875          }
2876  
2877 <        fclose(datafile);
2877 >        //fclose(datafile);
2878  
2879   /*
2880          fprintf(stderr," field : %s\n",field.name);

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines