def scoreBenchmark2():
dy.confProDy(verbosity='none')
resultsFile = open('mu-solv-scores.txt', 'w+')
csvWriter = csv.writer(resultsFile)
csvWriter.writerow(['name', 'mu', 'TYR', 'SER', 'CYS' ])
csvReader = csv.reader(open('train_dG_est.csv', 'rU'))
csvReader.next()
headers = csvReader.next()
for row in csvReader:
PDB_ID = row[0]
mu_pot_score = float(row[1])
dASA_tyr = float(row[2])
dASA_ser = float(row[3])
dASA_cys = float(row[4])
dG_est = float(row[5])
feature_vector = scoreOne(PDB_ID)
results = [PDB_ID]
map(results.append, feature_vector)
print results
csvWriter.writerow(results)
resultsFile.close()
def set_default_based_on_argparse(self, selection, vmd, compare, ref, debug, pdb):
'''
set arguments from command line based on argparser
'''
if selection in ["calpha", "backbone", "all"]:
self.selection=selection
else:
print("Invalid value for selection:", selection)
print("Possible Values for selection are: calpha, backbone, all")
exit()
self.vmd = vmd
self.compare=compare
self.ref=ref
self.debug=debug
self.pdbarg=pdb
#set prody level of output
if self.debug:
prody.confProDy(verbosity="debug")
else:
prody.confProDy(verbosity="info")
if self.debug:
print("***DEBUG***")
self.printSettings()
print("***DEBUG-END***")
def gen_normal_modes(self):
"""gen_normal_modes
"""
print('>>> Computing normal modes with ProDy')
from prody import ANM as prody_ANM
from prody import confProDy
confProDy(verbosity='critical')
anm = prody_ANM()
anm.buildHessian(self.atom_pos * 10**10, cutoff=self.elastic_network_cutoff)
anm.calcModes(n_modes=self.num_normal_modes)
self.normal_mode_vectors = anm.getEigvecs().reshape(self.atom_pos.shape[0],
self.atom_pos.shape[1],
self.num_normal_modes)
self.normal_mode_variances = 1./anm.getEigvals()
def main():
#no log messages:
confProDy(verbosity='none')
# parse command line arguments
parser = ArgumentParser(description='Calculate MDENM energies from a pdb \
will calculate energy using modes from pdb\
and then from reference--> crystal should\
be the reference')
parser.add_argument('--pdb', help='Molecule we want to examine. It will also be used as topology')
parser.add_argument('--reference',
help='Rerence pdb to which we will rmsd everything')
args = parser.parse_args()
flexy = FlexE(ref_pdb_file=args.reference)
results = flexy.compare_with_ref(pdb_file=args.pdb)
rmsd, energy_ref_to_pdb, energy_pdb_to_ref = results
print "%s %.2f %.2f %.2f " % (args.pdb, rmsd, energy_ref_to_pdb, energy_pdb_to_ref)
def setUpClass(cls):
# Generate and read the pdb
cls.pdb_path = "tmp_pdb.pdb"
open(cls.pdb_path,"w").write(amber_short_ca_contents);
try:
prody.confProDy(verbosity='none')#setVerbosity('none')
except Exception :
print "Impossible to silent prody"
cls.pdb = prody.parsePDB(cls.pdb_path, subset='calpha')
# Save coordsets before superposition
cls.not_iterposed_coordsets = numpy.array(cls.pdb.getCoordsets())
# Do Prody iterposition
cls.ensemble = prody.Ensemble('pca_test_ensemble')
cls.ensemble.setCoords( cls.pdb.getCoords())
cls.ensemble.addCoordset(cls.pdb.getCoordsets())
#prody.setVerbosity('info')
cls.ensemble.iterpose()
cls.coordsets = cls.ensemble.getCoordsets()
def setUpClass(cls):
# Generate and read the pdb
cls.pdb_path = "tmp_pdb.pdb"
open(cls.pdb_path, "w").write(amber_short_ca_contents)
try:
prody.confProDy(verbosity='none') #setVerbosity('none')
except Exception:
print "Impossible to silent prody"
cls.pdb = prody.parsePDB(cls.pdb_path, subset='calpha')
# Save coordsets before superposition
cls.not_iterposed_coordsets = numpy.array(cls.pdb.getCoordsets())
# Do Prody iterposition
cls.ensemble = prody.Ensemble('pca_test_ensemble')
cls.ensemble.setCoords(cls.pdb.getCoords())
cls.ensemble.addCoordset(cls.pdb.getCoordsets())
#prody.setVerbosity('info')
cls.ensemble.iterpose()
cls.coordsets = cls.ensemble.getCoordsets()
def read_pdb_dir(pdb_fs, pdb_dir):
'''
Only .ent files are read...
Returns AtomGroup object (prody)
'''
# import prody for pdb read/write
import prody
prody.confProDy(verbosity='none')
struct_data = []
for pdb_f in pdb_fs:
pdb_f = os.path.join(pdb_dir, pdb_f)
if (os.path.exists(pdb_f)):
struct = prody.parsePDB(pdb_f)
else:
struct = None
struct_data.append((pdb_f, struct))
return struct_data
def read_pdb_dir(pdb_fs, pdb_dir):
'''
Only .ent files are read...
Returns AtomGroup object (prody)
'''
# import prody for pdb read/write
import prody
prody.confProDy(verbosity='none')
struct_data = []
for pdb_f in pdb_fs:
pdb_f = os.path.join(pdb_dir, pdb_f)
if(os.path.exists(pdb_f)):
struct = prody.parsePDB(pdb_f)
else:
struct = None
struct_data.append((pdb_f, struct))
return struct_data
def __init__(self, parameters, observer):
"""
Class creator. It parses the needed files and extracts info and coordinates.
"""
super(TrajectoryHandler, self).__init__(observer)
print "Reading conformations..."
prody.confProDy(verbosity="none")
self.parameters = parameters
matrix_parameters = parameters.get_value(
"data.matrix.parameters", default_value=ProtocolParameters.empty())
parameters["data"]["files"] = self.expand_file_lists(
parameters["data"]["files"])
self.files = parameters["data"]["files"]
self.pdbs = []
if len(self.files) == 0:
common.print_and_flush("[ERROR] no pdbs. Exiting...\n")
self.notify("SHUTDOWN", "No pdbs defined in script.")
exit()
self.notify("Loading", "Loading Trajectories")
# Bookmarking structure
self.bookmarking = {"pdb": None, "selections": {}}
merged_structure = self.getMergedStructure()
self.coordsets = merged_structure.getCoordsets()
self.number_of_conformations = self.coordsets.shape[0]
self.number_of_atoms = self.coordsets.shape[1]
self.handle_selection_parameters(matrix_parameters)
print "%d conformations of %d atoms were read." % (
merged_structure.numCoordsets(), merged_structure.numAtoms())
#!/usr/bin/env python
# encoding: utf-8
import numpy
import numpy.matlib
import scipy.stats
import prody
import os
import itertools
import multiprocessing
prody.confProDy(verbosity='none')
n_process = 4
def compute_dist_matrix(points):
numPoints = len(points)
distMat = numpy.sqrt(numpy.sum((numpy.matlib.repmat(points, numPoints, 1) - numpy.matlib.repeat(points, numPoints, axis=0))**2, axis=1))
return distMat.reshape((numPoints,numPoints))
def extract_matrix(inputs):
pdb_file, secondary_file, ss_type, ss_length = inputs
path = os.path.join('PDB', pdb_file)
protein = prody.parsePDB(path, subset='CA')
coords = protein.getCoords()
n_residues = coords.shape[0]
import subprocess, os
import tempfile
import prody
import pandas as pd
prody.confProDy(verbosity='error')
NACCESS_BINARY = '/home/assaff/tools/naccess2.1.1/naccess'
rsa_colnames = [
'RES', 'Resname', 'Chain', 'Resnum',
'All-atoms-abs', 'All-atoms-rel',
'Total-Side-abs', 'Total-Side-rel',
'Main-Chain-abs', 'Main-Chain-rel',
'Non-polar-abs', 'Non-polar-rel',
'All-polar-abs', 'All-polar-rel',
]
rsa_colwidths = [
3,4,2,4,
9,6,
7,6,
7,6,
7,6,
7,6,
]
def read_naccess_rsa(rsa_filename):
rsa_table = pd.read_fwf(rsa_filename,
sep=None,
#!/usr/bin/env python
"""Calculates the new PDB structure of an input PDB structure using ANM"""
import sys
from prody import parsePDB, ANM, extendModel, confProDy
from lightdock.pdbutil.PDBIO import parse_complex_from_file, write_pdb_to_file
from lightdock.structure.complex import Complex
def usage():
print "Usage: %s PDB_file n_modes factor" % sys.argv[0]
if __name__ == "__main__":
confProDy(verbosity='info')
try:
pdb_structure = sys.argv[1]
n_modes = int(sys.argv[2])
factor = float(sys.argv[3])
except:
usage()
raise SystemExit("Wrong command line")
protein = parsePDB(pdb_structure)
ca_atoms = protein.select('name CA')
protein_anm = ANM('protein ca')
protein_anm.buildHessian(ca_atoms)
protein_anm.calcModes(n_modes=n_modes)
print 'Normal modes calculated'
import argparse
import logging
from pathlib import Path
def __append_error(path_txt, err_msg = None):
if err_msg is not None:
with open(path_txt, 'a') as f:
f.write('---\n\n')
f.write(str(err_msg))
f.write('\n')
if __name__ == '__main__':
logging.basicConfig(level=logging.INFO)
prody.confProDy(verbosity='none', typo_warnings=False, selection_warning=False)
prody.LOGGER._logger.setLevel(logging.ERROR)
parser = argparse.ArgumentParser()
parser.add_argument('--idx', type=str, required=True, default=None, help='path to proteins index file')
args = parser.parse_args()
logging.info(f'args = {args}')
num_log_iter = 10
path_csv = args.idx
path_csv_out = os.path.splitext(path_csv)[0] + '-chains.txt'
path_err_txt = os.path.splitext(path_csv)[0] + '-chains-errlog.txt'
Path(path_err_txt).touch()
wdir = os.path.dirname(path_csv)
data_csv = pd.read_csv(path_csv, converters={'uid': str})
paths_pdb = [os.path.join(wdir, x) for x in data_csv['path']]
#
data_csv_out = {x: [] for x in ['path2', 'chains_num', 'chains_legnth', 'chains_legnth_total']}
import prody
import itertools
import pandas as pd
from os import path
import numpy as np
prody.confProDy(verbosity="none")
def uep(pdb_path, uep_contact_matrix, group1, group2):
aa_code = {
'A': 'ALA',
'R': 'ARG',
'N': 'ASN',
'D': 'ASP',
'C': 'CYS',
'E': 'GLU',
'Q': 'GLN',
'G': 'GLY',
'H': 'HIS',
'I': 'ILE',
'L': 'LEU',
'K': 'LYS',
'M': 'MET',
'F': 'PHE',
'P': 'PRO',
'S': 'SER',
'T': 'THR',
'W': 'TRP',
'Y': 'TYR',
'V': 'VAL'
}
import time
import os
import prody
import numpy
import bz2
from pyRMSD.utils.proteinReading import flattenCoords
from pyproct.clustering.metrics.pcaMetrics import PCAMetric
if __name__ == '__main__':
"""
Compares Prody and pyProClust implementation.
"""
######################
# BENCHMARKING
######################
prody.confProDy(verbosity='none')#setVerbosity('none')
print "Loading file..."
t1 = time.time()
print "\tUncompressing..."
open("tmp_amber_long.pdb","w").write(bz2.BZ2File("data/amber_long.pdb.tar.bz2").read())
print "\tLoading..."
pdb = prody.parsePDB("tmp_amber_long.pdb", subset='calpha')
not_iterposed_coordsets = numpy.array(pdb.getCoordsets())
number_of_conformations = not_iterposed_coordsets.shape[0]
atoms_per_conformation = not_iterposed_coordsets.shape[1]
os.system("rm tmp_amber_long.pdb")
print "\tDeleting temporary file"
t2 = time.time()
print 'Loading took %0.3f s' % (t2-t1)
######################
import prody.sequence as sequence
import csv
import sys
import prody
from Bio.Seq import Seq
from Bio import SeqIO
from Bio.SeqRecord import SeqRecord
from Bio.Alphabet import generic_protein
#sys.path.insert(0, '/Users/peter/Work/3decision/3decision_python')
sys.path.insert(0, '/Users/peter/Documents/Work/3decision/3decision_python')
prody.confProDy(verbosity='none')
import db_interface as dbi3dec
input_file = csv.DictReader(open("kinome.csv"), delimiter=';')
#TODO : check why a few uniprot codes are missing here
domain_annotations = [
'Protein kinase domain (Domain)', 'Protein tyrosine kinase (Domain)'
]
expected_pfam_families = [
'PF07714'
] #PF00069']#,'PF07714'] #,'PF12330','PF00454','PF01163','PF03109']
o3i = dbi3dec.Oracle3decInterface()
o3i.connect()
final_sequences = [] #final list containing all kinase domain sequences
for line in input_file:
uniprot_code = (line['UNIPROT_CODE'])
if (len(uniprot_code)):
import MDAnalysis as md
import pandas as pd
from prody import confProDy, parsePDB, writePDB
silence_prody = confProDy(verbosity='none')
from plip.structure.preparation import PDBComplex
import progressbar
import os
import sys
import warnings
warnings.filterwarnings("ignore")
def plipmd(topol=None, traj=None):
traj = list(traj.strip('[]').split(','))
u = md.Universe(topol, traj)
print('\nINFO: your system contains {} segments with labels {} \n'.format(
len(u.segments), list(u.segments.segids)))
if len(u.segments.segids) == 1:
print('''
WARNING: Only one segment was identified. Proceeding to manual segment definition\n\n
You must define the peptide residues using MDAnalysis format.
from . import gmx
from . import mdp_defaults
import pxul
from pxul.logging import logger
import mdtraj
import prody
prody.confProDy(verbosity='critical')
import textwrap
import os
import shutil
import copy
def count_occurences(string, lines):
"""
Count the number of times 'string' occures in 'lines'
Where
string :: str
lines :: [str]
returns: int
"""
count = 0
for line in lines:
if string in line:
count += 1
return count
class suffix(object):
# H5PY for storage
import numpy as np
import numpy.ma as ma
import h5py
# from h5py import h5s
import oddt
import ConfigParser
# check if we have openbabel < 3.0.0
try:
from pybel import ob
except ImportError:
from openbabel import openbabel as ob
prody.confProDy(verbosity='error')
class Config(object):
fname = None
config = None
numposes = None
box = None
def __init__(self, fname=None):
if fname:
self.parse_config(fname)
self.is_valid()
self.fname = fname
else:
def prody_anm(self, variables, txtOutput):
'''
PRODY DRIVER is the function to read in variables from GUI input and
used to run a prody normal mode calculation using the anisotropic network model
(ANM) on a structure provide in a pdb file.
INPUT: variable descriptions:
pdbfile: input pdb file (reference)
OUTPUT:
model_anm_extended_bb.nmd
model_traverse.dcd
model_samp.dcd
model_samp.pdb
model_anm_sqflucts.txt
model_anm_kirchhoff.txt
model_anm_hessian.txt
model_anm_cross-correlations.hm
model_anm_cross-correlations.txt
model_anm_covariance.txt
model_anm_beta.txt
model_anm_evalues.txt
model_anm_evectors.txt
model_anm_extended_all.nmd
model_anm.nmd
txtOutput: TK handler for output to GUI textbox
files stored in ~/runname/prody directory:
outfile: output filename
'''
log = self.log
pgui = self.run_utils.print_gui
# start gui output
pgui("\n%s \n" % ('=' * 60))
pgui("DATA FROM RUN: %s \n\n" % time.asctime( time.gmtime( time.time() ) ))
mvars = self.mvars
#path = os.path.join(os.getcwd(),mvars.runname, 'prody')
path = os.path.join(mvars.runname, 'prody')
direxist = os.path.exists(path)
if(direxist == 0):
try:
result = os.system('mkdir -p ' + path)
except:
message = 'can not create project directory: ' + path
message += '\nstopping here\n'
print_failure(message, txtOutput)
if(result != 0):
message = 'can not create project directory: ' + path
message += '\nstopping here\n'
print_failure(message, txtOutput)
if mvars.advanced_usage == 1:
run_cmd = prody_exe + mvars.advanced_usage_cmd
os.system(run_cmd)
run_cmd = 'mv *.nmd *.txt *.hm prody'
os.system(run_cmd)
exit()
# display progress
fraction_done = (0 + 1) * 1.0 / 10.0
report_string = 'STATUS\t%f' % fraction_done
pgui(report_string)
prody.confProDy(verbosity='none') #option to set silent verbosity
model = mvars.pdbfile[0:len(mvars.pdbfile) - 4]
run_cmd = prody_exe + ' anm ' + \
mvars.pdbfile + ' -t all -n ' + str(mvars.number_modes) + ' -a'
log.info('staring prody_exe %s' % run_cmd)
prody_run = subprocess.Popen(run_cmd,shell=True,executable='/bin/bash')
prody_run.wait()
#prody.confProDy(verbosity='none') #option to set silent verbosity
file_anm = model + '_anm_extended_all.nmd'
# display progress
fraction_done = (1 + 1) * 1.0 / 10.0
report_string = 'STATUS\t%f' % fraction_done
pgui(report_string)
# parse nmd file with resuts extended to all atoms
log.info('staring prody.parseNMD %s' % file_anm)
mod, ag = prody.parseNMD(file_anm, type=None)
allatoms = ag.copy()
# set up to randomly sample number_conformations_samp modes
log.info('staring prody.sampleModes')
ensemble = prody.sampleModes(mod[:mvars.number_modes],
ag,
n_confs=mvars.number_conformations_samp,
rmsd=mvars.rmsd_conformations_samp)
ensemble
log.info('staring prody ensemble and writing pdb/dcd files')
allatoms.addCoordset(ensemble)
prody.writePDB('model_samp.pdb', allatoms)
prody.writeDCD('model_samp.dcd', allatoms)
trajectory_names = []
# display progress
fraction_done = (1 + 2) * 1.0 / 10.0
report_string = 'STATUS\t%f' % fraction_done
pgui(report_string)
log.info('starting prody traverse')
for i in xrange(0, mvars.number_modes):
#print i
# setup to tranverse slowest mode
traverse = prody.traverseMode(
mod[i],
allatoms,
n_steps=mvars.number_steps_traverse,
rmsd=mvars.rmsd_traverse)
traverse
prody.writeDCD('traverse.dcd', traverse)
this_dcd = str(os.path.join(path, 'traverse_' + str(i) + '.dcd'))
cmd = 'mv traverse.dcd ' + this_dcd
os.system(cmd)
trajectory_names.append(this_dcd)
# display progress
fraction_done = (1 + 7) * 1.0 / 10.0
report_string = 'STATUS\t%f' % fraction_done
pgui(report_string)
m1 = sasmol.SasMol(0)
m2 = sasmol.SasMol(0)
m1.read_pdb(mvars.pdbfile)
m2.read_pdb(mvars.pdbfile,fastread=True)
mvars.dcdfile = mvars.runname + '.dcd'
log.info('opening new dcd file to store trajectory: %s' %
os.path.join(self.runpath, mvars.dcdfile))
outfile_name = str(os.path.join(path, mvars.dcdfile))
dcdoutfile = m2.open_dcd_write(outfile_name)
count = 0
coor = numpy.zeros((1,m2.natoms(),3),numpy.float32)
for this_trajectory_name in trajectory_names:
dcdfile = m1.open_dcd_read(this_trajectory_name)
number_of_frames = dcdfile[2]
for j in xrange(number_of_frames):
m1.read_dcd_step(dcdfile,j)
coor[0,:,:] = m1.coor()[0]
m2.setCoor(coor)
m2.write_dcd_step(dcdoutfile,0, count + 1)
count += 1
m2.close_dcd_write(dcdoutfile)
log.info('moving files to runname / prody')
file_anm = model + '_anm.nmd'
mod, ag = prody.parseNMD(file_anm, type=None)
mod1 = prody.parsePDB(mvars.pdbfile)
calphas = mod1.select('calpha')
bb_anm, bb_atoms = prody.extendModel(mod, calphas, mod1.select(
'backbone')) # extend model to backbone atoms
prody.writeNMD('model_anm_extended_bb.nmd', bb_anm, bb_atoms)
cmd = 'mv model_samp.pdb ' + path + os.sep + os.path.basename(model) + '_samp.pdb'
os.system(cmd)
cmd = 'mv model_samp.dcd ' + path + os.sep + os.path.basename(model) + '_samp.dcd'
os.system(cmd)
cmd = 'mv model_anm_extended_bb.nmd ' + \
model + '_anm_extended_bb.nmd'
os.system(cmd)
cmd = 'mv *.hm *.nmd *.txt ' + path + os.sep
os.system(cmd)
# display progress
fraction_done = (1 + 9) * 1.0 / 10.0
report_string = 'STATUS\t%f' % fraction_done
pgui(report_string)
return
R[2, 1] = sy * cz
R[2, 2] = cy
return R
if __name__ == "__main__":
usage = "usage: %prog [options] docking_out_file"
p = OptionParser(usage=usage)
(options, args) = p.parse_args()
if len(args) != 2:
p.error("incorrect number of arguments")
prody.confProDy(auto_show=False)
outFileLines = open(args[0], "r").read().splitlines()
grid_num = int(outFileLines[0].split("\t")[0])
grid_size = float(outFileLines[0].split("\t")[1])
recFile = outFileLines[2].split("\t")[0]
rec_pdbid = recFile[0:4]
ligFile = outFileLines[3].split("\t")[0]
lig_pdbid = ligFile[0:4]
rec_init_cent = np.array([float(x) for x in outFileLines[2].strip().split("\t")[1:] if not len(x) == 0])
lig_init_cent = np.array([float(x) for x in outFileLines[3].strip().split("\t")[1:] if not len(x) == 0])
partnerPdbFile = args[1]
partner = prody.parsePDB(partnerPdbFile)
partner = partner.select("protein")
partner = preprocess_single(partner, "C")
from prody import parsePDB, fetchPDB, confProDy
from collections import OrderedDict
from difflib import SequenceMatcher
from src.utils import PAD_SS, to_one_letter, BACKBONE
from src.utils.profile import *
from src.utils.data import *
from src.utils.stride import *
LOAD_CCM = False
if LOAD_CCM: from src.utils.ccmpred import *
warnings.simplefilter(action='ignore', category=FutureWarning)
np.seterr('raise')
confProDy(verbosity='none')
random.seed(101)
PERM = 'r'
IDX = h5py.File(osp.join(DATA_HOME, 'h5', 'idx.h5'), PERM)
BETAS = h5py.File(osp.join(DATA_HOME, 'h5', 'betas.h5'), PERM)
COORDS = h5py.File(osp.join(DATA_HOME, 'h5', 'coords.h5'), PERM)
RESNAMES = h5py.File(osp.join(DATA_HOME, 'h5', 'resnames.h5'), PERM)
ATOMNAMES = h5py.File(osp.join(DATA_HOME, 'h5', 'atomnames.h5'), PERM)
_, SEQs = FASTA(osp.join(DATA_HOME, 'etc', 'pdb_seqres.txt'))
MAX_ALLOWED_SHIFT = 10
MAX_BATCH_SIZE = 1
MAX_LENGTH = 512
MIN_LENGTH = 32
R[2, 1] = sy * cz
R[2, 2] = cy
return R
if __name__ == '__main__':
usage = "usage: %prog [options] docking_out_file"
p = OptionParser(usage=usage)
(options, args) = p.parse_args()
if len(args) != 2:
p.error("incorrect number of arguments")
prody.confProDy(auto_show=False)
outFileLines = open(args[0], 'r').read().splitlines()
grid_num = int(outFileLines[0].split('\t')[0])
grid_size = float(outFileLines[0].split('\t')[1])
recFile = outFileLines[2].split('\t')[0]
rec_pdbid = recFile[0:4]
ligFile = outFileLines[3].split('\t')[0]
lig_pdbid = ligFile[0:4]
rec_init_cent = np.array([
float(x) for x in outFileLines[2].strip().split('\t')[1:]
if not len(x) == 0
])
lig_init_cent = np.array([
float(x) for x in outFileLines[3].strip().split('\t')[1:]
if not len(x) == 0
from HPC_Drug import important_lists
from HPC_Drug import pipeline_functions
from HPC_Drug import file_manipulation
from HPC_Drug.structures import ligand
from HPC_Drug.structures import protein
from HPC_Drug.auxiliary_functions import get_iterable
from HPC_Drug.PDB import prody
#deactivating all
#BiopythonWarning
import warnings
import Bio
warnings.simplefilter('ignore', Bio.BiopythonWarning)
#deactivating all prody warnings
true_prody_module.confProDy(verbosity='none')
class Orient(object):
"""This class contains the methods needed to
put the given stucture in a box with solvent
and do many other calculations needed to create
the input for the orac optimization with solvent"""
def __init__(self, Protein = None, Ligand = None):
self.Protein = Protein
self.Ligand = Ligand
self.atom_weights = important_lists.atom_weights
def center_of_mass(self, entity = None, geometric=False):
"""
import prody as pr
from tqdm import tqdm
from sidechainnet.utils.align import (assert_mask_gaps_are_correct,
expand_data_with_mask, init_aligner,
merge)
from sidechainnet.utils.download import download_sidechain_data
from sidechainnet.utils.errors import write_errors_to_files
from sidechainnet.utils.manual_adjustment import (manually_adjust_data,
manually_correct_mask,
needs_manual_adjustment)
from sidechainnet.utils.measure import NUM_COORDS_PER_RES
from sidechainnet.utils.organize import load_data, organize_data, save_data
from sidechainnet.utils.parse import parse_raw_proteinnet
pr.confProDy(verbosity="none")
pr.confProDy(auto_secondary=False)
def combine(pn_entry, sc_entry, aligner, pnid):
"""Supplements one entry in ProteinNet with sidechain information.
Args:
aligner: A sequence aligner with desired settings. See
utils.alignment.init_aligner().
pn_entry: A dictionary describing a single ProteinNet protein. Contains
sequence, coordinates, PSSMs, secondary structure.
sc_entry: A dictionary describing the sidechain information for the same
protein. Contains sequence, coordinates, and angles.
Returns:
from . import gmx
from . import mdp_defaults
import pxul
from pxul.logging import logger
import mdtraj
import prody
prody.confProDy(verbosity='critical')
import textwrap
import os
import shutil
import copy
def count_occurences(string, lines):
"""
Count the number of times 'string' occures in 'lines'
Where
string :: str
lines :: [str]
returns: int
"""
count = 0
for line in lines:
if string in line:
count += 1
return count
class suffix(object):
@classmethod
import prody from pyproct.driver.time.timerHandler import TimerHandler # Set current version __version__ = "1.7.2" # Set prody verbosity to avoid excess of cmd line messages prody.confProDy(verbosity="none")
#!/usr/bin/env python3
"""Filter LightDock final swarm results depending on the percentage of restraints satisfied"""
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
import collections
import pandas as pds
import prody as pd
import time
import glob
import argparse
import numpy as np
import growai.model.docking.glide as gl
import growai.model.helpers.helpers as hp
import growai.analysis as an
# Deactive tnesorflow warnings
os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
# Deactivate prody warnings
pd.confProDy(verbosity="none")
# Disable Rdkit stdout
rdBase.DisableLog('rdApp.error')
#Harcode RDKIT Data
#RDKIT=os.path.join(cs.SCHRODINGER, "mmshare-v*/data/RDKit/Data/")
RDKIT=""
#Print out Error if RDKIT not recognize
try:
fdefName = os.path.join(RDConfig.RDDataDir,'BaseFeatures.fdef')
factory = ChemicalFeatures.BuildFeatureFactory(fdefName)
except IOError:
print("If error: not RDDataDir specified on installation. Manually change the RDKIT variable on this file {}".format(os.__file__))
fdefName = os.path.join(RDKIT,'BaseFeatures.fdef')
