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)
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()
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 """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"""
"""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."""
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