hillclimber 0.1.6__cp313-cp313-macosx_15_0_x86_64.whl

plumed/_lib/include/plumed/molfile/periodic_table.h

@@ -0,0 +1,248 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+University of Illinois Open Source License
+Copyright 2003 Theoretical and Computational Biophysics Group, 
+All rights reserved.
+
+Developed by:		Theoretical and Computational Biophysics Group
+			University of Illinois at Urbana-Champaign
+			http://www.ks.uiuc.edu/
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the Software), to deal with 
+the Software without restriction, including without limitation the rights to 
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies 
+of the Software, and to permit persons to whom the Software is furnished to 
+do so, subject to the following conditions:
+
+Redistributions of source code must retain the above copyright notice, 
+this list of conditions and the following disclaimers.
+
+Redistributions in binary form must reproduce the above copyright notice, 
+this list of conditions and the following disclaimers in the documentation 
+and/or other materials provided with the distribution.
+
+Neither the names of Theoretical and Computational Biophysics Group, 
+University of Illinois at Urbana-Champaign, nor the names of its contributors 
+may be used to endorse or promote products derived from this Software without 
+specific prior written permission.
+
+THE SOFTWARE IS PROVIDED AS IS, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL 
+THE CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 
+OTHER DEALINGS WITH THE SOFTWARE.
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+#ifndef __PLUMED_molfile_periodic_table_h
+#define __PLUMED_molfile_periodic_table_h
+/***************************************************************************
+ * RCS INFORMATION:
+ *
+ *      $RCSfile: periodic_table.h,v $
+ *      $Author: johns $       $Locker:  $             $State: Exp $
+ *      $Revision: 1.12 $       $Date: 2009/01/21 17:45:41 $
+ *
+ ***************************************************************************/
+
+/*
+ * periodic table of elements and helper functions to convert
+ * ordinal numbers to labels and back.
+ * all tables and functions are declared static, so that it
+ * can be safely included by all plugins that may need it.
+ *
+ * 2002-2009 akohlmey@cmm.chem.upenn.edu, vmd@ks.uiuc.edu
+ */
+
+#include <string.h>
+#include <ctype.h>
+
+namespace PLMD{
+namespace molfile{
+/* periodic table of elements for translation of ordinal to atom type */
+static const char *pte_label[] = { 
+    "X",  "H",  "He", "Li", "Be", "B",  "C",  "N",  "O",  "F",  "Ne",
+    "Na", "Mg", "Al", "Si", "P" , "S",  "Cl", "Ar", "K",  "Ca", "Sc",
+    "Ti", "V",  "Cr", "Mn", "Fe", "Co", "Ni", "Cu", "Zn", "Ga", "Ge", 
+    "As", "Se", "Br", "Kr", "Rb", "Sr", "Y",  "Zr", "Nb", "Mo", "Tc",
+    "Ru", "Rh", "Pd", "Ag", "Cd", "In", "Sn", "Sb", "Te", "I",  "Xe",
+    "Cs", "Ba", "La", "Ce", "Pr", "Nd", "Pm", "Sm", "Eu", "Gd", "Tb",
+    "Dy", "Ho", "Er", "Tm", "Yb", "Lu", "Hf", "Ta", "W",  "Re", "Os",
+    "Ir", "Pt", "Au", "Hg", "Tl", "Pb", "Bi", "Po", "At", "Rn", "Fr",
+    "Ra", "Ac", "Th", "Pa", "U",  "Np", "Pu", "Am", "Cm", "Bk", "Cf",
+    "Es", "Fm", "Md", "No", "Lr", "Rf", "Db", "Sg", "Bh", "Hs", "Mt",
+    "Ds", "Rg"
+};
+static const int nr_pte_entries = sizeof(pte_label) / sizeof(char *);
+
+/* corresponding table of masses. */
+static const float pte_mass[] = { 
+    /* X  */ 0.00000, 1.00794, 4.00260, 6.941, 9.012182, 10.811,  
+    /* C  */ 12.0107, 14.0067, 15.9994, 18.9984032, 20.1797, 
+    /* Na */ 22.989770, 24.3050, 26.981538, 28.0855, 30.973761,
+    /* S  */ 32.065, 35.453, 39.948, 39.0983, 40.078, 44.955910,
+    /* Ti */ 47.867, 50.9415, 51.9961, 54.938049, 55.845, 58.9332,
+    /* Ni */ 58.6934, 63.546, 65.409, 69.723, 72.64, 74.92160, 
+    /* Se */ 78.96, 79.904, 83.798, 85.4678, 87.62, 88.90585, 
+    /* Zr */ 91.224, 92.90638, 95.94, 98.0, 101.07, 102.90550,
+    /* Pd */ 106.42, 107.8682, 112.411, 114.818, 118.710, 121.760, 
+    /* Te */ 127.60, 126.90447, 131.293, 132.90545, 137.327, 
+    /* La */ 138.9055, 140.116, 140.90765, 144.24, 145.0, 150.36,
+    /* Eu */ 151.964, 157.25, 158.92534, 162.500, 164.93032, 
+    /* Er */ 167.259, 168.93421, 173.04, 174.967, 178.49, 180.9479,
+    /* W  */ 183.84, 186.207, 190.23, 192.217, 195.078, 196.96655, 
+    /* Hg */ 200.59, 204.3833, 207.2, 208.98038, 209.0, 210.0, 222.0, 
+    /* Fr */ 223.0, 226.0, 227.0, 232.0381, 231.03588, 238.02891,
+    /* Np */ 237.0, 244.0, 243.0, 247.0, 247.0, 251.0, 252.0, 257.0,
+    /* Md */ 258.0, 259.0, 262.0, 261.0, 262.0, 266.0, 264.0, 269.0,
+    /* Mt */ 268.0, 271.0, 272.0
+};
+
+/*
+ * corresponding table of VDW radii.
+ * van der Waals radii are taken from A. Bondi, 
+ * J. Phys. Chem., 68, 441 - 452, 1964, 
+ * except the value for H, which is taken from R.S. Rowland & R. Taylor, 
+ * J.Phys.Chem., 100, 7384 - 7391, 1996. Radii that are not available in 
+ * either of these publications have RvdW = 2.00 �.
+ * The radii for Ions (Na, K, Cl, Ca, Mg, and Cs are based on the CHARMM27 
+ * Rmin/2 parameters for (SOD, POT, CLA, CAL, MG, CES) by default.
+ */
+static const float pte_vdw_radius[] = { 
+    /* X  */ 1.5, 1.2, 1.4, 1.82, 2.0, 2.0,  
+    /* C  */ 1.7, 1.55, 1.52, 1.47, 1.54, 
+    /* Na */ 1.36, 1.18, 2.0, 2.1, 1.8,
+    /* S  */ 1.8, 2.27, 1.88, 1.76, 1.37, 2.0,
+    /* Ti */ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0,
+    /* Ni */ 1.63, 1.4, 1.39, 1.07, 2.0, 1.85,
+    /* Se */ 1.9, 1.85, 2.02, 2.0, 2.0, 2.0, 
+    /* Zr */ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0,
+    /* Pd */ 1.63, 1.72, 1.58, 1.93, 2.17, 2.0, 
+    /* Te */ 2.06, 1.98, 2.16, 2.1, 2.0,
+    /* La */ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0,
+    /* Eu */ 2.0, 2.0, 2.0, 2.0, 2.0,
+    /* Er */ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0,
+    /* W  */ 2.0, 2.0, 2.0, 2.0, 1.72, 1.66,
+    /* Hg */ 1.55, 1.96, 2.02, 2.0, 2.0, 2.0, 2.0,
+    /* Fr */ 2.0, 2.0, 2.0, 2.0, 2.0, 1.86,
+    /* Np */ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0,
+    /* Md */ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0,
+    /* Mt */ 2.0, 2.0, 2.0
+};
+
+/* lookup functions */
+
+static const char *get_pte_label(const int idx)
+{
+    if ((idx < 1) || (idx >= nr_pte_entries)) return pte_label[0];
+
+    return pte_label[idx];
+}
+
+static float get_pte_mass(const int idx)
+{
+    if ((idx < 1) || (idx >= nr_pte_entries)) return pte_mass[0];
+
+    return pte_mass[idx];
+}
+
+static float get_pte_vdw_radius(const int idx)
+{
+    if ((idx < 1) || (idx >= nr_pte_entries)) return pte_vdw_radius[0];
+
+#if 1
+    /* Replace with Hydrogen radius with an "all-atom" radius */
+    if (idx == 1)
+      return 1.0;    /* H  */
+#else
+    /* Replace with old VMD atom radii values */
+    switch (idx) {
+      case  1: return 1.0;    /* H  */
+      case  6: return 1.5;    /* C  */
+      case  7: return 1.4;    /* N  */
+      case  8: return 1.3;    /* O  */
+      case  9: return 1.2;    /* F  */
+      case 15: return 1.5;    /* P  */
+      case 16: return 1.9;    /* S  */ 
+    }
+#endif
+
+    return pte_vdw_radius[idx];
+}
+
+static int get_pte_idx(const char *label)
+{
+    int i;
+    char atom[3];
+    
+    /* zap string */
+    atom[0] = (char) 0;
+    atom[1] = (char) 0;
+    atom[2] = (char) 0;
+    /* if we don't have a null-pointer, there must be at least two 
+     * chars, which is all we need. we convert to the capitalization 
+     * convention of the table above during assignment. */
+    if (label != NULL) {
+        atom[0] = (char) toupper((int) label[0]);
+        atom[1] = (char) tolower((int) label[1]);
+    }
+    /* discard numbers in atom label */
+    if (isdigit(atom[1])) atom[1] = (char) 0;
+    
+    for (i=0; i < nr_pte_entries; ++i) {
+        if ( (pte_label[i][0] == atom[0])
+             && (pte_label[i][1] == atom[1]) ) return i;
+    }
+    
+    return 0;
+}
+
+static int get_pte_idx_from_string(const char *label) {
+  int i, ind;
+  char atom[3];
+
+  if (label != NULL) {
+    /* zap string */
+    atom[0] = atom[1] = atom[2] = '\0';
+
+    for (ind=0,i=0; (ind<2) && (label[i]!='\0'); i++) {
+      if (label[i] != ' ') {
+        atom[ind] = toupper(label[i]);
+        ind++;
+      }
+    }
+
+    if (ind < 1)
+      return 0; /* no non-whitespace characters */
+ 
+    for (i=0; i < nr_pte_entries; ++i) {
+      if ((toupper(pte_label[i][0]) == atom[0]) && (toupper(pte_label[i][1]) == atom[1])) 
+        return i;
+    }
+  }  
+
+  return 0;
+}
+
+#if 0
+#include <stdio.h>
+
+int main() {
+  int i;
+
+  printf("Periodic table check/dump\n");
+  printf("  Table contains data for %d elements\n", nr_pte_entries);
+  printf("   Mass table size check: %d\n", sizeof(pte_mass) / sizeof(float));
+  printf("    VDW table size check: %d\n", sizeof(pte_vdw_radius) / sizeof(float));
+  printf("\n");
+  printf("Symbol Num    Mass   rVDW\n");
+  for (i=0; i<nr_pte_entries; i++) {
+    printf("   %-2s  %3d  %6.2f  %4.2f\n",
+      get_pte_label(i), i, get_pte_mass(i), get_pte_vdw_radius(i));
+  } 
+  return 0;
+}
+#endif
+}
+}
+#endif

