hydrogens (8 March 2004) | index /home/todd/release/pdb2pqr/hydrogens.py

`Hydrogen optimization routines for PDB2PQR
This module contains the hydrogen optimization routines and classes for
PDB2PQR. It is (optionally) used to check protonation states and
improve hydrogen networks within a protein.
Based on C code from Jens Erik Nielsen
UCSD/HHMI
Ported to Python by Todd Dolinsky (todd@ccb.wustl.edu)
Washington University in St. Louis`

Modules

``

getopt math | os string | sys |

Classes

``

HydrogenConformation
HydrogenDefinition
hydrogenAmbiguity
hydrogenRoutines

class HydrogenConformation
`` | `HydrogenConformation class The HydrogenConformation class contains data about possible hydrogen conformations as specified in the hydrogen data file.`

Methods defined here:

__init__(self, hname, boundatom, bondlength)
  `Initialize the object
  Parameters
  hname : The hydrogen name (string)
  boundatom : The atom the hydrogen is bound to (string)
  bondlength : The bond length (float)`

__str__(self)
  `Used for debugging purposes
  Returns
  output: Information about this conformation (string)`

addAtom(self, atom)
  `Add an atom to the list of atoms
  Parameters
  atom: The atom to be added (DefinitionAtom)`

Data and non-method functions defined here:

__doc__ = '\n HydrogenConformation class\n\n The...ions as specified in the hydrogen data file.\n '

__module__ = 'hydrogens'

class HydrogenDefinition
`` | `HydrogenDefinition class The HydrogenDefinition class provides information on possible ambiguities in amino acid hydrogens. It is essentially the hydrogen definition file in object form.`

Methods defined here:

__init__(self, name, group, numhydrogens, standardconf, type, chiangle, method)
  `Initialize the object with information from the definition file
  Parameters:
  name: The name of the grouping (string)
  group: The group of the definition
  (acid/base/none, string)
  numhydrogens: The number of hydrogens that can be added (int)
  standardconf: The number of standard conformations (int)
  type : Type of Hydrogen (int)
  chiangle : The chiangle to be changed (int)
  method : The standard optimization method (int)
  See HYDROGENS.DAT for more information`

__str__(self)
  `Used for debugging purposes
  Returns
  output: The information about this definition (string)`

addConf(self, conf)
  `Add a HydrogenConformation to the list of conformations
  Parameters
  conf: The conformation to be added (HydrogenConformation)`

Data and non-method functions defined here:

__doc__ = '\n HydrogenDefinition class\n\n The H...ogen\n definition file in object form.\n '

__module__ = 'hydrogens'

class hydrogenAmbiguity
`` | `A class containing information about the ambiguity`

Methods defined here:

__init__(self, residue, hdef)
  `Initialize the class
  Parameters
  residue: The residue in question (residue)
  hdef: The hydrogen definition matching the residue`

setNearatoms(self, allatoms)
  `Set the nearby atoms to this residue. The only donors/acceptors
  that will be changing positions are the flips, with maximum change
  of 2.5 A.
  Parameters
  allatoms: A list of all donors/acceptors (list)`

Data and non-method functions defined here:

__doc__ = '\n A class containing information about the ambiguity\n '

__module__ = 'hydrogens'

class hydrogenRoutines
`` | `The main class of routines in the hydrogen optimization process.`

Methods defined here:

__init__(self, routines)
  `Initialize the routines and run the hydrogen optimization
  Parameters
  routines: The parent routines object (Routines)`

debug(self, text)
  `Print text to stdout for debugging purposes.
  Parameters
  text: The text to output (string)`

findAmbiguities(self, water)
  `Find the amibiguities within a protein according to the
  DAT file, and set all boundatoms to their hydrogen donor/
  acceptor state. Store the ambiguities as (residue, hydrodef)
  tuples in self.groups.
  Returns
  allatoms: A list of all donors and acceptors in the
  protein (list)
  water: If 1, only put waters in groups, but fill allatoms
  appropriately`

