#include <PDB.h>
Public Member Functions | |
| PDB (const char *pdbfilename) | |
| PDB (molfile_plugin_t *pIOHdl, void *pIOFileHdl, int numAtoms, const float *occupancy, const float *bfactor) | |
| PDB (const char *, Ambertoppar *) | |
| PDB (const char *filename, const GromacsTopFile *topology) | |
| ~PDB (void) | |
| void | write (const char *outfilename, const char *commentline=NULL) |
| int | num_atoms (void) |
| PDBAtom * | atom (int place) |
| PDBAtomList * | atoms (void) |
| void | find_extremes (BigReal *min, BigReal *max, Vector rec, BigReal frac=1.0) const |
| void | set_all_positions (Vector *) |
| void | get_all_positions (Vector *) |
| void | get_position_for_atom (Vector *, int) |
|
|
Definition at line 140 of file PDB.C. References BigReal, PDBAtom::coordinates(), PAL::data, Fclose(), Fopen(), PDBAtom::myoccupancy, NAMD_die(), NAMD_err(), new_PDBData(), PAL::next, PDBAtom::occupancy(), PDBAtomList, PDBAtomPtr, and PDBAtom::temperaturefactor(). 00140 {
00141 FILE *infile;
00142 char buf[160];
00143
00144 atomCount = 0;
00145 atomListHead = atomListTail = NULL;
00146 infile = Fopen(pdbfilename, "r");
00147 if (! infile) {
00148 char s[500];
00149 sprintf(s, "Cannot open file '%s' for input in PDB::PDB.", pdbfilename);
00150 NAMD_err(s);
00151 }
00152
00153 // loop through each line in the file and get a record
00154 while ( fgets(buf, 150, infile) ) {
00155 PDBData *newelement;
00156 char *s;
00157 for (s=buf; *s && *s!='\n'; s++) // chop off the '\n'
00158 ;
00159 *s = 0;
00160 if ( s == (buf + 149) ) {
00161 char s[500];
00162 sprintf( s, "Line too long in pdbfile %s:\n%s\n", pdbfilename, buf);
00163 NAMD_die(s);
00164 }
00165 *(s+1) = 0; // just to be on the safe side
00166
00167 // I now have a string; make a PDBData element out of it
00168 newelement = new_PDBData(buf);
00169 if (!newelement) {
00170 NAMD_die("Could not allocate PDBData.\n");
00171 }
00172 // I only know how to deal with ATOM and HETATM types; and
00173 // I want to throw away the unknown data types; so
00174 if (newelement -> type() != PDBData::ATOM &&
00175 newelement -> type() != PDBData::HETATM) {
00176 delete newelement;
00177 } else {
00178 add_atom_element( (PDBAtom *) newelement);
00179 }
00180 } // input while loop
00181 Fclose(infile);
00182
00183 // now I have a linked list, and I know the size. However,
00184 // that's got pretty slow access time for ramdom fetches, so
00185 // I'll turn it into an array
00186 {
00187
00188 #ifdef MEM_OPT_VERSION
00189 //pruning the PDBData structure into PDBCoreData by only leaving X/Y/Z, occupancy and temperaturefactor
00190 atomArray = new PDBCoreData[atomCount];
00191 if(atomArray == NULL)
00192 NAMD_die("memory allocation failed in PDB::PDB");
00193
00194 PDBAtomList *tmp = atomListHead;
00195 for(int i=0; tmp!=NULL; tmp=tmp->next, i++){
00196 const BigReal *coor = tmp->data->coordinates();
00197 atomArray[i].coor[0] = coor[0];
00198 atomArray[i].coor[1] = coor[1];
00199 atomArray[i].coor[2] = coor[2];
00200 atomArray[i].myoccupancy = tmp->data->occupancy();
00201 atomArray[i].tempfactor = tmp->data->temperaturefactor();
00202 }
00203
00204 //free the PDBAtomList
00205 tmp = atomListHead;
00206 while(tmp!=NULL){
00207 PDBAtomList *nextTmp = tmp->next;
00208 delete tmp->data;
00209 delete tmp;
00210 tmp = nextTmp;
00211 }
00212 atomListHead = atomListTail = NULL;
00213 #else
00214 atomArray = new PDBAtomPtr[atomCount];
00215 if ( atomArray == NULL )
00216 {
00217 NAMD_die("memory allocation failed in PDB::PDB");
00218 }
00219 PDBAtomList *tmp = atomListHead;
00220 int i=0; // just need to copy the pointers
00221 for (i=0, tmp = atomListHead; tmp != NULL; tmp = tmp -> next, i++) {
00222 atomArray[i] = tmp -> data;
00223 }
00224 // now delete the linked list (w/o deleting the data)
00225 PDBAtomList *tmp2;
00226 for (tmp2 = tmp = atomListHead; tmp != NULL; tmp = tmp2) {
00227 tmp2 = tmp->next;
00228 delete tmp;
00229 }
00230 atomListHead = atomListTail = NULL;
00231 #endif
00232 } // everything converted
00233
00234 }
|
|
||||||||||||||||||||||||
|
Copyright (c) 1995, 1996, 1997, 1998, 1999, 2000 by The Board of Trustees of the University of Illinois. All rights reserved. Definition at line 82 of file PDB.C. References BigReal, PDBAtom::coordinates(), NAMD_die(), PDBAtom::occupancy(), PDBAtomPtr, and PDBAtom::temperaturefactor(). 00082 {
00083 #ifdef MEM_OPT_VERSION
00084 NAMD_die("Sorry, plugin IO is not supported in the memory optimized version.");
00085 #else
00086 molfile_timestep_t ts;
00087 float *atomcoords;
00088 memset(&ts, 0, sizeof(molfile_timestep_t));
00089
00090 /* set defaults for unit cell information */
00091 ts.A = ts.B = ts.C = 0.0f;
00092 ts.alpha = ts.beta = ts.gamma = 90.0f;
00093
00094 atomCount = numAtoms;
00095
00096 atomcoords = (float *) malloc(3*numAtoms*sizeof(float));
00097 memset(atomcoords, 0, 3*numAtoms*sizeof(float));
00098 ts.coords = atomcoords;
00099
00100 if (pIOHdl->read_next_timestep(pIOFileHdl, numAtoms, &ts)) {
00101 free(atomcoords);
00102 pIOHdl->close_file_read(pIOFileHdl);
00103 NAMD_die("ERROR: failed reading atom coordinates");
00104 }
00105
00106 //load coordinates to PDB object
00107 //Note: the PDBAtom structure is very redundant in this case
00108 PDBAtom *tmpAtoms = new PDBAtom[numAtoms];
00109 atomArray = new PDBAtomPtr[numAtoms];
00110 BigReal tmpCoords[3];
00111 for(int i=0; i<numAtoms; i++) {
00112 PDBAtom *thisAtom = tmpAtoms+i;
00113 atomArray[i] = thisAtom;
00114
00115 tmpCoords[0] = atomcoords[0];
00116 tmpCoords[1] = atomcoords[1];
00117 tmpCoords[2] = atomcoords[2];
00118 atomcoords += 3; //set to the next atom
00119 thisAtom->coordinates(tmpCoords);
00120 }
00121 free(ts.coords);
00122
00123 if(occupancy) {
00124 for(int i=0; i<numAtoms; i++) {
00125 PDBAtom *thisAtom = tmpAtoms+i;
00126 thisAtom->occupancy((BigReal)occupancy[i]);
00127 }
00128 }
00129 if(bfactor) {
00130 for(int i=0; i<numAtoms; i++) {
00131 PDBAtom *thisAtom = tmpAtoms+i;
00132 thisAtom->temperaturefactor((BigReal)bfactor[i]);
00133 }
00134 }
00135 #endif
00136 }
|
|
||||||||||||
|
Definition at line 485 of file PDB.C. References Ambertoppar, parm::AtomNames, parm::AtomRes, BigReal, PDBAtom::coordinates(), Fopen(), j, PDBAtom::myoccupancy, NAMD_die(), NAMD_err(), PDBAtom::name(), parm::Natom, PDBAtomPtr, readtoeoln(), PDBAtom::residuename(), PDBAtom::residueseq(), parm::ResNames, and PDBAtom::serialnumber(). 00486 { int i,j,k;
00487 BigReal coor[3];
00488 char buf[13],resname[5],atomname[5];
00489 FILE *infile;
00490 PDBAtom *pdb;
00491
00492 if ((infile=Fopen(filename, "r")) == NULL)
00493 NAMD_err("Can't open AMBER coordinate file!");
00494
00495 readtoeoln(infile); // Skip the first line (title)
00496
00497 fscanf(infile,"%d",&atomCount); // Read in num of atoms
00498 if (atomCount != amber_data->Natom)
00499 NAMD_die("Num of atoms in coordinate file is different from that in parm file!");
00500 readtoeoln(infile);
00501
00502 #ifdef MEM_OPT_VERSION
00503 atomArray = new PDBCoreData[atomCount];
00504 #else
00505 atomArray = new PDBAtomPtr[atomCount];
00506 #endif
00507
00508 if ( atomArray == NULL )
00509 {
00510 NAMD_die("memory allocation failed in PDB::PDB");
00511 }
00512
00513 // Read in the coordinates, which are in the format of 6F12.7
00514 // Other fields are copied from "amber_data"
00515 for (i=0; i<atomCount; ++i)
00516 { // Read x,y,z coordinates
00517 for (j=0; j<3; ++j)
00518 { for (k=0; k<12; ++k)
00519 { buf[k]=getc(infile);
00520 if (buf[k]=='\n' || buf[k]=='\0' || buf[k]==EOF)
00521 NAMD_die("Error reading AMBER coordinate file!");
00522 }
00523 buf[12] = '\0';
00524 coor[j] = atof(buf);
00525 }
00526 if (i%2 == 1)
00527 readtoeoln(infile);
00528 #ifdef MEM_OPT_VERSION
00529 atomArray[i].coor[0] = coor[0];
00530 atomArray[i].coor[1] = coor[1];
00531 atomArray[i].coor[2] = coor[2];
00532 atomArray[i].myoccupancy = PDBAtom::default_occupancy;
00533 atomArray[i].tempfactor = PDBAtom::default_temperaturefactor;
00534 #else
00535 // Copy name, resname and resid from "amber_data"
00536 for (j=0; j<4; ++j)
00537 { resname[j] = amber_data->ResNames[amber_data->AtomRes[i]*4+j];
00538 atomname[j] = amber_data->AtomNames[i*4+j];
00539 }
00540 resname[4] = atomname[4] = '\0';
00541 // Create a new PDB record, and fill in its entries
00542 pdb = new PDBAtomRecord("");
00543 pdb->name(atomname);
00544 pdb->residuename(resname);
00545 pdb->serialnumber(i+1);
00546 pdb->residueseq(amber_data->AtomRes[i]+1);
00547 pdb->coordinates(coor);
00548 atomArray[i] = pdb; // Include the new record into the array
00549 #endif
00550 }
00551 }
|
|
||||||||||||
|
Definition at line 559 of file PDB.C. References BigReal, PDBAtom::coordinates(), Fopen(), GromacsTopFile::getAtom(), GromacsTopFile::getNumAtoms(), LINESIZE, PDBAtom::myoccupancy, NAMD_die(), NAMD_err(), PDBAtom::name(), PDBAtomPtr, Real, PDBAtom::residuename(), PDBAtom::residueseq(), and PDBAtom::serialnumber(). 00559 {
00560 int i;
00561 char buf[LINESIZE];
00562 FILE *infile;
00563
00564 /* open up the coordinate file */
00565 infile=Fopen(filename, "r");
00566 if (infile == NULL)
00567 NAMD_err("Can't open GROMACS coordinate file!");
00568
00569 fgets(buf,LINESIZE-1,infile); // get the title
00570 // if(strcmp(buf,topology->getSystemName()) != 0)
00571 // NAMD_die("System names in topology and coordinate files differ.");
00572
00573 fgets(buf,LINESIZE-1,infile); // get the number of atoms
00574 sscanf(buf,"%d",&atomCount);
00575 if (atomCount != topology->getNumAtoms())
00576 NAMD_die("Num of atoms in coordinate file is different from that in topology file!");
00577
00578 /* read in the atoms */
00579 #ifdef MEM_OPT_VERSION
00580 atomArray = new PDBCoreData[atomCount];
00581 #else
00582 atomArray = new PDBAtomPtr[atomCount];
00583 #endif
00584 if ( atomArray == NULL )
00585 NAMD_die("memory allocation failed in PDB::PDB");
00586
00587 #ifdef MEM_OPT_VERSION
00588 for(i=0; i<atomCount; i++){
00589 fgets(buf,LINESIZE-1,infile); // get a line
00590 char *buf2 = buf+20; // skip three fields to get to the coordinates
00591 BigReal coor[3];
00592 if(3 != sscanf(buf2,"%lf%lf%lf", &coor[0],&coor[1],&coor[2]))
00593 NAMD_die("Couldn't get three coordinates from file.");
00594
00595 coor[0] *= 10; // convert to angstroms from nanometers
00596 coor[1] *= 10;
00597 coor[2] *= 10;
00598
00599 atomArray[i].coor[0] = coor[0];
00600 atomArray[i].coor[1] = coor[1];
00601 atomArray[i].coor[2] = coor[2];
00602 atomArray[i].myoccupancy = PDBAtom::default_occupancy;
00603 atomArray[i].tempfactor = PDBAtom::default_temperaturefactor;
00604 }
00605 #else
00606 for (i=0;i<atomCount;i++) {
00607 char *buf2, resname[11], atomname[11], atmtype[11];
00608 int resnum, typenum;
00609 Real charge,mass;
00610 BigReal coor[3];
00611 PDBAtom *pdb = new PDBAtomRecord("");
00612
00613 fgets(buf,LINESIZE-1,infile); // get a line
00614 buf2 = buf+20; // skip three fields to get to the coordinates
00615 if(3 != sscanf(buf2,"%lf%lf%lf",
00616 &coor[0],&coor[1],&coor[2]))
00617 NAMD_die("Couldn't get three coordinates from file.");
00618 topology->getAtom(i,&resnum,resname,
00619 atomname,atmtype,&typenum,&charge,&mass);
00620 coor[0] *= 10; // convert to angstroms from nanometers
00621 coor[1] *= 10;
00622 coor[2] *= 10;
00623
00624 pdb->name(atomname);
00625 pdb->residuename(resname);
00626 pdb->serialnumber(i+1);
00627 pdb->residueseq(resnum+1);
00628 pdb->coordinates(coor);
00629
00630 atomArray[i] = pdb; // Include the new record into the array
00631 }
00632 #endif
00633 }
|
|
|
Definition at line 238 of file PDB.C. 00239 {
00240 #ifndef MEM_OPT_VERSION
00241 int i;
00242 for (i=atomCount-1; i>=0; i--)
00243 delete atomArray[i];
00244 #endif
00245 delete [] atomArray;
00246 atomArray = NULL;
00247 atomCount = 0;
00248 }
|
|
|
Definition at line 384 of file PDB.C. Referenced by find_extremes(), colvarproxy_namd::load_atoms(), and colvarproxy_namd::load_coords(). 00385 {
00386 if (place <0 || place >= atomCount)
00387 return NULL;
00388 return atomArray[place];
00389 }
|
|
|
Definition at line 80 of file PDB.h. References PDBAtomList. 00080 { return atomListHead; }
|
|
||||||||||||||||||||
|
Definition at line 394 of file PDB.C. References atom(), ResizeArray< Elem >::begin(), BigReal, PDBAtomPtr, ResizeArray< Elem >::resize(), SortableResizeArray< Elem >::sort(), PDBAtom::xcoor(), PDBAtom::ycoor(), and PDBAtom::zcoor(). Referenced by WorkDistrib::patchMapInit(). 00395 {
00396 SortableResizeArray<BigReal> coor;
00397 coor.resize(atomCount);
00398 SortableResizeArray<BigReal>::iterator c_i = coor.begin();
00399 #ifdef MEM_OPT_VERSION
00400 PDBCoreData *atomptr = atomArray;
00401 for(int i=0; i<atomCount; i++, atomptr++){
00402 Vector pos(atomptr->xcoor(),atomptr->ycoor(),atomptr->zcoor());
00403 c_i[i] = rec*pos;
00404 }
00405 #else
00406 PDBAtomPtr *atomptr = atomArray;
00407 for (int i=0; i<atomCount; ++i, ++atomptr) {
00408 PDBAtom *atom = *atomptr;
00409 Vector pos(atom->xcoor(),atom->ycoor(),atom->zcoor());
00410 c_i[i] = rec*pos;
00411 }
00412 #endif
00413 coor.sort();
00414 int ilow = (int)((1.0 - frac) * atomCount);
00415 if ( ilow < 0 ) ilow = 0;
00416 if ( ilow > atomCount/2 ) ilow = atomCount/2;
00417 int ihigh = atomCount - ilow - 1;
00418 BigReal span = coor[ihigh] - coor[ilow];
00419 BigReal extension = (1.0 - frac) * span / (2.0 * frac - 1.0);
00420 *max = coor[ihigh] + extension;
00421 *min = coor[ilow] - extension;
00422 }
|
|
|
Definition at line 356 of file PDB.C. References PDBAtomPtr, Vector::x, Vector::y, and Vector::z. Referenced by WorkDistrib::createAtomLists(). 00357 {
00358 #ifdef MEM_OPT_VERSION
00359 for(int i=0; i<atomCount; i++){
00360 pos[i].x = atomArray[i].coor[0];
00361 pos[i].y = atomArray[i].coor[1];
00362 pos[i].z = atomArray[i].coor[2];
00363 }
00364 #else
00365 int i;
00366 PDBAtomPtr *atomptr;
00367
00368 for (i=0, atomptr=atomArray; i<atomCount; atomptr++, i++)
00369 {
00370 pos[i].x = (*atomptr)->xcoor();
00371 pos[i].y = (*atomptr)->ycoor();
00372 pos[i].z = (*atomptr)->zcoor();
00373 }
00374 #endif
00375 }
|
|
||||||||||||
|
Definition at line 342 of file PDB.C. References PDBAtomPtr, Vector::x, Vector::y, and Vector::z. Referenced by WorkDistrib::caclNumAtomsInEachPatch(), and WorkDistrib::fillOnePatchAtoms(). 00342 {
00343 #ifdef MEM_OPT_VERSION
00344 pos->x = atomArray[aid].coor[0];
00345 pos->y = atomArray[aid].coor[1];
00346 pos->z = atomArray[aid].coor[2];
00347 #else
00348 PDBAtomPtr *atomptr = &atomArray[aid];
00349 pos->x = (*atomptr)->xcoor();
00350 pos->y = (*atomptr)->ycoor();
00351 pos->z = (*atomptr)->zcoor();
00352 #endif
00353 }
|
|
|
Definition at line 313 of file PDB.C. Referenced by WorkDistrib::caclNumAtomsInEachPatch(), NamdState::configListInit(), WorkDistrib::createAtomLists(), WorkDistrib::initAndSendHomePatch(), colvarproxy_namd::load_atoms(), colvarproxy_namd::load_coords(), WorkDistrib::patchMapInit(), and read_binary_coors(). 00314 {
00315 return atomCount;
00316 }
|
|
|
Definition at line 321 of file PDB.C. References PDBAtomPtr, Vector::x, Vector::y, and Vector::z. Referenced by read_binary_coors(). 00322 {
00323 #ifdef MEM_OPT_VERSION
00324 for(int i=0; i<atomCount; i++){
00325 atomArray[i].coor[0] = pos[i].x;
00326 atomArray[i].coor[1] = pos[i].y;
00327 atomArray[i].coor[2] = pos[i].z;
00328 }
00329 #else
00330 int i;
00331 PDBAtomPtr *atomptr;
00332
00333 for (i=0, atomptr=atomArray; i<atomCount; atomptr++, i++)
00334 {
00335 (*atomptr)->xcoor(pos[i].x);
00336 (*atomptr)->ycoor(pos[i].y);
00337 (*atomptr)->zcoor(pos[i].z);
00338 }
00339 #endif
00340 }
|
|
||||||||||||
|
Definition at line 251 of file PDB.C. References NAMD_err(), and PDBAtom::sprint(). 00252 {
00253 int i;
00254 char s[200];
00255 FILE *outfile;
00256 if ((outfile = fopen(outfilename, "w")) == NULL) {
00257 sprintf(s, "Cannot open file '%s' in PDB::write.", outfilename);
00258 NAMD_err(s);
00259 }
00260
00261 if (commentline != NULL)
00262 {
00263 sprintf(s, "REMARK %s\n", commentline);
00264 if (fputs(s, outfile) == EOF)
00265 {
00266 NAMD_err("EOF in PDB::write writing the comment line - file system full?");
00267 }
00268 }
00269
00270 for (i=0; i<atomCount; i++){ // I only contain ATOM/HETATM records
00271 #ifdef MEM_OPT_VERSION
00272 atomArray[i].sprint(s, PDBData::COLUMNS);
00273 #else
00274 atomArray[i]->sprint(s, PDBData::COLUMNS);
00275 #endif
00276 if ( (fputs(s, outfile) == EOF) ||
00277 (fputs("\n", outfile) == EOF) ) {
00278 sprintf(s, "EOF in PDB::write line %d - file system full?", i);
00279 NAMD_err(s);
00280 }
00281 }
00282 if (fputs("END\n", outfile) == EOF) {
00283 NAMD_err("EOF in PDB::write while printing 'END' -- file system full?");
00284 }
00285 if (fclose(outfile) == EOF) {
00286 NAMD_err("EOF in PDB::write while closing -- file system full?");
00287 }
00288
00289 }
|
1.3.9.1