00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035 #ifndef READPARM_H
00036 #define READPARM_H
00037
00038
00039
00040 #define USENEWCODE 1
00041
00042 #include <stdio.h>
00043 #include <stdlib.h>
00044 #include <ctype.h>
00045 #include <sys/types.h>
00046 #include <sys/stat.h>
00047 #include <errno.h>
00048 #include <string.h>
00049 #include "molfile_plugin.h"
00050
00051 #if 0
00052 #define _REAL double
00053 #define DBLFMT "%lf"
00054 #else
00055 #define _REAL float
00056 #define DBLFMT "%f"
00057 #endif
00058
00059 typedef struct parm {
00060 char ititl[81];
00061 int IfBox, Nmxrs, IfCap,
00062 Natom, Ntypes, Nbonh, Mbona, Ntheth, Mtheta,
00063 Nphih, Mphia, Nhparm, Nparm, Nnb, Nres,
00064 Nbona, Ntheta, Nphia, Numbnd, Numang, Nptra,
00065 Natyp, Nphb, Nat3, Ntype2d, Nttyp, Nspm, Iptres, Nspsol,
00066 Ipatm, Natcap;
00067 char *AtomNames, *ResNames, *AtomSym, *AtomTree;
00068 _REAL *Charges, *Masses, *Rk, *Req, *Tk, *Teq, *Pk, *Pn, *Phase,
00069 *Solty, *Cn1, *Cn2, *HB12, *HB6;
00070 _REAL Box[3], Cutcap, Xcap, Ycap, Zcap;
00071 int *Iac, *Iblo, *Cno, *Ipres, *ExclAt, *TreeJoin,
00072 *AtomRes, *BondHAt1, *BondHAt2, *BondHNum, *BondAt1, *BondAt2,
00073 *BondNum, *AngleHAt1, *AngleHAt2, *AngleHAt3, *AngleHNum,
00074 *AngleAt1, *AngleAt2, *AngleAt3, *AngleNum, *DihHAt1,
00075 *DihHAt2, *DihHAt3, *DihHAt4, *DihHNum, *DihAt1, *DihAt2,
00076 *DihAt3, *DihAt4, *DihNum, *Boundary;
00077 } parmstruct;
00078
00079
00080 namespace {
00081 class ReadPARM {
00082 public:
00083 ReadPARM() {popn = 0;}
00084 ~ReadPARM(void) {}
00085
00086 int popn;
00087 parmstruct *prm;
00088 FILE *open_parm_file(const char *name);
00089 void close_parm_file(FILE *fileptr);
00090 char *get(int size);
00091 int preadln(FILE *file, char *string);
00092 int readparm(FILE *file);
00093 void get_parm_atom(int, char *, char *, char *, char *, int *, float *,
00094 float *);
00095
00096 void get_parm_bond(int, int fromAtom[], int toAtom[]);
00097 void get_hydrogen_bond(int, int fromAtom[], int toAtom[]);
00098 int get_parm_natoms();
00099 int get_parm_nbonds();
00100 int get_parm_boxInfo();
00101 int read_fortran_12I6(FILE *fp, int *data, int count);
00102 };
00103 }
00104
00105
00106
00107
00108
00109
00110
00111
00112 static int readtoeoln(FILE *f) {
00113 int c;
00114
00115
00116 while((c = getc(f)) != '\n') {
00117 if (c == EOF)
00118 return -1;
00119 }
00120
00121 return 0;
00122 }
00123
00124
00125
00126
00127
00128
00129
00130
00131
00132 FILE *ReadPARM::open_parm_file(const char *name) {
00133 struct stat buf;
00134 char cbuf[120];
00135 int length, compressed;
00136 FILE *fp;
00137
00138 length = strlen(name);
00139 compressed = 0;
00140
00141 strcpy(cbuf, name);
00142
00143
00144
00145
00146
00147 if (stat(cbuf, &buf) == -1) {
00148 switch (errno) {
00149 case ENOENT: {
00150 if (!compressed) {
00151 strcat(cbuf, ".Z");
00152 if (stat(cbuf, &buf) == -1) {
00153 printf("%s, %s: does not exist\n",
00154 name, cbuf);
00155 return(NULL);
00156 }
00157 compressed++;
00158
00159
00160 } else {
00161 cbuf[length-2] = '\0';
00162 if (stat(cbuf, &buf) == -1) {
00163 printf("%s, %s: does not exist\n",
00164 name, cbuf);
00165 return(NULL);
00166 }
00167 compressed = 0;
00168 }
00169 break;
00170 }
00171 default:
00172 return(NULL);
00173 }
00174 }
00175
00176
00177
00178
00179 #if defined(_MSC_VER)
00180 if (compressed) {
00181
00182 printf("Cannot load compressed PARM files on Windows.\n");
00183 return NULL;
00184 }
00185 #else
00186 if (compressed) {
00187 char pcmd[120];
00188 popn = 1;
00189
00190 sprintf(pcmd, "zcat %s", cbuf);
00191 if ((fp = popen(pcmd, "r")) == NULL) {
00192 perror(pcmd);
00193 return NULL;
00194 }
00195 }
00196 #endif
00197 else {
00198 if ((fp = fopen(cbuf, "r")) == NULL) {
00199 perror(cbuf);
00200 return NULL;
00201 }
00202 }
00203 return(fp);
00204 }
00205
00206
00207
00208
00209
00210
00211
00212
00213 void ReadPARM::close_parm_file(FILE *fileptr) {
00214 #if defined(_MSC_VER)
00215 if (popn) {
00216 printf("pclose() no such function on win32!\n");
00217 } else {
00218 if (fclose(fileptr) == -1)
00219 perror("fclose");
00220 }
00221 #else
00222 if (popn) {
00223 if (pclose(fileptr) == -1)
00224 perror("pclose");
00225 } else {
00226 if (fclose(fileptr) == -1)
00227 perror("fclose");
00228 }
00229 #endif
00230 }
00231
00232
00233
00234
00235
00236 char *ReadPARM::get(int size) {
00237 char *ptr;
00238
00239 #ifdef DEBUG
00240 printf("malloc %d\n", size);
00241 fflush(stdout);
00242 #endif
00243 if (size ==0)
00244 return((char *) NULL);
00245
00246 if ((ptr = (char *) malloc((unsigned)size)) == NULL) {
00247 printf("malloc %d", size);
00248 fflush(stdout);
00249 perror("malloc err:");
00250 fprintf(stderr, "Exiting due to ReadPARM memory allocation error.\n");
00251 }
00252 return(ptr);
00253 }
00254
00255
00256
00257
00258 int ReadPARM::preadln(FILE *file, char *string) {
00259 int i, j;
00260
00261 for (i=0; i<81; i++) {
00262 if ((j = getc(file)) == EOF) {
00263 printf("Error: unexpected EOF in Parm file\n");
00264 return MOLFILE_ERROR;
00265 }
00266
00267 string[i] = (char) j;
00268 if (string[i] == '\n') {
00269 break;
00270 }
00271 }
00272
00273 if (i == 80 && string[i] != '\n') {
00274 printf("Error: line too long in Parm file:\n%.80s", string);
00275 return MOLFILE_ERROR;
00276 }
00277
00278 return 0;
00279 }
00280
00281
00282
00283
00284
00285
00286
00287 int ReadPARM::readparm(FILE *file) {
00288
00289
00290
00291
00292
00293
00294 _REAL *H;
00295 int i, res, ifpert;
00296 int *buffer;
00297
00298 prm = (parmstruct *) get(sizeof(parmstruct));
00299 if (prm == NULL) {
00300 return MOLFILE_ERROR;
00301 }
00302
00303
00304 if (preadln(file, prm->ititl) != 0) {
00305 return MOLFILE_ERROR;
00306 }
00307
00308
00309 #if !defined(USENEWCODE)
00310 fscanf(file, f9118,
00311 &prm->Natom, &prm->Ntypes, &prm->Nbonh, &prm->Mbona,
00312 &prm->Ntheth, &prm->Mtheta, &prm->Nphih, &prm->Mphia,
00313 &prm->Nhparm, &prm->Nparm, &prm->Nnb, &prm->Nres);
00314
00315 fscanf(file, f9118,
00316 &prm->Nbona, &prm->Ntheta, &prm->Nphia, &prm->Numbnd,
00317 &prm->Numang, &prm->Nptra, &prm->Natyp, &prm->Nphb,
00318 &ifpert, &idum, &idum, &idum);
00319
00320 fscanf(file, " %d %d %d %d %d %d",
00321 &idum, &idum,&idum,&prm->IfBox,&prm->Nmxrs,&prm->IfCap);
00322 #else
00323 buffer = new int[30];
00324 if (!read_fortran_12I6(file,buffer,30)) {
00325 return MOLFILE_ERROR;
00326 }
00327 prm->Natom = buffer[0];
00328 prm->Ntypes = buffer[1];
00329 prm->Nbonh = buffer[2];
00330 prm->Mbona = buffer[3];
00331 prm->Ntheth = buffer[4];
00332 prm->Mtheta = buffer[5];
00333 prm->Nphih = buffer[6];
00334 prm->Mphia = buffer[7];
00335 prm->Nhparm = buffer[8];
00336 prm->Nparm = buffer[9];
00337 prm->Nnb = buffer[10];
00338 prm->Nres = buffer[11];
00339 prm->Nbona = buffer[12];
00340 prm->Ntheta = buffer[13];
00341 prm->Nphia = buffer[14];
00342 prm->Numbnd = buffer[15];
00343 prm->Numang = buffer[16];
00344 prm->Nptra = buffer[17];
00345 prm->Natyp = buffer[18];
00346 prm->Nphb = buffer[19];
00347 ifpert = buffer[20];
00348
00349 prm->IfBox = buffer[27];
00350 prm->Nmxrs = buffer[28];
00351 prm->IfCap = buffer[29];
00352 delete [] buffer;
00353 #endif
00354 readtoeoln(file);
00355
00356
00357 if (ifpert) {
00358 printf("not equipped to read perturbation prmtop\n");
00359 free(prm);
00360 return MOLFILE_ERROR;
00361 }
00362
00363
00364
00365 prm->Nat3 = 3 * prm->Natom;
00366 prm->Ntype2d = prm->Ntypes * prm->Ntypes;
00367 prm->Nttyp = prm->Ntypes*(prm->Ntypes+1)/2;
00368
00369
00370
00371
00372 prm->AtomNames = (char *) get(4*prm->Natom+81);
00373 prm->Charges = (_REAL *) get(sizeof(_REAL)*prm->Natom);
00374 prm->Masses = (_REAL *) get(sizeof(_REAL)*prm->Natom);
00375 prm->Iac = (int *) get(sizeof(int)*prm->Natom);
00376 prm->Iblo = (int *) get(sizeof(int)*prm->Natom);
00377 prm->Cno = (int *) get(sizeof(int)* prm->Ntype2d);
00378 prm->ResNames = (char *) get(4* prm->Nres+81);
00379 prm->Ipres = (int *) get(sizeof(int)*( prm->Nres+1));
00380 prm->Rk = (_REAL *) get(sizeof(_REAL)* prm->Numbnd);
00381 prm->Req = (_REAL *) get(sizeof(_REAL)* prm->Numbnd);
00382 prm->Tk = (_REAL *) get(sizeof(_REAL)* prm->Numang);
00383 prm->Teq = (_REAL *) get(sizeof(_REAL)* prm->Numang);
00384 prm->Pk = (_REAL *) get(sizeof(_REAL)* prm->Nptra);
00385 prm->Pn = (_REAL *) get(sizeof(_REAL)* prm->Nptra);
00386 prm->Phase = (_REAL *) get(sizeof(_REAL)* prm->Nptra);
00387 prm->Solty = (_REAL *) get(sizeof(_REAL)* prm->Natyp);
00388 prm->Cn1 = (_REAL *) get(sizeof(_REAL)* prm->Nttyp);
00389 prm->Cn2 = (_REAL *) get(sizeof(_REAL)* prm->Nttyp);
00390 prm->BondHAt1 = (int *) get(sizeof(int)* prm->Nbonh);
00391 prm->BondHAt2 = (int *) get(sizeof(int)* prm->Nbonh);
00392 prm->BondHNum = (int *) get(sizeof(int)* prm->Nbonh);
00393 prm->BondAt1 = (int *) get(sizeof(int)* prm->Nbona);
00394 prm->BondAt2 = (int *) get(sizeof(int)* prm->Nbona);
00395 prm->BondNum = (int *) get(sizeof(int)* prm->Nbona);
00396 prm->AngleHAt1 = (int *) get(sizeof(int)* prm->Ntheth);
00397 prm->AngleHAt2 = (int *) get(sizeof(int)* prm->Ntheth);
00398 prm->AngleHAt3 = (int *) get(sizeof(int)* prm->Ntheth);
00399 prm->AngleHNum = (int *) get(sizeof(int)* prm->Ntheth);
00400 prm->AngleAt1 = (int *) get(sizeof(int)* prm->Ntheta);
00401 prm->AngleAt2 = (int *) get(sizeof(int)*prm->Ntheta);
00402 prm->AngleAt3 = (int *) get(sizeof(int)*prm->Ntheta);
00403 prm->AngleNum = (int *) get(sizeof(int)*prm->Ntheta);
00404 prm->DihHAt1 = (int *) get(sizeof(int)*prm->Nphih);
00405 prm->DihHAt2 = (int *) get(sizeof(int)*prm->Nphih);
00406 prm->DihHAt3 = (int *) get(sizeof(int)*prm->Nphih);
00407 prm->DihHAt4 = (int *) get(sizeof(int)*prm->Nphih);
00408 prm->DihHNum = (int *) get(sizeof(int)*prm->Nphih);
00409 prm->DihAt1 = (int *) get(sizeof(int)*prm->Nphia);
00410 prm->DihAt2 = (int *) get(sizeof(int)*prm->Nphia);
00411 prm->DihAt3 = (int *) get(sizeof(int)*prm->Nphia);
00412 prm->DihAt4 = (int *) get(sizeof(int)*prm->Nphia);
00413 prm->DihNum = (int *) get(sizeof(int)*prm->Nphia);
00414 prm->ExclAt = (int *) get(sizeof(int)*prm->Nnb);
00415 prm->HB12 = (_REAL *) get(sizeof(_REAL)*prm->Nphb);
00416 prm->HB6 = (_REAL *) get(sizeof(_REAL)*prm->Nphb);
00417 prm->AtomSym = (char *) get(4*prm->Natom+81);
00418 prm->AtomTree = (char *) get(4*prm->Natom+81);
00419 prm->TreeJoin = (int *) get(sizeof(int)*prm->Natom);
00420 prm->AtomRes = (int *) get(sizeof(int)*prm->Natom);
00421
00422
00423
00424
00425 for (i=0; i<(prm->Natom/20 + (prm->Natom%20 ? 1 : 0)); i++) {
00426 preadln(file, &prm->AtomNames[i*80]);
00427 }
00428
00429
00430
00431
00432
00433
00434 for (i=0; i<prm->Natom; i++)
00435 fscanf(file, " " DBLFMT, &prm->Charges[i]);
00436 readtoeoln(file);
00437
00438
00439
00440
00441 for (i=0; i<prm->Natom; i++)
00442 fscanf(file, " " DBLFMT, &prm->Masses[i]);
00443 readtoeoln(file);
00444
00445
00446
00447
00448 #if !defined(USENEWCODE)
00449 for (i=0; i<prm->Natom; i++)
00450 fscanf(file, " %d", &prm->Iac[i]);
00451 #else
00452 if (!read_fortran_12I6(file, prm->Iac, prm->Natom)) {
00453 return MOLFILE_ERROR;
00454 }
00455 #endif
00456 readtoeoln(file);
00457
00458
00459
00460
00461 #if !defined(USENEWCODE)
00462 for (i=0; i<prm->Natom; i++)
00463 fscanf(file, " %d", &prm->Iblo[i]);
00464 #else
00465 if (!read_fortran_12I6(file, prm->Iblo, prm->Natom)) {
00466 return MOLFILE_ERROR;
00467 }
00468 #endif
00469 readtoeoln(file);
00470
00471
00472
00473
00474 #if !defined(USENEWCODE)
00475 for (i=0; i<prm->Ntype2d; i++)
00476 fscanf(file, " %d", &prm->Cno[i]);
00477 #else
00478 if (!read_fortran_12I6(file, prm->Cno, prm->Ntype2d)) {
00479 return MOLFILE_ERROR;
00480 }
00481 #endif
00482 readtoeoln(file);
00483
00484
00485
00486
00487 for (i=0; i<(prm->Nres/20 + (prm->Nres%20 ? 1 : 0)); i++)
00488 preadln(file, &prm->ResNames[i*80]);
00489
00490
00491
00492
00493 #if !defined(USENEWCODE)
00494 for (i=0; i<prm->Nres; i++)
00495 fscanf(file, " %d", &prm->Ipres[i]);
00496 #else
00497 if (!read_fortran_12I6(file, prm->Ipres, prm->Nres)) {
00498 return MOLFILE_ERROR;
00499 }
00500 #endif
00501 prm->Ipres[prm->Nres] = prm->Natom + 1;
00502 readtoeoln(file);
00503
00504
00505
00506
00507 for (i=0; i< prm->Numbnd; i++)
00508 fscanf(file, " " DBLFMT, &prm->Rk[i]);
00509 readtoeoln(file);
00510
00511
00512
00513
00514 for (i=0; i< prm->Numbnd; i++)
00515 fscanf(file, " " DBLFMT, &prm->Req[i]);
00516 readtoeoln(file);
00517
00518
00519
00520
00521 for (i=0; i< prm->Numang; i++)
00522 fscanf(file, " " DBLFMT, &prm->Tk[i]);
00523 readtoeoln(file);
00524
00525
00526
00527
00528 for (i=0; i< prm->Numang; i++)
00529 fscanf(file, " " DBLFMT, &prm->Teq[i]);
00530 readtoeoln(file);
00531
00532
00533
00534
00535 for (i=0; i< prm->Nptra; i++)
00536 fscanf(file, " " DBLFMT, &prm->Pk[i]);
00537 readtoeoln(file);
00538
00539
00540
00541
00542 for (i=0; i< prm->Nptra; i++)
00543 fscanf(file, " " DBLFMT, &prm->Pn[i]);
00544 readtoeoln(file);
00545
00546
00547
00548
00549 for (i=0; i< prm->Nptra; i++)
00550 fscanf(file, " " DBLFMT, &prm->Phase[i]);
00551 readtoeoln(file);
00552
00553
00554
00555
00556 for (i=0; i< prm->Natyp; i++)
00557 fscanf(file, " " DBLFMT, &prm->Solty[i]);
00558 readtoeoln(file);
00559
00560
00561
00562
00563
00564 for (i=0; i< prm->Nttyp; i++)
00565 fscanf(file, " " DBLFMT, &prm->Cn1[i]);
00566 readtoeoln(file);
00567
00568
00569
00570
00571
00572 for (i=0; i< prm->Nttyp; i++)
00573 fscanf(file, " " DBLFMT, &prm->Cn2[i]);
00574 readtoeoln(file);
00575
00576
00577
00578
00579
00580
00581
00582 #if !defined(USENEWCODE)
00583 for (i=0; i<prm->Nbonh; i++)
00584 fscanf(file, " %d %d %d",
00585 &prm->BondHAt1[i], &prm->BondHAt2[i], &prm->BondHNum[i]);
00586 #else
00587 buffer = new int[3*prm->Nbonh];
00588 if (!read_fortran_12I6(file, buffer, 3*prm->Nbonh)) {
00589 return MOLFILE_ERROR;
00590 }
00591 for (i=0; i<prm->Nbonh; i++) {
00592 prm->BondHAt1[i] = buffer[3*i];
00593 prm->BondHAt2[i] = buffer[3*i+1];
00594 prm->BondHNum[i] = buffer[3*i+2];
00595 }
00596 delete [] buffer;
00597 #endif
00598 readtoeoln(file);
00599
00600
00601
00602
00603
00604
00605
00606 #if !defined(USENEWCODE)
00607 for (i=0; i<prm->Nbona; i++)
00608 fscanf(file, " %d %d %d",
00609 &prm->BondAt1[i], &prm->BondAt2[i], &prm->BondNum[i]);
00610 #else
00611 buffer = new int[3*prm->Nbona];
00612 if (!read_fortran_12I6(file, buffer, 3*prm->Nbona)) {
00613 return MOLFILE_ERROR;
00614 }
00615 for (i=0; i<prm->Nbona; i++) {
00616 prm->BondAt1[i] = buffer[3*i];
00617 prm->BondAt2[i] = buffer[3*i+1];
00618 prm->BondNum[i] = buffer[3*i+2];
00619 }
00620 delete [] buffer;
00621 #endif
00622 readtoeoln(file);
00623
00624
00625
00626
00627
00628
00629
00630
00631 #if !defined(USENEWCODE)
00632 for (i=0; i<prm->Ntheth; i++)
00633 fscanf(file, " %d %d %d %d",
00634 &prm->AngleHAt1[i], &prm->AngleHAt2[i],
00635 &prm->AngleHAt3[i], &prm->AngleHNum[i]);
00636 #else
00637 buffer = new int[4*prm->Ntheth];
00638 if (!read_fortran_12I6(file, buffer, 4*prm->Ntheth)) {
00639 return MOLFILE_ERROR;
00640 }
00641 for (i=0; i<prm->Ntheth; i++) {
00642 prm->AngleHAt1[i] = buffer[4*i];
00643 prm->AngleHAt2[i] = buffer[4*i+1];
00644 prm->AngleHAt3[i] = buffer[4*i+2];
00645 prm->AngleHNum[i] = buffer[4*i+3];
00646 }
00647 delete [] buffer;
00648 #endif
00649 readtoeoln(file);
00650
00651
00652
00653
00654
00655
00656
00657
00658 #if !defined(USENEWCODE)
00659 for (i=0; i<prm->Ntheta; i++)
00660 fscanf(file, " %d %d %d %d",
00661 &prm->AngleAt1[i], &prm->AngleAt2[i],
00662 &prm->AngleAt3[i], &prm->AngleNum[i]);
00663 #else
00664 buffer = new int[4*prm->Ntheta];
00665 if (!read_fortran_12I6(file, buffer, 4*prm->Ntheta)) {
00666 return MOLFILE_ERROR;
00667 }
00668 for (i=0; i<prm->Ntheta; i++) {
00669 prm->AngleAt1[i] = buffer[4*i];
00670 prm->AngleAt2[i] = buffer[4*i+1];
00671 prm->AngleAt3[i] = buffer[4*i+2];
00672 prm->AngleNum[i] = buffer[4*i+3];
00673 }
00674 delete [] buffer;
00675 #endif
00676 readtoeoln(file);
00677
00678
00679
00680
00681
00682
00683
00684
00685
00686 #if !defined(USENEWCODE)
00687 for (i=0; i<prm->Nphih; i++)
00688 fscanf(file, " %d %d %d %d %d",
00689 &prm->DihHAt1[i], &prm->DihHAt2[i], &prm->DihHAt3[i],
00690 &prm->DihHAt4[i], &prm->DihHNum[i]);
00691 #else
00692 buffer = new int[5*prm->Nphih];
00693 if (!read_fortran_12I6(file, buffer, 5*prm->Nphih)) {
00694 return MOLFILE_ERROR;
00695 }
00696 for (i=0; i<prm->Nphih; i++) {
00697 prm->DihHAt1[i] = buffer[5*i];
00698 prm->DihHAt2[i] = buffer[5*i+1];
00699 prm->DihHAt3[i] = buffer[5*i+2];
00700 prm->DihHAt4[i] = buffer[5*i+3];
00701 prm->DihHNum[i] = buffer[5*i+4];
00702 }
00703 delete [] buffer;
00704 #endif
00705 readtoeoln(file);
00706
00707
00708
00709
00710
00711
00712
00713
00714
00715 #if !defined(USENEWCODE)
00716 for (i=0; i<prm->Nphia; i++) {
00717 fscanf(file, " %d %d %d %d %d",
00718 &prm->DihAt1[i], &prm->DihAt2[i], &prm->DihAt3[i],
00719 &prm->DihAt4[i], &prm->DihNum[i]);
00720 }
00721 #else
00722 buffer = new int[5*prm->Nphia];
00723 if (!read_fortran_12I6(file, buffer, 5*prm->Nphia)) {
00724 return MOLFILE_ERROR;
00725 }
00726 for (i=0; i<prm->Nphia; i++) {
00727 prm->DihAt1[i] = buffer[5*i];
00728 prm->DihAt2[i] = buffer[5*i+1];
00729 prm->DihAt3[i] = buffer[5*i+2];
00730 prm->DihAt4[i] = buffer[5*i+3];
00731 prm->DihNum[i] = buffer[5*i+4];
00732 }
00733 delete [] buffer;
00734 #endif
00735 readtoeoln(file);
00736
00737
00738
00739
00740 #if !defined(USENEWCODE)
00741 for (i=0; i<prm->Nnb; i++)
00742 fscanf(file, " %d", &prm->ExclAt[i]);
00743 #else
00744 if (!read_fortran_12I6(file, prm->ExclAt, prm->Nnb)) {
00745 return MOLFILE_ERROR;
00746 }
00747 #endif
00748 readtoeoln(file);
00749
00750
00751
00752
00753 for (i=0; i<prm->Nphb; i++)
00754 fscanf(file, " " DBLFMT, &prm->HB12[i]);
00755 readtoeoln(file);
00756
00757
00758
00759
00760 for (i=0; i<prm->Nphb; i++)
00761 fscanf(file, " " DBLFMT, &prm->HB6[i]);
00762 readtoeoln(file);
00763
00764
00765
00766
00767 H = (_REAL *) get(prm->Nphb * sizeof(_REAL));
00768 for (i=0; i<prm->Nphb; i++)
00769 fscanf(file, " " DBLFMT, &H[i]);
00770 free((char *)H);
00771 readtoeoln(file);
00772
00773
00774
00775
00776 for (i=0; i<(prm->Natom/20 + (prm->Natom%20 ? 1 : 0)); i++)
00777 preadln(file, &prm->AtomSym[i*80]);
00778
00779
00780
00781
00782 for (i=0; i<(prm->Natom/20 + (prm->Natom%20 ? 1 : 0)); i++)
00783 preadln(file, &prm->AtomTree[i*80]);
00784
00785
00786
00787
00788 #if !defined(USENEWCODE)
00789 for (i=0; i<prm->Natom; i++)
00790 fscanf(file, " %d", &prm->TreeJoin[i]);
00791 #else
00792 if (!read_fortran_12I6(file, prm->TreeJoin, prm->Natom)) {
00793 return MOLFILE_ERROR;
00794 }
00795 #endif
00796 readtoeoln(file);
00797
00798
00799
00800
00801
00802
00803 #if !defined(USENEWCODE)
00804 for (i=0; i<prm->Natom; i++)
00805 fscanf(file, " %d", &prm->AtomRes[i]);
00806 #else
00807 if (!read_fortran_12I6(file, prm->AtomRes, prm->Natom)) {
00808 return MOLFILE_ERROR;
00809 }
00810 #endif
00811 res = 0;
00812 for (i=0; i<prm->Natom; i++) {
00813 if (i+1 == prm->Ipres[res+1])
00814 res++;
00815 prm->AtomRes[i] = res;
00816 }
00817
00818
00819
00820
00821 if (!prm->IfBox) {
00822 prm->Nspm = 1;
00823 prm->Boundary = (int *) get(sizeof(int)*prm->Nspm);
00824 prm->Boundary[0] = prm->Natom;
00825 } else {
00826 readtoeoln(file);
00827 #if !defined(USENEWCODE)
00828 fscanf(file, " %d %d %d", &prm->Iptres, &prm->Nspm,
00829 &prm->Nspsol);
00830 #else
00831 buffer = new int[3];
00832 if (!read_fortran_12I6(file, buffer, 3)) {
00833 return MOLFILE_ERROR;
00834 }
00835 prm->Iptres = buffer[0];
00836 prm->Nspm = buffer[1];
00837 prm->Nspsol = buffer[2];
00838 delete [] buffer;
00839 #endif
00840 readtoeoln(file);
00841 prm->Boundary = (int *) get(sizeof(int)*prm->Nspm);
00842 #if !defined(USENEWCODE)
00843 for (i=0; i<prm->Nspm; i++)
00844 fscanf(file, " %d", &prm->Boundary[i]);
00845 #else
00846 if (!read_fortran_12I6(file, prm->Boundary, prm->Nspm)) {
00847 return MOLFILE_ERROR;
00848 }
00849 #endif
00850 readtoeoln(file);
00851 fscanf(file, " " DBLFMT " " DBLFMT " " DBLFMT,
00852 &prm->Box[0], &prm->Box[1], &prm->Box[2]);
00853 readtoeoln(file);
00854 if (prm->Iptres)
00855 prm->Ipatm = prm->Ipres[prm->Iptres] - 1;
00856
00857 }
00858
00859
00860
00861
00862 if (prm->IfCap) {
00863
00864
00865 fscanf(file, " %d " DBLFMT " " DBLFMT " " DBLFMT " " DBLFMT,
00866 &prm->Natcap, &prm->Cutcap,
00867 &prm->Xcap, &prm->Ycap, &prm->Zcap);
00868 }
00869
00870 return MOLFILE_SUCCESS;
00871 }
00872
00873
00874 void ReadPARM::get_parm_atom(int i, char *name, char *atype, char *resname,
00875 char *segname, int *resid, float *q, float *m) {
00876 int nres = prm->Nres;
00877
00878 int j,k;
00879 int flag = 0;
00880 char *blank = (char *) " ";
00881
00882 *q = prm->Charges[i];
00883 *m = prm->Masses[i];
00884
00885 for (k = 0; k < 4; k++) {
00886 if (prm->AtomNames[i*4+k] == *blank)
00887 name[k] = '\0';
00888 else
00889 name[k] = prm->AtomNames[i*4+k];
00890 }
00891 name[k] = '\0';
00892
00893 for (k = 0; k < 4; k++) {
00894 if ((prm->AtomSym[i*4+k]) == *blank)
00895 atype[k] = '\0';
00896 else
00897 atype[k] = prm->AtomSym[i*4+k];
00898 }
00899 atype[k] = '\0';
00900
00901 for (j = 0; j < nres-1; j++)
00902 if (((i+1) >= prm->Ipres[j]) && ((i+1) < prm->Ipres[j+1])) {
00903 *resid = j;
00904 resname[0] = prm->ResNames[j*4];
00905 resname[1] = prm->ResNames[j*4+1];
00906 resname[2] = prm->ResNames[j*4+2];
00907 resname[3] = '\0';
00908 flag = 1;
00909 }
00910 if (flag == 0) {
00911 *resid = j;
00912 resname[0] = prm->ResNames[j*4];
00913 resname[1] = prm->ResNames[j*4+1];
00914 resname[2] = prm->ResNames[j*4+2];
00915 resname[3] = '\0';
00916 flag = 1;
00917 }
00918
00919 segname[0] = '\0';
00920
00921 }
00922
00923 void ReadPARM::get_parm_bond (int i, int fromAtom[], int toAtom[]) {
00924
00925 if (i < prm->Nbona) {
00926 fromAtom[i] = (int) ((prm->BondAt1[i])/3 + 1);
00927 toAtom[i] = (int) ((prm->BondAt2[i])/3 + 1);
00928 }
00929 else get_hydrogen_bond (i, fromAtom, toAtom);
00930 }
00931
00932 void ReadPARM::get_hydrogen_bond(int i, int fromAtom[], int toAtom[]) {
00933 fromAtom[i] = (int) ((prm->BondHAt1[i-prm->Nbona])/3 + 1);
00934 toAtom[i] = (int) ((prm->BondHAt2[i-prm->Nbona])/3 + 1);
00935 }
00936
00937
00938 int ReadPARM::get_parm_natoms() {return prm->Natom;}
00939
00940 int ReadPARM::get_parm_nbonds() {return (prm->Nbona + prm->Nbonh);}
00941
00942 int ReadPARM::get_parm_boxInfo() {return(prm->IfBox);}
00943
00944
00945
00946
00947
00948
00949
00950 int ReadPARM::read_fortran_12I6(FILE *fp, int *data, int count) {
00951 int i, j;
00952 char buf[7];
00953
00954 for (i=0; i<count; ++i) {
00955 for (j=0; j<6; ++j) {
00956 buf[j]=getc(fp);
00957 if (buf[j]=='\n' || buf[j]=='\0' || buf[j]==EOF)
00958 return 0;
00959 }
00960 buf[6] = '\0';
00961
00962 if (sscanf(buf,"%d",data+i) != 1)
00963 return 0;
00964
00965 if (i%12==11 && i<count-1)
00966 readtoeoln(fp);
00967 }
00968
00969 return 1;
00970 }
00971
00972
00973 #endif
00974