findNetworks(self, limit)
  `Find hydrogen networks that should be optimized together.
  Parameters
  limit: The limit to see how close two boundatoms are
  Returns
  networks: A list of group ID networks (list)`

findViableAngles(self, residue, nearatoms)
  `Find the viable angles that a water molecule can be rotated to.
  If there are no donor/acceptor atoms within
  Parameters
  residue: The water residue to examine
  nearatoms: A list of nearby donor/acceptors
  Returns
  angle: A list of viable angles`

getHbondEnergy(self, amb)

getHbondEnergy2(self, clusteratoms, compatoms, res=None)
  `Get the hydrogen bond energy for a cluster of donors
  and acceptors. If res is not present, compare each atom
  in clusteratoms to all nearby atoms in compatoms. If res is
  present, we are trying to find the new energy of the residue
  res that has just switched states, and thus need to include
  all comparisons where atoms within the residue is an
  acceptor.
  Parameters
  clusteratoms: A list of hydrogen donor/acceptor atoms in
  the cluster(list)
  compatoms: A list of all hydrogen donor/acceptor
  atoms within a given distance of the
  cluster (list)
  res: (Optional) Residue to get the energy of
  (Residue)
  Returns
  energy: The energy of this hydrogen bond network
  (float)`

getHbondangle(self, atom1, atom2, atom3)
  `Get the angle between three atoms
  Parameters
  atom1: The first atom (atom)
  atom2: The second (vertex) atom (atom)
  atom3: The third atom (atom)
  Returns
  angle: The angle between the atoms (float)`

getPairEnergy(self, donor, acceptor)
  `Get the energy between two atoms
  Parameters
  donor: The first atom in the pair (Atom)
  acceptor: The second atom in the pair (Atom)
  Returns
  energy: The energy of the pair (float)`

getPenalty(self, residue)
  `Add penalties for unusual protonation states.
  Parameters
  atom: The residue to examine (Atom)
  Returns
  penalty: The amount of the penalty (float)`

getstates(self, amb)
  `Get all possible states for a conformation/protonation
  ambiguity and store them in a list. Each.
  hydrogen type must be explicitly defined.
  Parameters
  amb : The ambiguity to get the states of (tuple)
  Returns
  states: A list of states, where each state
  is a list of conformations of the atom. (list)`

initHbondEnergy(self, cluster, allatoms)
  `Create a list of hydrogen donors/acceptors within this cluster
  and another list of donors/acceptors throughout the
  entire protein.
  Parameters
  cluster: A list of group ids that are networked (list)
  Returns
  clusteratoms: A list of hydrogen donor/acceptor atoms in
  the cluster (list)`

liststates(self)
  `List the final results of all conformation/protonation
  ambiguities to stdout.`

optimizeHydrogens(self)
  `Optimize hydrogens according to HYDROGENS.DAT. This
  function serves as the main driver for the optimizing
  script.`

optimizeSingle(self, amb)
  `Use brute force optimization for a single ambiguity - try all
  energy configurations and pick the best.
  Parameters
  amb: The ambiguity object (tuple)`

optimizeWaters(self)
  `Optimize the waters found in a protein`

parseHydrogen(self, lines)
  `Parse a list of lines in order to make a hydrogen
  definition
  Parameters
  lines: The lines to parse (list)
  Returns
  mydef: The hydrogen definition object (HydrogenDefinition)`

printAmbiguities(self)
  `Print the list of ambiguities to stdout`

randomizeWaters(self)
  `Randomize the waters found in a protein. Mimics the
  optimizeWaters function, but instead of going through
  all possible 5 degree increments, simply choose a random
  angle.`

readHydrogenDefinition(self)
  `Read the Hydrogen Definition file
  Returns
  hydrodef: The hydrogen definition ()`

setWaterHydrogens(self, residue, newangle)
  `Optimize a Water molecule
  Parameters
  residue: The water residue
  newangle: The new chi angle (float)`