plumed/_lib/include/plumed/molfile/readpdb.h

@@ -0,0 +1,447 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+University of Illinois Open Source License
+Copyright 2003 Theoretical and Computational Biophysics Group, 
+All rights reserved.
+
+Developed by:		Theoretical and Computational Biophysics Group
+			University of Illinois at Urbana-Champaign
+			http://www.ks.uiuc.edu/
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the Software), to deal with 
+the Software without restriction, including without limitation the rights to 
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies 
+of the Software, and to permit persons to whom the Software is furnished to 
+do so, subject to the following conditions:
+
+Redistributions of source code must retain the above copyright notice, 
+this list of conditions and the following disclaimers.
+
+Redistributions in binary form must reproduce the above copyright notice, 
+this list of conditions and the following disclaimers in the documentation 
+and/or other materials provided with the distribution.
+
+Neither the names of Theoretical and Computational Biophysics Group, 
+University of Illinois at Urbana-Champaign, nor the names of its contributors 
+may be used to endorse or promote products derived from this Software without 
+specific prior written permission.
+
+THE SOFTWARE IS PROVIDED AS IS, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL 
+THE CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 
+OTHER DEALINGS WITH THE SOFTWARE.
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+#ifndef __PLUMED_molfile_readpdb_h
+#define __PLUMED_molfile_readpdb_h
+/***************************************************************************
+ *cr
+ *cr            (C) Copyright 1995-2016 The Board of Trustees of the
+ *cr                        University of Illinois
+ *cr                         All Rights Reserved
+ *cr
+ ***************************************************************************/
+
+/***************************************************************************
+ * RCS INFORMATION:
+ *
+ *      $RCSfile: readpdb.h,v $
+ *      $Author: johns $       $Locker:  $             $State: Exp $
+ *      $Revision: 1.43 $       $Date: 2016/11/28 05:01:54 $
+ *
+ ***************************************************************************/
+
+#ifndef READ_PDB_H
+#define READ_PDB_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+namespace PLMD{
+namespace molfile{
+
+#define PDB_RECORD_LENGTH   80   /* actual record size */
+#define PDB_BUFFER_LENGTH   83   /* size need to buffer + CR, LF, and NUL */
+
+#define VMDUSECONECTRECORDS 1
+
+/*  record type defines */
+enum {
+  PDB_HEADER, PDB_REMARK, PDB_ATOM, PDB_CONECT, PDB_UNKNOWN, PDB_END, PDB_EOF, PDB_CRYST1
+};
+
+/* read the next record from the specified pdb file, and put the string found
+   in the given string pointer (the caller must provide adequate (81 chars)
+   buffer space); return the type of record found
+*/
+static int read_pdb_record(FILE *f, char *retStr) {
+  int ch;
+  char inbuf[PDB_BUFFER_LENGTH]; /* space for line + cr + lf + NUL */
+  int recType = PDB_UNKNOWN;
+ 
+  /* XXX This PDB record reading code breaks with files that use
+   * Mac or DOS style line breaks with ctrl-M characters.  We need
+   * to replace the use of fgets() and comparisons against \n with
+   * code that properly handles the other cases.
+   */
+ 
+  /* read the next line, including any ending cr/lf char */
+  if (inbuf != fgets(inbuf, PDB_RECORD_LENGTH + 2, f)) {
+    retStr[0] = '\0';
+    recType = PDB_EOF;
+  } else {
+#if 0
+    /* XXX disabled this code since \n chars are desirable in remarks */
+    /* and to make the behavior consistent with webpdbplugin          */
+
+    /* remove the newline character, if there is one */
+    if (inbuf[strlen(inbuf)-1] == '\n')
+      inbuf[strlen(inbuf)-1] = '\0';
+#endif
+
+    /* atom records are the most common */
+    if (!strncmp(inbuf, "ATOM ",  5) || !strncmp(inbuf, "HETATM", 6)) {
+      /* Note that by only comparing 5 chars for "ATOM " rather than 6,     */
+      /* we allow PDB files containing > 99,999 atoms generated by AMBER    */
+      /* to load which would otherwise fail.  Not needed for HETATM since   */
+      /* those aren't going to show up in files produced for/by MD engines. */
+      recType = PDB_ATOM;
+    } else if (!strncmp(inbuf, "CONECT", 6)) {
+      recType = PDB_CONECT;
+    } else if (!strncmp(inbuf, "REMARK", 6)) {
+      recType = PDB_REMARK;
+    } else if (!strncmp(inbuf, "CRYST1", 6)) {
+      recType = PDB_CRYST1;
+    } else if (!strncmp(inbuf, "HEADER", 6)) {
+      recType = PDB_HEADER;
+    } else if (!strncmp(inbuf, "END", 3)) {  /* very permissive */
+      /* XXX we treat any "ENDxxx" record as an end, to simplify testing */
+      /*     since we don't remove trailing '\n' chars                   */
+
+      /* the only two legal END records are "END   " and "ENDMDL" */
+      recType = PDB_END;
+    } 
+
+#if 0
+    /* XXX disable record type checking for now */
+    if (recType == PDB_ATOM || 
+        recType == PDB_CONECT || 
+        recType == PDB_REMARK || 
+        recType == PDB_HEADER || 
+        recType == PDB_CRYST1) {
+      strcpy(retStr, inbuf);
+    } else {
+      retStr[0] = '\0';
+    }
+#else
+    strcpy(retStr, inbuf);
+#endif
+  }
+
+  /* read the '\r', if there was one */
+  ch = fgetc(f);
+  if (ch != '\r')
+    ungetc(ch, f);
+  
+  return recType;
+}
+
+
+/* Extract the alpha/beta/gamma a/b/c unit cell info from a CRYST1 record */
+static void get_pdb_cryst1(const char *record, 
+                           float *alpha, float *beta, float *gamma, 
+                           float *a, float *b, float *c) {
+  char tmp[PDB_RECORD_LENGTH+3]; /* space for line + cr + lf + NUL */
+  char ch, *s;
+  memset(tmp, 0, sizeof(tmp));
+  strncpy(tmp, record, PDB_RECORD_LENGTH);
+
+  s = tmp+6 ;          ch = tmp[15]; tmp[15] = 0;
+  *a = (float) atof(s);
+  s = tmp+15; *s = ch; ch = tmp[24]; tmp[24] = 0;
+  *b = (float) atof(s);
+  s = tmp+24; *s = ch; ch = tmp[33]; tmp[33] = 0;
+  *c = (float) atof(s);
+  s = tmp+33; *s = ch; ch = tmp[40]; tmp[40] = 0;
+  *alpha = (float) atof(s);
+  s = tmp+40; *s = ch; ch = tmp[47]; tmp[47] = 0;
+  *beta = (float) atof(s);
+  s = tmp+47; *s = ch; ch = tmp[54]; tmp[54] = 0;
+  *gamma = (float) atof(s);
+}
+
+
+/* Extract the x,y,z coords, occupancy, and beta from an ATOM record */
+static void get_pdb_coordinates(const char *record, 
+                                float *x, float *y, float *z,
+                                float *occup, float *beta) {
+  char numstr[50]; /* store all fields in one array to save memset calls */
+  memset(numstr, 0, sizeof(numstr));
+
+  if (x != NULL) {
+    strncpy(numstr, record + 30, 8);
+    *x = (float) atof(numstr);
+  }
+
+  if (y != NULL) {
+    strncpy(numstr+10, record + 38, 8);
+    *y = (float) atof(numstr+10);
+  }
+
+  if (z != NULL) {
+    strncpy(numstr+20, record + 46, 8);
+    *z = (float) atof(numstr+20);
+  }
+
+  if (occup != NULL) {
+    strncpy(numstr+30, record + 54, 6);
+    *occup = (float) atof(numstr+30);
+  }
+
+  if (beta != NULL) {
+    strncpy(numstr+40, record + 60, 6);
+    *beta = (float) atof(numstr+40);
+  }
+}
+
+
+/* remove leading and trailing spaces from PDB fields */
+static void adjust_pdb_field_string(char *field) {
+  int i, len;
+
+  len = strlen(field);
+  while (len > 0 && field[len-1] == ' ') {
+    field[len-1] = '\0';
+    len--;
+  }
+
+  while (len > 0 && field[0] == ' ') {
+    for (i=0; i < len; i++)
+      field[i] = field[i+1];
+    len--;
+  }
+}
+
+static void get_pdb_header(const char *record, char *pdbcode, char *date,
+                           char *classification) {
+  if (date != NULL) {
+    strncpy(date, record + 50, 9);
+    date[9] = '\0';
+  }
+
+  if (classification != NULL) {
+    strncpy(classification, record + 10, 40);
+    classification[40] = '\0';
+  }
+
+  if (pdbcode != NULL) {
+    strncpy(pdbcode, record + 62, 4);
+    pdbcode[4] = '\0';
+    adjust_pdb_field_string(pdbcode); /* remove spaces from accession code */
+  }
+}
+
+
+static void get_pdb_conect(const char *record, int natoms, int *idxmap,
+                           int *maxbnum, int *nbonds, int **from, int **to) {
+  int bondto[11], numbonds, i;
+
+  int reclen = strlen(record);
+  for (numbonds=0, i=0; i<11; i++) {
+    char bondstr[6];
+    const int fieldwidth = 5;
+    int start = 6 + i*fieldwidth;
+    int end = start + fieldwidth;
+
+    if (end >= reclen)
+      break;
+
+    memcpy(bondstr, record + start, fieldwidth);
+    bondstr[5] = '\0';
+    if (sscanf(bondstr, "%d", &bondto[numbonds]) < 0)
+      break;
+    numbonds++; 
+  }
+
+  for (i=0; i<numbonds; i++) {
+    /* only add one bond per pair, PDBs list them redundantly */ 
+    if (bondto[i] > bondto[0]) {
+      int newnbonds = *nbonds + 1; /* add a new bond */
+
+      /* allocate more bondlist space if necessary */
+      if (newnbonds >= *maxbnum) {
+        int newmax;
+        int *newfromlist, *newtolist;
+        newmax = (newnbonds + 11) * 1.25;
+
+        newfromlist = (int *) realloc(*from, newmax * sizeof(int));
+        newtolist = (int *) realloc(*to, newmax * sizeof(int));
+
+        if (newfromlist != NULL || newtolist != NULL) {
+          *maxbnum = newmax;
+          *from = newfromlist;
+          *to = newtolist;
+        } else {
+          printf("readpdb) failed to allocate memory for bondlists\n");
+          return; /* abort */
+        }
+      }
+
+      *nbonds = newnbonds;
+      (*from)[newnbonds-1] = idxmap[bondto[0]] + 1;
+      (*to)[newnbonds-1] = idxmap[bondto[i]] + 1;
+    }
+  }
+}
+
+/* ATOM field format according to PDB standard v2.2
+  COLUMNS        DATA TYPE       FIELD         DEFINITION
+---------------------------------------------------------------------------------
+ 1 -  6        Record name     "ATOM  "
+ 7 - 11        Integer         serial        Atom serial number.
+13 - 16        Atom            name          Atom name.
+17             Character       altLoc        Alternate location indicator.
+18 - 20        Residue name    resName       Residue name.
+22             Character       chainID       Chain identifier.
+23 - 26        Integer         resSeq        Residue sequence number.
+27             AChar           iCode         Code for insertion of residues.
+31 - 38        Real(8.3)       x             Orthogonal coordinates for X in Angstroms.
+39 - 46        Real(8.3)       y             Orthogonal coordinates for Y in Angstroms.
+47 - 54        Real(8.3)       z             Orthogonal coordinates for Z in Angstroms.
+55 - 60        Real(6.2)       occupancy     Occupancy.
+61 - 66        Real(6.2)       tempFactor    Temperature factor.
+73 - 76        LString(4)      segID         Segment identifier, left-justified.
+77 - 78        LString(2)      element       Element symbol, right-justified.
+79 - 80        LString(2)      charge        Charge on the atom.
+ */
+
+/* Break a pdb ATOM record into its fields.  The user must provide the
+   necessary space to store the atom name, residue name, and segment name.
+   Character strings will be null-terminated.
+*/
+static void get_pdb_fields(const char *record, int reclength, int *serial,
+                           char *name, char *resname, char *chain, 
+                           char *segname, char *resid, char *insertion, 
+                           char *altloc, char *elementsymbol,
+                           float *x, float *y, float *z, 
+                           float *occup, float *beta) {
+  char serialbuf[6];
+
+  /* get atom serial number */
+  strncpy(serialbuf, record + 6, 5);
+  serialbuf[5] = '\0';
+  *serial = 0;
+  sscanf(serialbuf, "%5d", serial);
+  
+  /* get atom name */
+  strncpy(name, record + 12, 4);
+  name[4] = '\0';
+  adjust_pdb_field_string(name); /* remove spaces from the name */
+
+  /* get alternate location identifier */
+  strncpy(altloc, record + 16, 1);
+  altloc[1] = '\0';
+
+  /* get residue name */
+  strncpy(resname, record + 17, 4);
+  resname[4] = '\0';
+  adjust_pdb_field_string(resname); /* remove spaces from the resname */
+
+  /* get chain name */
+  chain[0] = record[21];
+  chain[1] = '\0';
+
+  /* get residue id number */
+  strncpy(resid, record + 22, 4);
+  resid[4] = '\0';
+  adjust_pdb_field_string(resid); /* remove spaces from the resid */
+
+  /* get the insertion code */
+  insertion[0] = record[26];
+  insertion[1] = '\0';
+
+  /* get x, y, and z coordinates */
+  get_pdb_coordinates(record, x, y, z, occup, beta);
+
+  /* get segment name */
+  if (reclength >= 73) {
+    strncpy(segname, record + 72, 4);
+    segname[4] = '\0';
+    adjust_pdb_field_string(segname); /* remove spaces from the segname */
+  } else {
+    segname[0] = '\0';
+  }
+
+  /* get the atomic element symbol */
+  if (reclength >= 77) {
+    strncpy(elementsymbol, record + 76, 2);
+    elementsymbol[2] = '\0';
+  } else {
+    elementsymbol[0] = '\0';
+  }
+}  
+
+
+/* Write PDB data to given file descriptor; return success. */
+static int write_raw_pdb_record(FILE *fd, const char *recordname,
+    int index,const char *atomname, const char *resname,int resid, 
+    const char *insertion, const char *altloc, const char *elementsymbol,
+    float x, float y, float z, float occ, float beta, 
+    const char *chain, const char *segname) {
+  int rc;
+  char indexbuf[32];
+  char residbuf[32];
+  char segnamebuf[5];
+  char resnamebuf[5];
+  char altlocchar;
+
+  /* XXX                                                          */
+  /* if the atom or residue indices exceed the legal PDB spec, we */
+  /* start emitting asterisks or hexadecimal strings rather than  */
+  /* aborting.  This is not really legal, but is an accepted hack */
+  /* among various other programs that deal with large PDB files  */
+  /* If we run out of hexadecimal indices, then we just print     */
+  /* asterisks.                                                   */
+  if (index < 100000) {
+    snprintf(indexbuf, 32, "%5d", index);
+  } else if (index < 1048576) {
+    snprintf(indexbuf, 32, "%05x", index);
+  } else {
+    snprintf(indexbuf, 32, "*****");
+  }
+
+  if (resid < 10000) {
+    snprintf(residbuf, 32, "%4d", resid);
+  } else if (resid < 65536) {
+    snprintf(residbuf, 32, "%04x", resid);
+  } else { 
+    snprintf(residbuf, 32, "****");
+  }
+
+  altlocchar = altloc[0];
+  if (altlocchar == '\0') {
+    altlocchar = ' ';
+  }
+
+  /* make sure the segname or resname do not overflow the format */ 
+  strncpy(segnamebuf,segname,4);
+  segnamebuf[4] = '\0';
+  strncpy(resnamebuf,resname,4);
+  resnamebuf[4] = '\0';
+
+ 
+  rc = fprintf(fd,
+         "%-6s%5s %4s%c%-4s%c%4s%c   %8.3f%8.3f%8.3f%6.2f%6.2f      %-4s%2s\n",
+         recordname, indexbuf, atomname, altlocchar, resnamebuf, chain[0], 
+         residbuf, insertion[0], x, y, z, occ, beta, segnamebuf, elementsymbol);
+
+  return (rc > 0);
+}
+
+}
+}
+#endif
+#endif