def __init__(self, tasks, num_cpus=0, profiling=False):
self.log = LoggingManager.get_logger('kraken')
try:
self.num_processes = int(num_cpus)
if self.num_processes < 1:
raise ValueError()
if self.num_processes > cpu_count():
self.log.warning(
"Number of cores (%d) larger than available." %
self.num_processes)
raise ValueError()
except (ValueError, TypeError):
self.log.warning(
"Number of cores has not been specified or is incorrect. Using available cores."
)
self.num_processes = cpu_count()
self.log.info("Kraken has %d tentacles (cpu cores)" %
self.num_processes)
self.tasks = tasks
self.num_tasks = len(tasks)
self.tentacles = []
tentacle_tasks = [
tasks[i::self.num_processes] for i in range(self.num_processes)
]
for i in range(self.num_processes):
tentacle = Tentacle(tentacle_tasks[i], profiling)
self.tentacles.append(tentacle)
self.log.info("%d ships ready to be smashed" % self.num_tasks)
def __init__(self, tasks, num_cpus=0, profiling=False):
self.log = LoggingManager.get_logger('kraken')
try:
self.num_processes = int(num_cpus)
if self.num_processes < 1:
raise ValueError()
if self.num_processes > cpu_count():
self.log.warning("Number of cores (%d) larger than available." % self.num_processes)
raise ValueError()
except (ValueError, TypeError):
self.log.warning("Number of cores has not been specified or is incorrect. Using available cores.")
self.num_processes = cpu_count()
self.log.info("Kraken has %d tentacles (cpu cores)" % self.num_processes)
self.tasks = tasks
self.num_tasks = len(tasks)
self.tentacles = []
tentacle_tasks = [tasks[i::self.num_processes] for i in xrange(self.num_processes)]
for i in range(self.num_processes):
tentacle = Tentacle(tentacle_tasks[i], profiling)
self.tentacles.append(tentacle)
self.log.info("%d ships ready to be smashed" % self.num_tasks)
import os
import sys
from lightdock.util.logger import LoggingManager
from lightdock.pdbutil.PDBIO import parse_complex_from_file
from lightdock.structure.complex import Complex
from lightdock.gso.boundaries import Boundary, BoundingBox
from lightdock.mathutil.lrandom import MTGenerator
from lightdock.gso.parameters import GSOParameters
from lightdock.mathutil.cython.quaternion import Quaternion
from lightdock.scoring.dfire.driver import DFIRE, DFIREAdapter
from lightdock.gso.algorithm import GSO
from lightdock.gso.searchspace.landscape import DockingLandscapePosition
from lightdock.gso.swarm import Swarm
log = LoggingManager.get_logger('relightdock')
MAX_TRANSLATION = 30 # In Angstroms
MAX_ROTATION = 1.0 # Quaternion default value for its components
DEFAULT_TRANSLATION_STEP = 0.5 # Normalized step
DEFAULT_ROTATION_STEP = 0.5 # Normalized SLERP step. 1 means full jump, 0 means no movement
GSO_SEED = 324324 # Seed for the random number generator in the GSO algorithm
STARTING_POINTS_SEED = 324324
def parse_output_file(lightdock_output):
translations = []
rotations = []
luciferin = []
neighbors = []
vision_range = []
#!/usr/bin/env python
"""Creates a PDB with atom points representing the position for each of the glowworms of a swarm"""
import argparse
import os
from lightdock.error.lightdock_errors import LightDockError
from lightdock.pdbutil.PDBIO import create_pdb_from_points
from lightdock.util.logger import LoggingManager
from lightdock.constants import DEFAULT_LIST_EXTENSION, DEFAULT_LIGHTDOCK_PREFIX
log = LoggingManager.get_logger('generate_glowworm_positions')
def valid_file(file_name):
"""Checks if it is a valid file"""
if not os.path.exists(file_name):
raise argparse.ArgumentTypeError("The file does not exist")
return file_name
def get_lightdock_structures(input_file):
"""Get a list of the PDB files in the input_file"""
input_file_name, input_file_extension = os.path.splitext(input_file)
file_names = []
if input_file_extension == DEFAULT_LIST_EXTENSION:
with open(input_file) as input_lines:
for line in input_lines:
file_name = line.rstrip(os.linesep)
lightdock_structure = os.path.join(
os.path.dirname(file_name),
DEFAULT_LIGHTDOCK_PREFIX % os.path.basename(file_name))
#!/usr/bin/env python3
import os
import argparse
from prody import parsePDB, writePDB, confProDy
from math import cos, sin, radians, pi
from numpy import arange
from lightdock.pdbutil.PDBIO import create_pdb_from_points
from lightdock.util.logger import LoggingManager
# Disable ProDy output
confProDy(verbosity='info')
log = LoggingManager.get_logger('lgd_create_membrane')
if __name__ == "__main__":
parser = argparse.ArgumentParser(prog='lgd_create_membrane')
parser.add_argument("input_pdb_file",
help="Input PDB file",
metavar="input_pdb_file")
parser.add_argument(
"anchor_residue",
help="A residue in the format ChainID.ResidueName.ResidueNumber "
"which indicates the point to start to build the fake-membrane",
metavar="anchor_residue")
parser.add_argument("--angular_resolution",
"-angular_resolution",
"-ar",
help="Angular resolution, in degrees",
dest="angular_resolution",
#!/usr/bin/env python
"""Cluster LightDock final swarm results using BSAS algorithm"""
import sys
import argparse
import Bio.PDB
from lightdock.util.analysis import read_lightdock_output
from lightdock.util.logger import LoggingManager
from lightdock.constants import CLUSTER_REPRESENTATIVES_FILE
log = LoggingManager.get_logger('lgd_cluster_bsas')
def parse_command_line():
"""Parses command line arguments"""
parser = argparse.ArgumentParser(prog='lgd_cluster_bsas')
parser.add_argument("gso_output_file",
help="LightDock output file",
metavar="gso_output_file")
return parser.parse_args()
def get_ca_atoms(ids_list):
"""Get all Carbon-alpha atoms of the PDB files specified by the ids_list.
PDB files follow the format lightdock_ID.pdb where ID is in ids_list
"""
ca_atoms = {}
try:
#!/usr/bin/env python
"""Calculates the scoring function value for a pair of receptor and ligand PDB structures"""
import argparse
import importlib
from lightdock.pdbutil.PDBIO import parse_complex_from_file
from lightdock.structure.complex import Complex
from lightdock.util.logger import LoggingManager
log = LoggingManager.get_logger('calculate_scoring')
def parse_command_line():
parser = argparse.ArgumentParser(prog='calculate_scoring')
parser.add_argument("scoring_function", help="scoring function")
parser.add_argument("receptor", help="PDB receptor")
parser.add_argument("ligand", help="PDB ligand")
script_args = parser.parse_args()
return script_args
if __name__ == "__main__":
args = parse_command_line()
try:
scoring_function_module = "lightdock.scoring.%s.driver" % args.scoring_function
module = importlib.import_module(scoring_function_module)
except ImportError:
raise SystemExit("Scoring function not found or not available")
import numpy as np
import operator
import os
from lightdock.mathutil.cython.quaternion import Quaternion
from lightdock.constants import RANKING_BY_LUCIFERIN_FILE,\
RANKING_BY_SCORING_FILE, RANKING_BY_RMSD_FILE, RANKING_FILE
from lightdock.util.logger import LoggingManager
log = LoggingManager.get_logger('analysis')
class DockingResult(object):
"""Represents a LightDock docking result line"""
def __init__(self, id_cluster=0, id_glowworm=0, receptor_id=0, ligand_id=0, luciferin=0.0,
num_neighbors=0, vision_range=0.0, pose=None, rmsd=-1.0,
pdb_file='', contacts=0, scoring=0.0):
self.id_cluster = id_cluster
self.id_glowworm = id_glowworm
self.receptor_id = receptor_id
self.ligand_id = ligand_id
self.luciferin = luciferin
self.num_neighbors = num_neighbors
self.vision_range = vision_range
self.pose = pose
self.translation = np.array(pose[:3])
self.rotation = Quaternion(pose[3], pose[4], pose[5], pose[6]).normalize()
self.coord = DockingResult.pose_repr(pose)
self.rmsd = rmsd
self.pdb_file = pdb_file
self.contacts = contacts
C-implementation of the SIPPER (https://dx.doi.org/10.1021/ci100353e) scoring function.
"""
import numpy as np
import os
from lightdock.constants import DEFAULT_LIGHTDOCK_PREFIX
from lightdock.scoring.functions import ScoringFunction, ModelAdapter
from lightdock.structure.model import DockingModel
from lightdock.scoring.sipper.data.energy import sipper_energy, res_to_index
import lightdock.scoring.sipper.c.sipper as csipper
from lightdock.util.logger import LoggingManager
log = LoggingManager.get_logger('sipper')
class SIPPERModel(DockingModel):
"""Prepares the structure necessary for the C-implementation of the SIPPER
scoring function
"""
def __init__(self, objects, coordinates, restraints, energy, indexes, atoms_per_residue,
oda=None, reference_points=None, n_modes=None):
super(SIPPERModel, self).__init__(objects, coordinates, restraints, reference_points)
self.energy = energy
self.indexes = indexes
self.atoms_per_residue = atoms_per_residue
self.oda = oda
self.n_modes = n_modes
"""Parses Atomic coordinates entries from PDB files"""
import math
from lightdock.error.lightdock_errors import PDBParsingError, PDBParsingWarning
from lightdock.structure.atom import Atom, HetAtom
from lightdock.structure.residue import Residue
from lightdock.structure.chain import Chain
from lightdock.util.logger import LoggingManager
log = LoggingManager.get_logger('pdb')
def cstrip(string):
"""Remove unwanted symbols from string."""
return string.strip(' \t\n\r')
def read_atom_line(line, line_type='', atoms_to_ignore=[]):
"""Parses a PDB file line starting with 'ATOM' or 'HETATM'"""
element = cstrip(line[76:78])
try:
x = float(line[30:38])
y = float(line[38:46])
z = float(line[46:54])
if math.isnan(x) or math.isnan(y) or math.isnan(z):
raise Exception()
except:
raise PDBParsingError("Wrong coordinates in '%s'" % line)
try:
import argparse
import os
import numpy as np
from lightdock.error.lightdock_errors import LightDockError
from lightdock.util.logger import LoggingManager
from lightdock.constants import DEFAULT_LIST_EXTENSION, DEFAULT_LIGHTDOCK_PREFIX, \
DEFAULT_NMODES_REC, DEFAULT_NMODES_LIG, DEFAULT_REC_NM_FILE, DEFAULT_LIG_NM_FILE
from lightdock.pdbutil.PDBIO import parse_complex_from_file, write_pdb_to_file
from lightdock.structure.complex import Complex
from lightdock.mathutil.cython.quaternion import Quaternion
from lightdock.structure.nm import read_nmodes
from lightdock.prep.simulation import get_setup_from_file
log = LoggingManager.get_logger('generate_conformations')
def valid_file(file_name):
"""Checks if it is a valid file"""
if not os.path.exists(file_name):
raise argparse.ArgumentTypeError("The file does not exist")
return file_name
def valid_integer_number(ivalue):
"""Checks for a valid integer"""
try:
ivalue = int(ivalue)
except:
raise argparse.ArgumentTypeError("%s is an invalid value" % ivalue)
#!/usr/bin/env python
"""Calculates few statistics about the result of the simulation"""
import sys
import os
from lightdock.util.logger import LoggingManager
from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
from matplotlib.figure import Figure
log = LoggingManager.get_logger('stats')
def usage():
"""Displays usage parameters and exists with error"""
log.error("Wrong arguments")
raise SystemExit("usage: %s number_of_steps number_of_glowworms" % (sys.argv[0]))
def parse_command_line():
# Arguments parsing
if len(sys.argv) != 3:
usage()
try:
num_steps = int(sys.argv[1])
except Exception, e:
log.error(str(e))
try:
num_glowworms = int(sys.argv[2])
"""Generates the top N structures in PDB format given a ranking file"""
import argparse
import os
import numpy as np
from lightdock.mathutil.cython.quaternion import Quaternion
from lightdock.util.analysis import read_lightdock_output
from lightdock.util.logger import LoggingManager
from lightdock.constants import DEFAULT_NMODES_REC, DEFAULT_NMODES_LIG, DEFAULT_REC_NM_FILE, DEFAULT_LIG_NM_FILE
from lightdock.pdbutil.PDBIO import parse_complex_from_file, write_pdb_to_file
from lightdock.structure.complex import Complex
from lightdock.structure.nm import read_nmodes
from lightdock.util.parser import CommandLineParser, get_lightdock_structures
log = LoggingManager.get_logger('lightdock_top')
if __name__ == "__main__":
parser = argparse.ArgumentParser(prog="conformer_conformations")
# Receptor
parser.add_argument("receptor_structures", help="receptor structures: PDB file or list of PDB files",
type=CommandLineParser.valid_file, metavar="receptor_structure")
# Ligand
parser.add_argument("ligand_structures", help="ligand structures: PDB file or list of PDB files",
type=CommandLineParser.valid_file, metavar="ligand_structure")
# Ranking file
parser.add_argument("lightdock_ranking_file", help="LightDock ranking file",
type=CommandLineParser.valid_file, metavar="lightdock_ranking_file")
# Number of structures to generate
#!/usr/bin/env python
"""Calculates the ranking file by scoring intra-swarm"""
from __future__ import print_function
import sys
import os
import argparse
from lightdock.util.logger import LoggingManager
from lightdock.constants import DEFAULT_SWARM_FOLDER, GSO_OUTPUT_FILE
from lightdock.util.analysis import read_ranking_file
from lightdock.util.analysis import read_lightdock_output
from lightdock.util.analysis import write_ranking_to_file
log = LoggingManager.get_logger('lgd_rank_swarm')
def parse_command_line():
parser = argparse.ArgumentParser(prog='lgd_rank_swarm')
parser.add_argument("num_swarms", help="number of swarms to consider", type=int, metavar="num_swarms")
parser.add_argument("steps", help="steps to consider", type=int, metavar="steps")
return parser.parse_args()
if __name__ == '__main__':
try:
CURRENT_FOLDER = os.getcwd()
args = parse_command_line()
Reference: SwarmDock and the use of Normal Models in Protein-Protein Docking
https://www.ncbi.nlm.nih.gov/pmc/articles/PMC2996808/
"""
import numpy as np
from lightdock.scoring.functions import ScoringFunction, ModelAdapter
from lightdock.structure.model import DockingModel
import lightdock.scoring.sd.energy.c.sd as sd
from lightdock.util.logger import LoggingManager
from lightdock.scoring.sd.data.amber import amber_types, masses, charges
import lightdock.scoring.sd.data.vdw as vdw
log = LoggingManager.get_logger('sd')
class SDModel(DockingModel):
"""Prepares the structure necessary for the C-implementation"""
def __init__(self, objects, coordinates, restraints,
elec_charges, vdw_energy, vdw_radii, reference_points=None, n_modes=None):
super(SDModel, self).__init__(objects, coordinates, restraints, reference_points)
self.charges = elec_charges
self.vdw_energy = vdw_energy
self.vdw_radii = vdw_radii
self.n_modes = n_modes
def clone(self):
"""Creates a copy of the current model"""
return SDModel(self.objects, self.coordinates.copy(), self.restraints, self.charges.copy(), self.vdw_energy.copy(),
#!/usr/bin/env python
"""Calculates the diameter of a given PDB structure"""
import argparse
from scipy import spatial
import numpy as np
from lightdock.pdbutil.PDBIO import parse_complex_from_file
from lightdock.structure.complex import Complex
from lightdock.util.logger import LoggingManager
log = LoggingManager.get_logger('diameter')
def parse_command_line():
parser = argparse.ArgumentParser(prog='calculate_diameter')
parser.add_argument("pdb", help="PDB file for structure to calculate maximum diameter")
args = parser.parse_args()
return args
if __name__ == "__main__":
args = parse_command_line()
atoms, residues, chains = parse_complex_from_file(args.pdb)
structure = Complex(chains, atoms, structure_file_name=args.pdb)
distances_matrix = spatial.distance.squareform(spatial.distance.pdist(structure.representative()))
ligand_max_diameter = np.max(distances_matrix)
print ligand_max_diameter
#!/usr/bin/env python3
"""Calculates the diameter of a given PDB structure"""
import argparse
from scipy import spatial
import numpy as np
from lightdock.pdbutil.PDBIO import parse_complex_from_file
from lightdock.structure.complex import Complex
from lightdock.util.logger import LoggingManager
log = LoggingManager.get_logger('diameter')
def parse_command_line():
parser = argparse.ArgumentParser(prog='calculate_diameter')
parser.add_argument(
"pdb", help="PDB file for structure to calculate maximum diameter")
args = parser.parse_args()
return args
if __name__ == "__main__":
args = parse_command_line()
atoms, residues, chains = parse_complex_from_file(args.pdb)
structure = Complex(chains, atoms, structure_file_name=args.pdb)
distances_matrix = spatial.distance.squareform(
spatial.distance.pdist(structure.representative()))
ligand_max_diameter = np.max(distances_matrix)
print(ligand_max_diameter)
import os
import argparse
import numpy as np
import math
from lightdock.constants import DEFAULT_SWARM_FOLDER, CLUSTER_REPRESENTATIVES_FILE, \
GSO_OUTPUT_FILE, DEFAULT_POSITIONS_FOLDER, DEFAULT_BILD_STARTING_PREFIX, CLUSTERS_CENTERS_FILE, \
DEFAULT_STARTING_PREFIX
from lightdock.prep.poses import create_file_from_poses
from lightdock.util.logger import LoggingManager
from lightdock.util.analysis import read_lightdock_output
from lightdock.prep.geometry import create_bild_file
from lightdock.pdbutil.PDBIO import create_pdb_from_points
log = LoggingManager.get_logger('lgd_prepare_new_simulation')
def parse_command_line():
parser = argparse.ArgumentParser(prog='lgd_prepare_new_simulation')
parser.add_argument("cluster", help="cluster to consider", type=int, metavar="cluster")
parser.add_argument("steps", help="steps to consider", type=int, metavar="steps")
parser.add_argument("destination", help="destination folder", metavar="destination")
parser.add_argument("-nm", "--nm", help="Keep normal modes in starting positions if exist",
dest="nm", action="store_true")
return parser.parse_args()
def read_cluster_representative_data(file_name):
glowworms = []
with open(file_name) as input_file:
"""Module to calculate normal modes of a given protein.
It uses the awesome Prody library
"""
import numpy as np
from prody import parsePDB, ANM, extendModel, confProDy
from lightdock.error.lightdock_errors import NormalModesCalculationError
from lightdock.util.logger import LoggingManager
# Disable ProDy output
confProDy(verbosity='none')
log = LoggingManager.get_logger('ANM')
def calculate_nmodes(pdb_file_name, n_modes, molecule):
"""Calculates Normal modes for a given molecule"""
prody_molecule = parsePDB(pdb_file_name)
# Try first for proteins
backbone_atoms = prody_molecule.select('name CA')
if not backbone_atoms:
# If previous step has failed, maybe we're dealing with DNA
backbone_atoms = prody_molecule.select("nucleic and name C4'")
if not backbone_atoms:
raise NormalModesCalculationError("Error selecting backbone atoms (protein or DNA)")
molecule_anm = ANM('molecule backbone')
molecule_anm.buildHessian(backbone_atoms)
molecule_anm.calcModes(n_modes=n_modes)
num_atoms_prody = prody_molecule.numAtoms()
import argparse
import os
import numpy as np
import importlib
from lightdock.util.logger import LoggingManager
from lightdock.constants import DEFAULT_NMODES_REC, DEFAULT_NMODES_LIG, \
DEFAULT_REC_NM_FILE, DEFAULT_LIG_NM_FILE, DEFAULT_SCORING_FUNCTION
from lightdock.pdbutil.PDBIO import parse_complex_from_file
from lightdock.structure.complex import Complex
from lightdock.mathutil.cython.quaternion import Quaternion
from lightdock.structure.nm import read_nmodes
from scipy.optimize import fmin_powell
log = LoggingManager.get_logger('minimizer')
def valid_file(file_name):
"""Checks if it is a valid file"""
if not os.path.exists(file_name):
raise argparse.ArgumentTypeError("The file does not exist")
return file_name
def valid_integer_number(ivalue):
"""Checks for a valid integer"""
try:
ivalue = int(ivalue)
except:
raise argparse.ArgumentTypeError("%s is an invalid value" % ivalue)
import json
import time
from lightdock.prep.poses import calculate_initial_poses
from lightdock.constants import DEFAULT_POSITIONS_FOLDER, DEFAULT_SWARM_FOLDER, DEFAULT_LIST_EXTENSION, \
DEFAULT_LIGHTDOCK_PREFIX, DEFAULT_NMODES_REC, DEFAULT_NMODES_LIG, DEFAULT_REC_NM_FILE, DEFAULT_LIG_NM_FILE, \
MIN_EXTENT, MAX_EXTENT, DEFAULT_SETUP_FILE, DEFAULT_LIGHTDOCK_INFO, DEFAULT_POSITIONS_FOLDER, \
DEFAULT_STARTING_PREFIX, MAX_TRANSLATION, MAX_ROTATION
from lightdock.util.logger import LoggingManager
from lightdock.pdbutil.PDBIO import parse_complex_from_file, write_pdb_to_file
from lightdock.structure.complex import Complex
from lightdock.structure.nm import calculate_nmodes, write_nmodes
from lightdock.gso.boundaries import Boundary, BoundingBox
from lightdock.error.lightdock_errors import LightDockError
log = LoggingManager.get_logger('lightdock_setup')
def get_pdb_files(input_file):
"""Get a list of the PDB files in the input_file"""
file_names = []
with open(input_file) as input:
for line in input:
file_name = line.rstrip(os.linesep)
if os.path.exists(file_name):
file_names.append(file_name)
return file_names
def read_input_structure(pdb_file_name, ignore_oxt=True):
"""Reads the input structure.
import sys
import os
import argparse
import shutil
import re
from prody.measure.contacts import Contacts
from prody import parsePDB, confProDy
from lightdock.util.logger import LoggingManager
from lightdock.util.analysis import read_ranking_file
# Disable ProDy output
confProDy(verbosity='info')
filtered_folder = 'filtered'
log = LoggingManager.get_logger('lgd_filter_restraints')
def get_structures(ranking, base_path='.'):
structures = []
for rank in ranking:
swarm_id = rank.id_cluster
glowworm_id = rank.id_glowworm
score = rank.scoring
structures.append([os.path.join(base_path,
'swarm_{}'.format(swarm_id),
'lightdock_{}.pdb'.format(glowworm_id)), score])
return structures
def get_restraints(restraints_file):
#!/usr/bin/env python3
"""Calculates few statistics about the result of the simulation"""
import sys
import os
from lightdock.util.logger import LoggingManager
from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
from matplotlib.figure import Figure
log = LoggingManager.get_logger('stats')
def usage():
"""Displays usage parameters and exists with error"""
log.error("Wrong arguments")
raise SystemExit("usage: %s number_of_steps number_of_glowworms" % (sys.argv[0]))
def parse_command_line():
# Arguments parsing
if len(sys.argv) != 3:
usage()
try:
num_steps = int(sys.argv[1])
except Exception as e:
log.error(str(e))
try:
num_glowworms = int(sys.argv[2])
#!/usr/bin/env python
"""Calculates the reference points of the simulation"""
import os
import argparse
from lightdock.constants import DEFAULT_LIST_EXTENSION, DEFAULT_REFERENCE_POINTS_EXTENSION
from lightdock.error.lightdock_errors import MinimumVolumeEllipsoidError
from lightdock.mathutil.ellipsoid import MinimumVolumeEllipsoid
from lightdock.pdbutil.PDBIO import parse_complex_from_file, create_pdb_from_points
from lightdock.structure.complex import Complex
from lightdock.util.logger import LoggingManager
script_name = 'reference_points'
log = LoggingManager.get_logger(script_name)
def parse_command_line():
parser = argparse.ArgumentParser(prog=script_name)
parser.add_argument("structure", help="structure to calculate reference points", metavar="structure")
parser.add_argument("--noxt", help="Remove OXT atoms", dest="noxt", action='store_true', default=False)
return parser.parse_args()
def get_pdb_files(input_file_name):
"""Get a list of the PDB files in the input_file_name"""
structure_file_names = []
with open(input_file_name) as input_file:
for line in input_file:
structure_file_name = line.rstrip(os.linesep)
#!/usr/bin/env python
"""Calculates the density of surface points"""
import argparse
from lightdock.constants import MIN_SURFACE_DENSITY
from lightdock.pdbutil.PDBIO import parse_complex_from_file
from lightdock.structure.complex import Complex
from lightdock.util.logger import LoggingManager
from scipy import spatial
import numpy as np
log = LoggingManager.get_logger('surface_density')
def parse_command_line():
"""
Parses command line arguments
"""
parser = argparse.ArgumentParser(prog='surface_density')
parser.add_argument("pdb1", help="PDB file for receptor structure")
parser.add_argument("pdb2", help="PDB file for ligand structure")
parser.add_argument("points", type=int, default=400, help="The number of points on the surface")
args = parser.parse_args()
return args
if __name__ == "__main__":
args = parse_command_line()
#!/usr/bin/env python
"""Calculates the ranking files depending of different metrics"""
import os
import argparse
from lightdock.constants import DEFAULT_SWARM_FOLDER, GSO_OUTPUT_FILE, EVALUATION_FILE, SCORING_FILE, \
LIGHTDOCK_PDB_FILE, CLUSTER_REPRESENTATIVES_FILE
from lightdock.util.logger import LoggingManager
from lightdock.util.analysis import read_rmsd_and_contacts_data, read_lightdock_output, write_ranking_to_file, \
read_cluster_representatives_file
log = LoggingManager.get_logger('lgd_rank')
def parse_command_line():
parser = argparse.ArgumentParser(prog='lgd_rank')
parser.add_argument("num_clusters", help="number of clusters to consider", type=int, metavar="num_clusters")
parser.add_argument("steps", help="steps to consider", type=int, metavar="steps")
parser.add_argument("-c", "--clashes_cutoff", help="clashes cutoff", dest="clashes_cutoff", type=float)
parser.add_argument("-f", "--file_name", help="lightdock output file to consider", dest="result_file")
parser.add_argument("--ignore_clusters", help="Ignore cluster information", dest="ignore_clusters",
action="store_true")
return parser.parse_args()
if __name__ == "__main__":
try:
# Parse command line
args = parse_command_line()
"""DFIRE potentials scoring functions
S. Liu, C. Zhang, H. Zhou, and Y. Zhou, A physical reference state unifies the structure-derived
potential of mean force for protein folding and binding. Proteins 56, 93-101 (2004)
"""
import os
from lightdock.structure.model import DockingModel
from lightdock.scoring.functions import ModelAdapter, ScoringFunction
from lightdock.scoring.dfire.cython.cdfire import calculate_dfire
from lightdock.util.logger import LoggingManager
log = LoggingManager.get_logger('dfire')
class DFIREPotential(object):
"""Loads DFIRE potentials information"""
atoms_in_residues = {'ALA': ['N', 'CA', 'C', 'O', 'CB'],
'CYS': ['N', 'CA', 'C', 'O', 'CB', 'SG'],
'ASP': ['N', 'CA', 'C', 'O', 'CB', 'CG', 'OD1', 'OD2'],
'GLU': ['N', 'CA', 'C', 'O', 'CB', 'CG', 'CD', 'OE1', 'OE2'],
'PHE': ['N', 'CA', 'C', 'O', 'CB', 'CG', 'CD1', 'CD2', 'CE1', 'CE2', 'CZ'],
'GLY': ['N', 'CA', 'C', 'O'],
'HIS': ['N', 'CA', 'C', 'O', 'CB', 'CG', 'ND1', 'CD2', 'CE1', 'NE2'],
'ILE': ['N', 'CA', 'C', 'O', 'CB', 'CG1', 'CG2', 'CD1'], # or maybe 'CD' if CHARMM
'LYS': ['N', 'CA', 'C', 'O', 'CB', 'CG', 'CD', 'CE', 'NZ'],
'LEU': ['N', 'CA', 'C', 'O', 'CB', 'CG', 'CD1', 'CD2'],
'MET': ['N', 'CA', 'C', 'O', 'CB', 'CG', 'SD', 'CE'],
'ASN': ['N', 'CA', 'C', 'O', 'CB', 'CG', 'OD1', 'ND2'],
'PRO': ['N', 'CA', 'C', 'O', 'CB', 'CG', 'CD'],
#!/usr/bin/env python3
"""Copy clustered structures to new folder for analysis"""
import sys
import os
import argparse
import shutil
import re
from lightdock.util.logger import LoggingManager
from lightdock.util.analysis import read_ranking_file
clustered_folder = 'clustered'
log = LoggingManager.get_logger('lgd_copy_structures')
def get_structures(ranking, base_path='.'):
structures = []
for rank in ranking:
swarm_id = rank.id_swarm
glowworm_id = rank.id_glowworm
score = rank.scoring
structures.append([
os.path.join(base_path, 'swarm_{}'.format(swarm_id),
'lightdock_{}.pdb'.format(glowworm_id)), score
])
return structures
def parse_command_line():
"""Parses command line arguments"""
https://github.com/mittinatten/freesasa
"""
import numpy as np
import freesasa
from freesasa import Structure
from lightdock.scoring.functions import ScoringFunction, ModelAdapter
from lightdock.structure.model import DockingModel
import lightdock.scoring.cpydock.energy.c.cpydock as cpydock
import lightdock.scoring.cpydock.energy.parameters as parameters
from lightdock.util.logger import LoggingManager
import lightdock.scoring.cpydock.data.amber as amber
import lightdock.scoring.cpydock.data.vdw as vdw
import lightdock.scoring.cpydock.data.solvation as solvation
log = LoggingManager.get_logger('cpydock')
freesasa.setVerbosity(freesasa.silent)
class CPyDockModel(DockingModel):
"""Prepares the structure necessary for the C-implementation of the pyDock scoring function"""
def __init__(self, objects, coordinates, restraints, charges,
vdw_energy, vdw_radii, des_energy, des_radii, sasa, hydrogens,
reference_points=None, n_modes=None):
super(CPyDockModel, self).__init__(objects, coordinates, restraints, reference_points)
self.charges = charges
self.vdw_energy = vdw_energy
self.vdw_radii = vdw_radii
self.des_energy = des_energy
self.des_radii = des_radii
self.sasa = sasa
"""Generates the simulated trajectory of a given glowworm in a swarm"""
import argparse
import os
import numpy as np
from lightdock.constants import DEFAULT_NMODES_REC, DEFAULT_NMODES_LIG, DEFAULT_REC_NM_FILE, DEFAULT_LIG_NM_FILE
from lightdock.structure.nm import read_nmodes
from lightdock.util.logger import LoggingManager
from lightdock.mathutil.cython.quaternion import Quaternion
from lightdock.error.lightdock_errors import LightDockError
from lightdock.pdbutil.PDBIO import parse_complex_from_file, write_pdb_to_file
from lightdock.structure.complex import Complex
from lightdock.prep.simulation import get_setup_from_file
log = LoggingManager.get_logger('lgd_generate_trajectory')
def valid_file(file_name):
"""Checks if it is a valid file"""
if not os.path.exists(file_name):
raise argparse.ArgumentTypeError("The file does not exist")
return file_name
def parse_command_line():
parser = argparse.ArgumentParser(prog='lgd_generate_trajectory')
parser.add_argument("glowworm_id", help="glowworm to consider", type=int, metavar="glowworm_id")
parser.add_argument("steps", help="steps to consider", type=int, metavar="steps")
parser.add_argument("receptor_pdb", help="Receptor LightDock parsed PDB structure", type=valid_file,
metavar="receptor_pdb")
Reference: SwarmDock and the use of Normal Models in Protein-Protein Docking
https://www.ncbi.nlm.nih.gov/pmc/articles/PMC2996808/
"""
import numpy as np
from lightdock.scoring.functions import ScoringFunction, ModelAdapter
from lightdock.structure.model import DockingModel
import lightdock.scoring.sd.energy.c.sd as sd
from lightdock.util.logger import LoggingManager
from lightdock.scoring.sd.data.amber import amber_types, masses, charges
import lightdock.scoring.sd.data.vdw as vdw
from lightdock.constants import DEFAULT_CONTACT_RESTRAINTS_CUTOFF
log = LoggingManager.get_logger('sd')
class SDModel(DockingModel):
"""Prepares the structure necessary for the C-implementation"""
def __init__(self,
objects,
coordinates,
restraints,
elec_charges,
vdw_energy,
vdw_radii,
reference_points=None,
n_modes=None):
super(SDModel, self).__init__(objects, coordinates, restraints,
reference_points)
#!/usr/bin/env python
"""Cluster LightDock final swarm results using an hierarchical algorithm"""
import os
import argparse
import math
import numpy as np
import scipy.cluster.hierarchy as hier
import Bio.PDB
from lightdock.constants import CLUSTER_ANALYSIS_FILE, DEFAULT_SWARM_FOLDER, DEFAULT_RMSD_EXTENSION, \
NUMPY_FILE_SAVE_EXTENSION, EVALUATION_FILE, SCORING_FILE, GSO_OUTPUT_FILE, LIGHTDOCK_PDB_FILE, \
CLUSTER_DEFAULT_NAME, CLUSTER_REPRESENTATIVES_FILE
from lightdock.util.logger import LoggingManager
from lightdock.util.analysis import read_rmsd_and_contacts_data, read_lightdock_output
log = LoggingManager.get_logger('lgd_cluster_hierarchical')
POPULATION_THRESHOLD = 10
def parse_command_line():
"""
Parses command line arguments
"""
parser = argparse.ArgumentParser(prog='cluster_poses')
parser.add_argument("swarm_id",
help="swarm to consider for clustering",
type=int,
metavar="swarm_id")
parser.add_argument("steps",
#!/usr/bin/env python
"""Converts a Quaternion to a Rotation Matrix"""
import argparse
from lightdock.util.logger import LoggingManager
from lightdock.util.analysis import read_ranking_file
from lightdock.mathutil.cython.quaternion import Quaternion
log = LoggingManager.get_logger('quaternion2rot')
def parse_command_line():
parser = argparse.ArgumentParser(prog='quaternion2rot')
parser.add_argument("ranking_file", help="lightdock ranking file name")
parser.add_argument("rotation_file", help="pyDock rotation file name")
args = parser.parse_args()
return args
def quaternion_to_matrix(q):
x2 = q.x * q.x
y2 = q.y * q.y
z2 = q.z * q.z
r11 = 1 - 2 * y2 - 2 * z2
r12 = 2 * (q.x * q.y) + 2 * (q.w * q.z)
r13 = 2 * (q.x * q.z) - 2 * (q.w * q.y)
r21 = 2 * (q.x * q.y) - 2 * (q.w * q.z)
r22 = 1 - 2 * x2 - 2 * z2
r23 = 2 * (q.y * q.z) + 2 * (q.w * q.x)
r31 = 2 * (q.x * q.z) + 2 * (q.w * q.y)
r32 = 2 * (q.y * q.z) - 2 * (q.w * q.x)
"""
import os
import argparse
import numpy as np
import math
from lightdock.constants import DEFAULT_SWARM_FOLDER, CLUSTER_REPRESENTATIVES_FILE, \
GSO_OUTPUT_FILE, DEFAULT_POSITIONS_FOLDER, DEFAULT_BILD_STARTING_PREFIX, CLUSTERS_CENTERS_FILE, \
DEFAULT_STARTING_PREFIX
from lightdock.prep.poses import create_file_from_poses
from lightdock.util.logger import LoggingManager
from lightdock.util.analysis import read_lightdock_output
from lightdock.prep.geometry import create_bild_file
from lightdock.pdbutil.PDBIO import create_pdb_from_points
log = LoggingManager.get_logger('lgd_prepare_new_simulation')
def parse_command_line():
parser = argparse.ArgumentParser(prog='lgd_prepare_new_simulation')
parser.add_argument("swarm",
help="swarm to consider",
type=int,
metavar="swarm")
parser.add_argument("steps",
help="steps to consider",
type=int,
metavar="steps")
parser.add_argument("destination",
help="destination folder",
metavar="destination")
#!/usr/bin/env python
"""Translates a LightDock output file to CSV format"""
import argparse
import os
from lightdock.util.logger import LoggingManager
log = LoggingManager.get_logger('lightdock2csv')
DEFAULT_SEP = ','
def parse_command_line():
parser = argparse.ArgumentParser(prog='lightdock2csv')
parser.add_argument("ranking_file", help="lightdock ranking file name")
parser.add_argument("csv_file", help="csv format file name")
parser.add_argument("-s", "--sep", help="csv file separator character", dest="csv_sep", default=DEFAULT_SEP)
args = parser.parse_args()
return args
if __name__ == "__main__":
try:
# Parse command line
args = parse_command_line()
fin = open(args.ranking_file)
lines = fin.readlines()
fin.close()
output = open(args.csv_file, 'w')
output.write(args.csv_sep.join(lines[0].split()) + os.linesep)
#!/usr/bin/env python
"""Calculates the density of surface points"""
import argparse
from lightdock.constants import MIN_SURFACE_DENSITY
from lightdock.pdbutil.PDBIO import parse_complex_from_file
from lightdock.structure.complex import Complex
from lightdock.util.logger import LoggingManager
from scipy import spatial
import numpy as np
log = LoggingManager.get_logger('surface_density')
def parse_command_line():
"""
Parses command line arguments
"""
parser = argparse.ArgumentParser(prog='surface_density')
parser.add_argument("pdb1", help="PDB file for receptor structure")
parser.add_argument("pdb2", help="PDB file for ligand structure")
parser.add_argument("points", type=int, default=400, help="The number of points on the surface")
args = parser.parse_args()
return args
if __name__ == "__main__":
args = parse_command_line()
import argparse
import os
import numpy as np
from lightdock.error.lightdock_errors import LightDockError
from lightdock.util.logger import LoggingManager
from lightdock.constants import DEFAULT_LIST_EXTENSION, DEFAULT_LIGHTDOCK_PREFIX, \
DEFAULT_NMODES_REC, DEFAULT_NMODES_LIG, DEFAULT_REC_NM_FILE, DEFAULT_LIG_NM_FILE
from lightdock.pdbutil.PDBIO import parse_complex_from_file, write_pdb_to_file
from lightdock.structure.complex import Complex
from lightdock.mathutil.cython.quaternion import Quaternion
from lightdock.structure.nm import read_nmodes
from lightdock.prep.simulation import get_setup_from_file
from lightdock.util.parser import valid_file, valid_integer_number, get_lightdock_structures
log = LoggingManager.get_logger('generate_conformations')
def parse_output_file(lightdock_output, num_anm_rec, num_anm_lig):
translations = []
rotations = []
receptor_ids = []
ligand_ids = []
rec_extents = []
lig_extents = []
data_file = open(lightdock_output)
lines = data_file.readlines()
data_file.close()
counter = 0
"""Cluster LightDock final swarm results using an hierarchical algorithm"""
import os
import argparse
import math
import numpy as np
import scipy.cluster.hierarchy as hier
import Bio.PDB
from lightdock.constants import CLUSTER_ANALYSIS_FILE, DEFAULT_SWARM_FOLDER, DEFAULT_RMSD_EXTENSION, \
NUMPY_FILE_SAVE_EXTENSION, EVALUATION_FILE, SCORING_FILE, GSO_OUTPUT_FILE, LIGHTDOCK_PDB_FILE, \
CLUSTER_DEFAULT_NAME, CLUSTER_REPRESENTATIVES_FILE
from lightdock.util.logger import LoggingManager
from lightdock.util.analysis import read_rmsd_and_contacts_data, read_lightdock_output
log = LoggingManager.get_logger('lgd_cluster_hierarchical')
POPULATION_THRESHOLD = 10
def parse_command_line():
"""
Parses command line arguments
"""
parser = argparse.ArgumentParser(prog='cluster_poses')
parser.add_argument("swarm_id", help="swarm to consider for clustering", type=int, metavar="swarm_id")
parser.add_argument("steps", help="steps to consider", type=int, metavar="steps")
parser.add_argument("-f", "--file_name", help="lightdock output file to consider", dest="result_file")
parser.add_argument("-p", "--ponderated", help="Structures selection takes into account cluster population",
#!/usr/bin/env python3
"""Calculates the ranking file by scoring intra-swarm"""
import os
import argparse
from lightdock.util.logger import LoggingManager
from lightdock.constants import DEFAULT_SWARM_FOLDER, GSO_OUTPUT_FILE
from lightdock.util.analysis import read_lightdock_output
from lightdock.util.analysis import write_ranking_to_file
log = LoggingManager.get_logger('lgd_rank_swarm')
def parse_command_line():
parser = argparse.ArgumentParser(prog='lgd_rank_swarm')
parser.add_argument("num_swarms",
help="number of swarms to consider",
type=int,
metavar="num_swarms")
parser.add_argument("steps",
help="steps to consider",
type=int,
metavar="steps")
return parser.parse_args()
if __name__ == '__main__':
try:
current_path = os.getcwd()
args = parse_command_line()
"""Parses Atomic coordinates entries from PDB files"""
import math
from lightdock.error.lightdock_errors import PDBParsingError, PDBParsingWarning
from lightdock.structure.atom import Atom, HetAtom
from lightdock.structure.residue import Residue
from lightdock.structure.chain import Chain
from lightdock.util.logger import LoggingManager
log = LoggingManager.get_logger('pdb')
def cstrip(string):
"""Remove unwanted symbols from string."""
return string.strip(' \t\n\r')
def read_atom_line(line, line_type='', atoms_to_ignore=[]):
"""Parses a PDB file line starting with 'ATOM' or 'HETATM'"""
element = cstrip(line[76:78])
try:
x = float(line[30:38])
y = float(line[38:46])
z = float(line[46:54])
if math.isnan(x) or math.isnan(y) or math.isnan(z):
raise Exception()
except:
raise PDBParsingError("Wrong coordinates in '%s'" % line)
try:
C-implementation of the pyDockDNA scoring function (no desolvation) and
custom VdW weight.
"""
import numpy as np
from lightdock.scoring.functions import ScoringFunction, ModelAdapter
from lightdock.structure.model import DockingModel
import lightdock.scoring.dna.energy.c.cdna as cdna
import lightdock.scoring.dna.energy.parameters as parameters
from lightdock.util.logger import LoggingManager
import lightdock.scoring.dna.data.amber as amber
import lightdock.scoring.dna.data.vdw as vdw
from lightdock.constants import DEFAULT_CONTACT_RESTRAINTS_CUTOFF
from lightdock.error.lightdock_errors import NotSupportedInScoringError
log = LoggingManager.get_logger('dna')
class DNAModel(DockingModel):
"""Prepares the structure necessary for the scoring function"""
def __init__(self,
objects,
coordinates,
restraints,
charges,
vdw_energy,
vdw_radii,
reference_points=None,
n_modes=None):
super(DNAModel, self).__init__(objects, coordinates, restraints,
reference_points)
#!/usr/bin/env python3
"""Calculates the ranking files depending of different metrics"""
import os
import argparse
from lightdock.constants import DEFAULT_SWARM_FOLDER, GSO_OUTPUT_FILE, EVALUATION_FILE, SCORING_FILE, \
LIGHTDOCK_PDB_FILE, CLUSTER_REPRESENTATIVES_FILE
from lightdock.util.logger import LoggingManager
from lightdock.util.analysis import read_rmsd_and_contacts_data, read_lightdock_output, write_ranking_to_file, \
read_cluster_representatives_file
log = LoggingManager.get_logger('lgd_rank')
def parse_command_line():
parser = argparse.ArgumentParser(prog='lgd_rank')
parser.add_argument("num_swarms",
help="number of swarms to consider",
type=int,
metavar="num_swarms")
parser.add_argument("steps",
help="steps to consider",
type=int,
metavar="steps")
parser.add_argument("-c",
"--clashes_cutoff",
help="clashes cutoff",
dest="clashes_cutoff",
type=float)
parser.add_argument("-f",
"--file_name",
"""Truncated Van der Waals energy"""
import numpy as np
from lightdock.scoring.functions import ScoringFunction, ModelAdapter
from lightdock.scoring.vdw.data import amber
from lightdock.scoring.vdw.data import vdw
from lightdock.structure.model import DockingModel
import lightdock.scoring.vdw.energy.c.cvdw as cvdw
from lightdock.util.logger import LoggingManager
from lightdock.constants import DEFAULT_CONTACT_RESTRAINTS_CUTOFF
log = LoggingManager.get_logger('vdw')
class VdWModel(DockingModel):
"""Prepares the necessary structure"""
def __init__(self,
objects,
coordinates,
restraints,
vdw_energy,
vdw_radii,
reference_points=None,
n_modes=None):
super(VdWModel, self).__init__(objects, coordinates, restraints,
reference_points)
self.vdw_energy = vdw_energy
self.vdw_radii = vdw_radii
self.n_modes = n_modes
#!/usr/bin/env python
"""Generates the trajectory of a given glowworm in a swarm simulation"""
import sys
import os
import numpy as np
from lightdock.constants import DEFAULT_NMODES_REC, DEFAULT_NMODES_LIG, DEFAULT_REC_NM_FILE, DEFAULT_LIG_NM_FILE
from lightdock.structure.nm import read_nmodes
from lightdock.util.logger import LoggingManager
from lightdock.mathutil.cython.quaternion import Quaternion
from lightdock.error.lightdock_errors import LightDockError
from lightdock.pdbutil.PDBIO import parse_complex_from_file, write_pdb_to_file
from lightdock.structure.complex import Complex
log = LoggingManager.get_logger('trajectory')
def usage():
"""Displays usage parameters and exists with error"""
log.error("Wrong arguments")
raise SystemExit("usage: %s glowworm_id steps receptor_pdb ligand_pdb" % (sys.argv[0]))
def parse_command_line():
# Arguments parsing
if len(sys.argv) != 5:
usage()
try:
glowworm_id = int(sys.argv[1])
except Exception, e:
from lightdock.util.logger import LoggingManager
from lightdock.util.parser import CommandLineParser
from lightdock.prep.simulation import get_setup_from_file, create_simulation_info_file, read_input_structure, \
load_starting_positions, get_default_box
from lightdock.gso.algorithm import LightdockGSOBuilder
from lightdock.mathutil.lrandom import MTGenerator
from lightdock.gso.parameters import GSOParameters
from lightdock.constants import DEFAULT_SCORING_FUNCTION, DEFAULT_SWARM_FOLDER, \
DEFAULT_REC_NM_FILE, DEFAULT_LIG_NM_FILE, NUMPY_FILE_SAVE_EXTENSION, \
DEFAULT_NMODES_REC, DEFAULT_NMODES_LIG, DEFAULT_LIGHTDOCK_PREFIX
from lightdock.parallel.kraken import Kraken
from lightdock.parallel.util import GSOClusterTask
from lightdock.scoring.multiple import ScoringConfiguration
from lightdock.structure.nm import read_nmodes
log = LoggingManager.get_logger('lightdock')
def set_gso(number_of_glowworms,
adapters,
scoring_functions,
initial_positions,
seed,
step_translation,
step_rotation,
configuration_file=None,
use_anm=False,
nmodes_step=0.1,
anm_rec=DEFAULT_NMODES_REC,
anm_lig=DEFAULT_NMODES_LIG,
local_minimization=False):
#!/usr/bin/env python
"""Cluster LightDock final swarm results using BSAS algorithm"""
import sys
import argparse
import Bio.PDB
from lightdock.util.analysis import read_lightdock_output
from lightdock.util.logger import LoggingManager
from lightdock.constants import CLUSTER_REPRESENTATIVES_FILE
log = LoggingManager.get_logger('lgd_cluster_bsas')
def parse_command_line():
"""Parses command line arguments"""
parser = argparse.ArgumentParser(prog='lgd_cluster_bsas')
parser.add_argument("gso_output_file", help="LightDock output file", metavar="gso_output_file")
return parser.parse_args()
def get_ca_atoms(ids_list):
"""Get all Carbon-alpha atoms of the PDB files specified by the ids_list.
PDB files follow the format lightdock_ID.pdb where ID is in ids_list
"""
ca_atoms = {}
try:
#!/usr/bin/env python
"""Converts a Quaternion to a Rotation Matrix"""
import argparse
from lightdock.util.logger import LoggingManager
from lightdock.util.analysis import read_ranking_file
from lightdock.mathutil.cython.quaternion import Quaternion
log = LoggingManager.get_logger('quaternion2rot')
def parse_command_line():
parser = argparse.ArgumentParser(prog='quaternion2rot')
parser.add_argument("ranking_file", help="lightdock ranking file name")
parser.add_argument("rotation_file", help="pyDock rotation file name")
args = parser.parse_args()
return args
def quaternion_to_matrix(q):
x2 = q.x * q.x
y2 = q.y * q.y
z2 = q.z * q.z
r11 = 1 - 2 * y2 - 2 * z2
r12 = 2 * (q.x * q.y) + 2 * (q.w * q.z)
r13 = 2 * (q.x * q.z) - 2 * (q.w * q.y)
r21 = 2 * (q.x * q.y) - 2 * (q.w * q.z)
r22 = 1 - 2 * x2 - 2 * z2
r23 = 2 * (q.y * q.z) + 2 * (q.w * q.x)
def __init__(self, tasks, profiling=False):
super(Tentacle, self).__init__()
self.tasks = tasks
self.profiling = profiling
self.log = LoggingManager.get_logger('kraken')
self.log.info("Tentacle ready with %d tasks" % len(self.tasks))
"""DFIRE potentials scoring functions
S. Liu, C. Zhang, H. Zhou, and Y. Zhou, A physical reference state unifies the structure-derived
potential of mean force for protein folding and binding. Proteins 56, 93-101 (2004)
"""
import os
from lightdock.structure.model import DockingModel
from lightdock.scoring.functions import ModelAdapter, ScoringFunction
from lightdock.scoring.dfire.cython.cdfire import calculate_dfire
from lightdock.util.logger import LoggingManager
from lightdock.constants import DEFAULT_CONTACT_RESTRAINTS_CUTOFF
log = LoggingManager.get_logger('dfire')
class DFIREPotential(object):
"""Loads DFIRE potentials information"""
atoms_in_residues = {'ALA': ['N', 'CA', 'C', 'O', 'CB'],
'CYS': ['N', 'CA', 'C', 'O', 'CB', 'SG'],
'ASP': ['N', 'CA', 'C', 'O', 'CB', 'CG', 'OD1', 'OD2'],
'GLU': ['N', 'CA', 'C', 'O', 'CB', 'CG', 'CD', 'OE1', 'OE2'],
'PHE': ['N', 'CA', 'C', 'O', 'CB', 'CG', 'CD1', 'CD2', 'CE1', 'CE2', 'CZ'],
'GLY': ['N', 'CA', 'C', 'O'],
'HIS': ['N', 'CA', 'C', 'O', 'CB', 'CG', 'ND1', 'CD2', 'CE1', 'NE2'],
'ILE': ['N', 'CA', 'C', 'O', 'CB', 'CG1', 'CG2', 'CD1'], # or maybe 'CD' if CHARMM
'LYS': ['N', 'CA', 'C', 'O', 'CB', 'CG', 'CD', 'CE', 'NZ'],
'LEU': ['N', 'CA', 'C', 'O', 'CB', 'CG', 'CD1', 'CD2'],
'MET': ['N', 'CA', 'C', 'O', 'CB', 'CG', 'SD', 'CE'],
'ASN': ['N', 'CA', 'C', 'O', 'CB', 'CG', 'OD1', 'ND2'],
#!/usr/bin/env python3
"""Calculates the reference points of the simulation"""
import os
import argparse
from lightdock.constants import DEFAULT_LIST_EXTENSION, DEFAULT_REFERENCE_POINTS_EXTENSION
from lightdock.error.lightdock_errors import MinimumVolumeEllipsoidError
from lightdock.mathutil.ellipsoid import MinimumVolumeEllipsoid
from lightdock.pdbutil.PDBIO import parse_complex_from_file, create_pdb_from_points
from lightdock.structure.complex import Complex
from lightdock.util.logger import LoggingManager
script_name = 'reference_points'
log = LoggingManager.get_logger(script_name)
def parse_command_line():
parser = argparse.ArgumentParser(prog=script_name)
parser.add_argument("structure",
help="structure to calculate reference points",
metavar="structure")
parser.add_argument("--noxt",
help="Remove OXT atoms",
dest="noxt",
action='store_true',
default=False)
return parser.parse_args()
def get_pdb_files(input_file_name):
"""Get a list of the PDB files in the input_file_name"""
def __init__(self, tasks, profiling=False):
super(Tentacle, self).__init__()
self.tasks = tasks
self.profiling = profiling
self.log = LoggingManager.get_logger('kraken')
self.log.info("Tentacle ready with %d tasks" % len(self.tasks))
"""Truncated Van der Waals energy"""
import numpy as np
from lightdock.scoring.functions import ScoringFunction, ModelAdapter
from lightdock.scoring.vdw.data import amber
from lightdock.scoring.vdw.data import vdw
from lightdock.structure.model import DockingModel
import lightdock.scoring.vdw.energy.c.cvdw as cvdw
from lightdock.util.logger import LoggingManager
log = LoggingManager.get_logger('vdw')
class VdWModel(DockingModel):
"""Prepares the necessary structure"""
def __init__(self, objects, coordinates, vdw_energy, vdw_radii, reference_points=None, n_modes=None):
super(VdWModel, self).__init__(objects, coordinates, reference_points)
self.vdw_energy = vdw_energy
self.vdw_radii = vdw_radii
self.n_modes = n_modes
def clone(self):
"""Creates a copy of the current model"""
return VdWModel(self.objects, self.coordinates.copy(), self.vdw_energy, self.vdw_radii,
reference_points=self.reference_points.copy())
class VdWAdapter(ModelAdapter):
"""Adapts a given Complex to a DockingModel object suitable for this scoring function."""
#!/usr/bin/env python
"""Generates the trajectory of a given glowworm in a swarm simulation"""
import sys
import os
import numpy as np
from lightdock.constants import DEFAULT_NMODES_REC, DEFAULT_NMODES_LIG, DEFAULT_REC_NM_FILE, DEFAULT_LIG_NM_FILE
from lightdock.structure.nm import read_nmodes
from lightdock.util.logger import LoggingManager
from lightdock.mathutil.cython.quaternion import Quaternion
from lightdock.error.lightdock_errors import LightDockError
from lightdock.pdbutil.PDBIO import parse_complex_from_file, write_pdb_to_file
from lightdock.structure.complex import Complex
log = LoggingManager.get_logger('trajectory')
def usage():
"""Displays usage parameters and exists with error"""
log.error("Wrong arguments")
raise SystemExit("usage: %s glowworm_id steps receptor_pdb ligand_pdb" %
(sys.argv[0]))
def parse_command_line():
# Arguments parsing
if len(sys.argv) != 5:
usage()
try:
glowworm_id = int(sys.argv[1])
except Exception, e:
import argparse
import shutil
import re
from prody.measure.contacts import Contacts
from prody import parsePDB, confProDy
from lightdock.util.logger import LoggingManager
from lightdock.util.analysis import read_ranking_file
from lightdock.pdbutil.PDBIO import parse_complex_from_file
from lightdock.structure.complex import Complex
# Disable ProDy output
confProDy(verbosity='info')
filtered_folder = 'filtered'
log = LoggingManager.get_logger('lgd_filter_membrane')
def get_structures(ranking, base_path='.'):
structures = []
for rank in ranking:
swarm_id = rank.id_cluster
glowworm_id = rank.id_glowworm
structures.append(os.path.join(base_path,
'swarm_{}'.format(swarm_id),
'lightdock_{}.pdb'.format(glowworm_id)))
return structures
def get_restraints(restraints_file):
restraints_receptor = set()
import glob
import json
import time
from lightdock.prep.poses import calculate_initial_poses
from lightdock.constants import DEFAULT_POSITIONS_FOLDER, DEFAULT_SWARM_FOLDER, DEFAULT_LIST_EXTENSION, \
DEFAULT_LIGHTDOCK_PREFIX, DEFAULT_NMODES_REC, DEFAULT_NMODES_LIG, \
MIN_EXTENT, MAX_EXTENT, DEFAULT_SETUP_FILE, DEFAULT_LIGHTDOCK_INFO, \
DEFAULT_STARTING_PREFIX, MAX_TRANSLATION, MAX_ROTATION
from lightdock.util.logger import LoggingManager
from lightdock.pdbutil.PDBIO import parse_complex_from_file, write_pdb_to_file
from lightdock.structure.complex import Complex
from lightdock.structure.nm import calculate_nmodes, write_nmodes
from lightdock.gso.boundaries import Boundary, BoundingBox
from lightdock.error.lightdock_errors import LightDockError
log = LoggingManager.get_logger('lightdock_setup')
def get_pdb_files(input_file):
"""Get a list of the PDB files in the input_file"""
file_names = []
with open(input_file) as input:
for line in input:
file_name = line.rstrip(os.linesep)
if os.path.exists(file_name):
file_names.append(file_name)
return file_names
def read_input_structure(pdb_file_name,
ignore_oxt=True,
"""
import numpy as np
import freesasa
from freesasa import Structure
from lightdock.scoring.functions import ScoringFunction, ModelAdapter
from lightdock.structure.model import DockingModel
import lightdock.scoring.cpydock.energy.c.cpydock as cpydock
import lightdock.scoring.cpydock.energy.parameters as parameters
from lightdock.util.logger import LoggingManager
import lightdock.scoring.cpydock.data.amber as amber
import lightdock.scoring.cpydock.data.vdw as vdw
import lightdock.scoring.cpydock.data.solvation as solvation
from lightdock.constants import DEFAULT_CONTACT_RESTRAINTS_CUTOFF
log = LoggingManager.get_logger('cpydock')
freesasa.setVerbosity(freesasa.silent)
class CPyDockModel(DockingModel):
"""Prepares the structure necessary for the C-implementation of the pyDock scoring function"""
def __init__(self,
objects,
coordinates,
restraints,
charges,
vdw_energy,
vdw_radii,
des_energy,
des_radii,
sasa,
import sys
import os
import argparse
import shutil
import re
from prody.measure.contacts import Contacts
from prody import parsePDB, confProDy
from lightdock.util.logger import LoggingManager
from lightdock.util.analysis import read_ranking_file
# Disable ProDy output
confProDy(verbosity='info')
filtered_folder = 'filtered'
log = LoggingManager.get_logger('lgd_filter_restraints')
def get_structures(ranking, base_path='.'):
structures = []
for rank in ranking:
swarm_id = rank.id_swarm
glowworm_id = rank.id_glowworm
score = rank.scoring
structures.append([
os.path.join(base_path, 'swarm_{}'.format(swarm_id),
'lightdock_{}.pdb'.format(glowworm_id)), score
])
return structures
#!/usr/bin/env python
"""Calculates the scoring function value for a pair of receptor and ligand PDB structures"""
import argparse
import importlib
from lightdock.pdbutil.PDBIO import parse_complex_from_file
from lightdock.structure.complex import Complex
from lightdock.util.logger import LoggingManager
log = LoggingManager.get_logger('calculate_scoring')
def parse_command_line():
parser = argparse.ArgumentParser(prog='calculate_scoring')
parser.add_argument("scoring_function", help="scoring function")
parser.add_argument("receptor", help="PDB receptor")
parser.add_argument("ligand", help="PDB ligand")
script_args = parser.parse_args()
return script_args
if __name__ == "__main__":
args = parse_command_line()
try:
scoring_function_module = "lightdock.scoring.%s.driver" % args.scoring_function
module = importlib.import_module(scoring_function_module)
except ImportError:
raise SystemExit("Scoring function not found or not available")