switchstate(self, states, amb, id)
  `Switch a residue to a new state by first removing all
  hydrogens.
  Parameters
  states: The list of states (list)
  amb : The amibiguity to switch (tuple)
  id : The state id to switch to (int)`

Data and non-method functions defined here:

__doc__ = '\n The main class of routines in the hydrogen optimization process.\n '

__module__ = 'hydrogens'

Functions

``

acos(...)
  `acos(x)
  Return the arc cosine (measured in radians) of x.`

asctime(...)
  `asctime([tuple]) -> string
  Convert a time tuple to a string, e.g. 'Sat Jun 06 16:26:11 1998'.
  When the time tuple is not present, current time as returned by localtime()
  is used.`

asin(...)
  `asin(x)
  Return the arc sine (measured in radians) of x.`

atan(...)
  `atan(x)
  Return the arc tangent (measured in radians) of x.`

atan2(...)
  `atan2(y, x)
  Return the arc tangent (measured in radians) of y/x.
  Unlike atan(y/x), the signs of both x and y are considered.`

ceil(...)
  `ceil(x)
  Return the ceiling of x as a float.
  This is the smallest integral value >= x.`

clock(...)
  `clock() -> floating point number
  Return the CPU time or real time since the start of the process or since
  the first call to clock(). This has as much precision as the system records.`

cos(...)
  `cos(x)
  Return the cosine of x (measured in radians).`

cosh(...)
  `cosh(x)
  Return the hyperbolic cosine of x.`

ctime(...)
  `ctime(seconds) -> string
  Convert a time in seconds since the Epoch to a string in local time.
  This is equivalent to asctime(localtime(seconds)). When the time tuple is
  not present, current time as returned by localtime() is used.`

exp(...)
  `exp(x)
  Return e raised to the power of x.`

fabs(...)
  `fabs(x)
  Return the absolute value of the float x.`

floor(...)
  `floor(x)
  Return the floor of x as a float.
  This is the largest integral value <= x.`

fmod(...)
  `fmod(x,y)
  Return fmod(x, y), according to platform C. x % y may differ.`

frexp(...)
  `frexp(x)
  Return the mantissa and exponent of x, as pair (m, e).
  m is a float and e is an int, such that x = m * 2.**e.
  If x is 0, m and e are both 0. Else 0.5 <= abs(m) < 1.0.`

gmtime(...)
  `gmtime([seconds]) -> (tm_year, tm_mon, tm_day, tm_hour, tm_min,
  tm_sec, tm_wday, tm_yday, tm_isdst)
  Convert seconds since the Epoch to a time tuple expressing UTC (a.k.a.
  GMT). When 'seconds' is not passed in, convert the current time instead.`

hypot(...)
  `hypot(x,y)
  Return the Euclidean distance, sqrt(x*x + y*y).`

ldexp(...)
  `ldexp(x, i) -> x * (2**i)`

localtime(...)
  `localtime([seconds]) -> (tm_year,tm_mon,tm_day,tm_hour,tm_min,tm_sec,tm_wday,tm_yday,tm_isdst)
  Convert seconds since the Epoch to a time tuple expressing local time.
  When 'seconds' is not passed in, convert the current time instead.`

log(...)
  `log(x) -> the natural logarithm (base e) of x.`

log10(...)
  `log10(x) -> the base 10 logarithm of x.`

mktime(...)
  `mktime(tuple) -> floating point number
  Convert a time tuple in local time to seconds since the Epoch.`

modf(...)
  `modf(x)
  Return the fractional and integer parts of x. Both results carry the sign
  of x. The integer part is returned as a real.`

pow(...)
  `pow(x,y)
  Return x**y (x to the power of y).`

sin(...)
  `sin(x)
  Return the sine of x (measured in radians).`

sinh(...)
  `sinh(x)
  Return the hyperbolic sine of x.`

