packmol-memgen-minimal 1.1.16__py3-none-any.whl

packmol_memgen/lib/pdbremix/trajectory.py

@@ -0,0 +1,286 @@
+# encoding: utf-8
+
+__doc__ = """
+
+Interface to read molecular-dynamics trajectories. 
+
+Simulation trajectories are read into a Trajectory object
+that provides a Soup object, which is updated everytime a
+frame is requested. All operations on Soup are available,
+including the writing of PDB files, and extracting fragments
+for further interrogation.
+
+Trajectory object:
+  Attributes:
+    basename
+    n_frame
+    i_frame
+    soup
+  Methods:
+    load_frame
+
+Currently supported trajectories:
+- AMBER: .top .trj .vel.trj
+- GROMACS: .top .gro .trr
+- NAMD: .psf .dcd .vel.dcd
+"""
+
+
+import os
+import copy
+
+from . import util
+from . import v3
+from . import pdbatoms
+from . import data
+from . import rmsd
+from . import force
+
+from . import namd
+from . import amber
+from . import gromacs
+
+
+
+def open_trajectory(basename):
+  """
+  Returns Trajectory object by guessing the type from basename.
+  """
+  if os.path.isfile(basename + '.trr'):
+    print("Detected GROMACS trajectory")
+    return gromacs.Trajectory(basename)
+  if os.path.isfile(basename + '.psf'):
+    print("Detected NAMD trajectory")
+    return namd.Trajectory(basename)
+  if os.path.isfile(basename + '.top'):
+    print("Detected AMBER trajectory")
+    return amber.Trajectory(basename)
+  raise ValueError("No trajectories found at all!")
+
+
+def make_equilibrium_pdb(trajectory, pdb, start=None, end=None):
+  """
+  Calculates the equilibrium structure between start and end
+  frames. Default: last half of trajectory.
+  """
+  if start is None:
+    start = trajectory.n_frame // 2
+  if end is None:
+    end = trajectory.n_frame
+  
+  if start < 0 or start >= trajectory.n_frame:
+    raise IndexError("Start frame out of range")
+  if end < 0 or end > trajectory.n_frame+1:
+    raise IndexError("End frame out of range")
+  
+  # sum_soup stores cumulative values
+  sum_soup = trajectory.soup.copy()
+  for a in sum_soup.atoms():
+    v3.set_vector(a.pos, 0, 0, 0)
+  
+  n_frame = 0
+  for i in range(start, end):
+    trajectory.load_frame(i)
+    n_frame += 1
+    for sum_atom, atom in zip(
+        sum_soup.atoms(), trajectory.soup.atoms()):
+      sum_atom.pos += atom.pos
+  
+  for a in sum_soup.atoms():
+    x = a.pos.x / float(n_frame)
+    y = a.pos.y / float(n_frame)
+    z = a.pos.z / float(n_frame)
+    v3.set_vector(a.pos, x, y, z)
+  
+  trajectory.soup.write_pdb(pdb)
+
+
+def make_pdb_from_trajectory(
+    basename, i_frame, out_pdb, res_bfactors=None):
+  """
+  Make a PDB from the ith frame of a trajectory described by
+  basename. Optional residue bfactors are loaded into residues.
+  """
+  trajectory = open_trajectory(basename)
+  trajectory.load_frame(i_frame)
+  if res_bfactors is not None:
+    trajectory.soup.load_residue_bfactors(res_bfactors)
+  trajectory.soup.write_pdb(out_pdb)
+  del trajectory
+
+
+
+class TrajectoryAnalyzer(object):
+  """
+  Abstract strategy object to analyze the frames of a trajectory
+  and write the results to a text file.
+  """
+  var_name = 'override'
+
+  def __init__(self, trj, n_frame_per_ps, ref_pdb):
+    self.trj = trj
+    self.soup = self.trj.soup
+    self.n_frame_per_ps = n_frame_per_ps
+    
+    # for reference frame
+    if ref_pdb:
+      self.ref_soup = pdbatoms.Soup(ref_pdb)
+    else:
+      self.ref_soup = self.soup.copy()
+
+    # output files
+    fname = trj.basename + '.' + self.var_name + '.per_frame'
+    self.file_per_frame = open(fname, 'w')
+    fname = trj.basename + '.' + self.var_name + '.per_ps'
+    self.file_per_ps = open(fname, 'w')
+
+    # cumul results for ps save
+    self.cumul_results = None
+    self.n_cumul_frame = 0
+
+  def calculate_results(self):
+    """
+    To be overriden: return list of results to print out
+    """
+    return []
+  
+  def process_frame_on_ps(self):
+    for i in range(len(self.cumul_results)):
+      self.cumul_results[i] /= float(self.n_cumul_frame)
+
+    # save results for ps calculation
+    s = ' '.join(map(str, self.cumul_results))
+    t = round(self.trj.i_frame / float(self.n_frame_per_ps))
+    self.file_per_ps.write('%.f %s\n' % (t, s))
+
+    # clear for next ps
+    if self.trj.i_frame > 0:
+      for i in range(len(self.cumul_results)):
+        self.cumul_results[i] = 0.0
+    self.n_cumul_frame = 0
+
+  def process_frame(self):
+    results = self.calculate_results()
+
+    # write results to file_per_frame
+    s = " ".join(map(str, results))
+    frame = self.trj.i_frame
+    self.file_per_frame.write("%d %s\n" % (frame, s))
+
+    # initialize on first frame
+    if self.cumul_results is None:
+      self.cumul_results = [0.0 for i in range(len(results))]
+
+    # add results to cumul_results
+    for i in range(len(results)):
+      self.cumul_results[i] += results[i]
+    self.n_cumul_frame += 1
+
+  def close(self):
+    self.file_per_frame.close()
+    self.file_per_ps.close()
+
+
+
+class CaRmsdAnalyzer(TrajectoryAnalyzer):
+  """
+  TrajectoryAnalyzer to calculate C-alpha RMSD.
+  """
+  var_name = 'rmsd'
+  def calculate_results(self):
+    return [rmsd.rmsd_of_soups(self.ref_soup, self.soup)]
+
+
+class KineticEnergyAnalyzer(TrajectoryAnalyzer):
+  """
+  TrajectoryAnalyzer to calculate kinetic energy of residues.
+  """
+  var_name = 'kin'
+  def calculate_results(self):
+    results = []
+    for residue in self.soup.residues():
+      if residue.type not in data.solvent_res_types:
+        atoms = residue.atoms()
+        energy = force.kinetic_energy(atoms)/float(len(atoms))
+        results.append(energy)
+    return results
+
+
+class ResidueDeviationAnalyzer(TrajectoryAnalyzer):
+  """
+  TrajectoryAnalyzer to calculate kinetic energy of residues.
+  """
+  var_name = 'dev'
+  def calculate_results(self):
+    ref_crds = []
+    crds = []
+    for ref_residue, residue in zip(self.ref_soup.residues(), self.soup.residues()):
+      if residue.type not in data.solvent_res_types:
+        if residue.has_atom('CA'):
+          ref_crds.append(ref_residue.atom('CA').pos.copy())
+          crds.append(residue.atom('CA').pos.copy())
+    center = v3.get_center(crds)
+    crds = [c - center for c in crds]
+    ref_center = v3.get_center(ref_crds)
+    ref_crds = [c - ref_center for c in ref_crds]
+    rmsd_val, transform_ref_to_this = rmsd.calc_rmsd_rot(ref_crds, crds)
+    ref_crds = [v3.transform(transform_ref_to_this, c) for c in ref_crds]
+    return [v3.distance(crd, ref_crd) for crd, ref_crd in zip(crds, ref_crds)]
+
+
+def guess_n_frame_per_ps(basename):
+  """
+  Returns the n_frame_per_ps of a trajectory by reading any
+  .config files that would have been generated using simualte.py.
+  """
+  config = basename + ".config"
+  try:
+    params = util.read_dict(config)
+    # assuming 1fs time step
+    n_step_per_ps = 1000 
+    if 'n_step_per_snapshot' in params:
+      n_step_per_snapshot = params['n_step_per_snapshot']
+    n_frame_per_ps = n_step_per_ps / n_step_per_snapshot
+  except:
+    n_frame_per_ps = 50
+  return n_frame_per_ps
+  
+  
+
+def analyze_trajectory(
+    basename, n_frame_per_ps=None, 
+    analyzer_classes=None, ref_pdb=None):
+  """"
+  Calculates trajectory variables for the residues in the 
+  system using the TrajectoryAnalyzer straegy objects in 
+  analyzers.
+  """
+  trj = open_trajectory(basename)
+
+  # Instantiate analyzers
+  if n_frame_per_ps is None:
+    n_frame_per_ps = guess_n_frame_per_ps(basename)
+  if analyzer_classes is None:
+    analyzer_classes = \
+        [KineticEnergyAnalyzer, CaRmsdAnalyzer, ResidueDeviationAnalyzer]
+  analyzers = [a(trj, n_frame_per_ps, ref_pdb) \
+               for a in analyzer_classes]
+
+  # Go through frame by frame
+  for i_frame in range(trj.n_frame):
+    print("Processing frame %d/%d" % (i_frame, trj.n_frame))
+    trj.load_frame(i_frame)
+    for analyzer in analyzers:
+      analyzer.process_frame()
+      # A whole ps has been save to file_per_ps
+      if (i_frame+1) % n_frame_per_ps == 0 or i_frame == 0:
+        analyzer.process_frame_on_ps()
+
+  # At last frame
+  trj.soup.write_pdb(basename + '.last.pdb')
+  
+  for analyzer in analyzers:
+    analyzer.close()
+
+
+