sleep(...)
  `sleep(seconds)
  Delay execution for a given number of seconds. The argument may be
  a floating point number for subsecond precision.`

sqrt(...)
  `sqrt(x)
  Return the square root of x.`

strftime(...)
  `strftime(format[, tuple]) -> string
  Convert a time tuple to a string according to a format specification.
  See the library reference manual for formatting codes. When the time tuple
  is not present, current time as returned by localtime() is used.`

strptime(...)
  `strptime(string, format) -> tuple
  Parse a string to a time tuple according to a format specification.
  See the library reference manual for formatting codes (same as strftime()).`

tan(...)
  `tan(x)
  Return the tangent of x (measured in radians).`

tanh(...)
  `tanh(x)
  Return the hyperbolic tangent of x.`

time(...)
  `time() -> floating point number
  Return the current time in seconds since the Epoch.
  Fractions of a second may be present if the system clock provides them.`

Data

``

AAFILE = 'AA.DAT'
AAS = ['ALA', 'ARG', 'ASN', 'ASP', 'CYS', 'GLN', 'GLU', 'GLH', 'GLY', 'HIS', 'HID', 'HIE', 'HIP', 'HSD', 'HSE', 'HSP', 'ILE', 'LEU', 'LYS', 'MET', ...]
AMBER_FILE = 'AMBER.DAT'
BACKBONE = ['N', 'CA', 'C', 'O', 'O2', 'HA', 'HN', 'H', 'tN']
BONDED_SS_LIMIT = 2.5
BUMP_DIST = 2.0
BUMP_HDIST = 1.5
CELL_SIZE = 2
CHARMM_FILE = 'CHARMM.DAT'
DIHEDRAL = 57.2958
HACCEPTOR = [0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0]
HDONOR = [0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1]
HYDROGENFILE = 'HYDROGENS.DAT'
HYDROGEN_DIST = 6.0
HYDRO_BONDCOORDS = [[7.5810000000000004, 2.0899999999999999, 12.506], [6.4580000000000002, 2.1619999999999999, 13.159000000000001], [5.1449999999999996, 2.2090000000000001, 12.452999999999999]]
HYDRO_COORDS = [6.476, 2.1859999999999999, 14.159000000000001]
LARGE_TORSION_ANGLE = 1000.0
NAFILE = 'NA.DAT'
NAS = ['A', 'A5', 'A3', 'C', 'C5', 'C3', 'G', 'G5', 'G3', 'T', 'T5', 'T3', 'U', 'U5', 'U3']
NTERM2_COORDS = [-24.001000000000001, 50.223999999999997, -22.225999999999999]
NTERM3_COORDS = [-24.869, 48.845999999999997, -22.77]
NTERM_COORDS = [[-24.196000000000002, 48.789999999999999, -20.800000000000001], [-25.552, 49.881, -21.847999999999999], [-24.645, 49.491, -22.007000000000001]]
OXT_COORDS = [-1.5289999999999999, 1.8580000000000001, 0.69499999999999995]
PARSE_FILE = 'PARSE.DAT'
PEPTIDE_DIST = 1.7
PEP_TRANS_CA = [-2.3130000000000002, 2.7839999999999998, 1.0229999999999999]
PEP_TRANS_N = [-1.252, 1.877, 0.88300000000000001]
REFATOM_SIZE = 3
REPAIR_LIMIT = 10
ROTAMERFILE = 'ROTAMER.DAT'
SMALL = 9.9999999999999995e-08
WATER_DIST = 4.0
__author__ = 'Jens Erik Nielsen, Todd Dolinsky'
__date__ = '8 March 2004'
__file__ = './hydrogens.pyc'
__name__ = 'hydrogens'
accept2dyear = 1
altzone = 18000
daylight = 1
e = 2.7182818284590451
pi = 3.1415926535897931
timezone = 21600
tzname = ('CST', 'CDT')

Author
`` |  | Jens Erik Nielsen, Todd Dolinsky