packmol_memgen/lib/pdbremix/util.py

@@ -0,0 +1,273 @@
+# encoding: utf-8
+
+__doc__ = """
+
+Utility functions.
+
+- directory handling
+- pathname mangling
+- running shell commands
+- timer
+- file checking
+"""
+
+import os
+import stat
+import tempfile
+import copy
+import re
+import glob
+import json
+import subprocess
+import time
+import math
+import pprint
+import sys
+
+
+def re_glob(dir_tag, reg_exp=""):
+  fnames = glob.glob(dir_tag)
+  return [f for f in fnames if re.search(reg_exp, f)]
+
+
+def check_dir(dirname):
+  if dirname.strip() == '':
+    return
+  if not os.path.isdir(dirname):
+    os.makedirs(dirname)
+    
+  
+def goto_dir(new_dir):
+  if new_dir.strip() == '':
+    return
+  if not os.path.isdir(new_dir):
+    os.makedirs(new_dir)
+  os.chdir(new_dir)
+
+
+def relpath(path):
+  if path == '':
+    return ''
+  dirpath, basename = os.path.split(path)
+  dirpath = os.path.relpath(dirpath, os.getcwd())
+  if dirpath == '' or dirpath == '.':
+    return basename
+  return os.path.join(dirpath, basename)
+
+
+def temp_fname(suffix=''):
+  fd, fname = tempfile.mkstemp(suffix, 'tmp-', '.')
+  f = os.fdopen(fd, 'w')
+  f.close()
+  os.unlink(fname)
+  return os.path.basename(fname)
+
+
+def fname_variant(fname):
+  root, ext = os.path.splitext(fname)
+  i = 1
+  new_fname = "%s-%d%s" % (root, i, ext)
+  while os.path.isfile(new_fname):
+    i += 1
+    new_fname = "%s-%d%s" % (root, i, ext)
+  return new_fname
+
+
+def clean_fname(*fnames):
+  for fname in fnames:
+    if os.path.isdir(fname):
+      for root, dirs, files in os.walk(fname, topdown=False):
+        for name in files:
+          os.remove(os.path.join(root, name))
+        for name in dirs:
+          os.rmdir(os.path.join(root, name)) 
+      os.rmdir(fname)
+    elif os.path.isfile(fname):
+      try:
+        os.remove(fname)
+      except:
+        pass
+
+
+def get_floats_from_string(s):
+  val_strs = re.finditer(r'[-+]?([0-9]*\.[0-9]+|[0-9]+)', s)
+  return [float(v.group()) for v in val_strs]
+  
+  
+def write_dict(fname, d, indent=2):
+  pprint.pprint(d, indent=2, stream=open(fname, "w"))
+
+
+def read_dict(fname):
+  try:
+    txt = open(fname).read()
+    d = eval(txt)
+    if not isinstance(d, dict):
+      raise Exception('Not a dictionary in ' + fname)
+    return d
+  except:
+    raise Exception('Couldn\'t parse dictionary in ' + fname)
+  
+
+def is_same_dict_in_file(d, fname):
+  try:
+    saved_d = read_dict(fname)
+    return saved_d == d
+  except:
+    return False
+
+
+def words_in_file(fname):
+  result = []
+  for line in open(fname).readlines():
+    result.extend(line.split())
+  return result
+
+
+def elapsed_time_str(time):
+  s = str(time) + ' '
+  minute = math.floor(time / 60.0)
+  if minute > 60:
+    hour = math.floor(minute / 60.0)
+    partial_minute = math.fmod(time, 60.0)
+    s += "%.f:%02.f:" % (hour, partial_minute)
+  elif minute >= 1:
+    s += "%.f:" % minute
+  sec = math.fmod(time, 60.0)
+  if sec < 0.01:
+    s += "%07.4fs" % sec
+  else:
+    s += "%05.2fs" % sec
+  return s
+  
+  
+class Timer:
+  def __init__(self):
+    self._elapsed = 0;
+    self._start = time.time()
+
+  def start(self):
+    self._start = time.time()
+    self._elapsed = 0
+
+  def stop(self):
+    self._elapsed = time.time() - self._start
+
+  def elapsed(self):
+    if self._elapsed == 0:
+      return time.time() - self._start
+    else:
+      return self._elapsed
+
+  def str(self):
+    elapsed_time = self.elapsed()
+    return elapsed_time_str(elapsed_time)
+    
+  def __str__(self):
+    return self.str()
+
+
+def val_range(start, end, step):
+  vals = []
+  v = start
+  while v <= end:
+    vals.append(v)
+    v += step
+  return vals
+ 
+ 
+class FileException(Exception):
+  pass
+
+
+def check_files(*fnames):
+  """
+  Checks for existence of fnames. Raises error if not found.
+  """
+  for fname in fnames:
+    if not os.path.isfile(fname):
+      raise FileException("Can't find {}".format(fname))
+
+
+def which(program, other_binary_dirs=[]):
+  """
+  Reproduces Unix 'which' and looks in other_binary_dirs
+  """
+
+  def is_binary(fpath):
+    return os.path.isfile(fpath) and os.access(fpath, os.X_OK)
+
+  fpath, fname = os.path.split(program)
+  if fpath:
+    if is_binary(program):
+      return program
+  else:
+    binary_dirs = os.environ["PATH"].split(os.pathsep)
+    binary_dirs.extend(other_binary_dirs)
+    for path in binary_dirs:
+      exe_file = os.path.join(path, program)
+      if is_binary(exe_file):
+        return exe_file
+  return None
+
+
+def check_program(program):
+  if not which(program):
+    raise FileException("Can't find executable: " + program)
+
+
+def check_output(fname, bad_words=[]):
+  if not os.path.isfile(fname):
+    raise FileException("Can't find output file: " + fname)
+  txt = open(fname).read()
+  if txt.strip() == '':
+    raise Exception("Empty file: " + fname)
+  for bad_word in bad_words:
+    for i_line, line in enumerate(txt.splitlines()):
+      if bad_word in line:
+        raise Exception(
+            "Output indicates %s error in line %d: %s" % (bad_word, i_line+1, fname))
+
+def run_with_output(cmd):
+  p = subprocess.Popen(
+      cmd, 
+      shell=True, 
+      stdout=subprocess.PIPE, 
+      stderr=subprocess.PIPE)
+  return p.stdout.read()
+
+
+def run_with_output_file(cmd, out_fname=None, in_fname=None):
+  in_f = None
+  out_f = None
+
+  if in_fname and os.path.isfile(in_fname):
+    in_f = open(in_fname)
+
+  if out_fname:
+    log_file = out_fname + '.log'
+    out_f = open(log_file, 'w')
+    sh_file = out_fname + '.sh'
+    sh_cmd = cmd
+    if in_f:
+      sh_cmd += ' < ' + in_fname
+    if log_file:
+      sh_cmd += ' &> ' + log_file
+    open(sh_file, 'w').write(sh_cmd)
+    os.chmod(sh_file, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)
+    stopwatch = Timer()
+
+  subprocess.call(
+    cmd, 
+    shell=True,
+    stdin=in_f,
+    stdout=out_f,
+    stderr=out_f)
+
+  if out_fname:
+    stopwatch.stop()
+    open(out_fname + '.time', 'w').write(stopwatch.str())
+    out_f.close()
+
+
+

packmol_memgen/lib/pdbremix/v3.py

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+__doc__ = """
+
+Interface 3D vector geometry library.
+
+This is an interface to choose between the pure Python version
+or the numpy version. This depends on numpy availability.
+"""
+
+try:
+  import numpy
+  from .v3numpy import *
+except:
+  from .v3array import *
+