def submain(args_phi_psi=False, args_seq=False, args_name='render'):
with open(args_phi_psi, 'r') as phi_psi:
args_phi_psi = phi_psi.readlines()
torsion_space_iterable = args_phi_psi
PhiPsi = []
if args_seq:
if os.path.isfile(args_seq):
with open(args_seq, 'r') as seq:
args_seq = seq.readlines()
args_seq = [line for line in args_seq if len(line)]
if len(args_seq) == 1: args_seq = args_seq[0].strip()
Seq = list(args_seq)
else:
Seq = []
try:
assert len(torsion_space_iterable) == len(Seq)
except:
print('Sequence and torison iteratable must be same length\n', Seq,
len(Seq), torsion_space_iterable, len(torsion_space_iterable))
sys.exit()
# 1st loop through backbone
for i, element in enumerate(torsion_space_iterable):
element = element.strip()
angles = tuple(float(a) for a in element.split())
if len(angles) == 2:
phi, psi = angles
omega = 180
else:
assert len(angles) == 3
phi, psi, omega = angles
PhiPsi.append((phi, psi, omega))
if not args_seq:
Seq.append(AminoAcid)
assert len(PhiPsi) == len(Seq)
try:
pyrosetta
except NameError:
import pyrosetta
pyrosetta.init()
render_pose = pyrosetta.pose_from_sequence(''.join(Seq))
for i, torsion_angles in enumerate(PhiPsi):
phi, psi, omega = torsion_angles
p = i + 1
render_pose.set_phi(p, phi)
render_pose.set_psi(p, psi)
render_pose.set_omega(p, omega)
render_pose.dump_pdb('%s.pdb' % args_name)
def run_pyrosetta_with_flags(flags_file_path, mute=False):
if not flags_file_path:
pyrosetta.init("-mute all " if mute else "", silent=mute)
return
flags = read_flag_file(flags_file_path)
flags_str = " ".join(flags.replace("\n", " ").split())
pyrosetta.init(f"-mute all {flags_str}" if mute else flags_str,
silent=mute)
def preprocess(path):
import pyrosetta, logging
pyrosetta.init(
extra_options=
'-no_optH false -mute all -ignore_unrecognized_res true -load_PDB_components false'
)
from fragmenstein.mpro import MProVictor
MProVictor.enable_stdout(logging.INFO)
MProVictor.work_path = path
def update_mover(self):
self.mover = rFastDesign(self.sfxn, self.rounds)
self.mover.set_up_default_task_factory()
init(' '.join(self.init_args))
if self.edited_movemap:
self.mover.set_movemap(self.movemap)
if hasattr(self, '_task_factory'):
self.mover.set_task_factory(self.task_factory)
def main():
print(len(sys.argv))
pyrosetta.init()
report_memuse("init")
keep = list()
for posefile in sys.argv[1:]:
with open(posefile, "rb") as f:
pose = pickle.load(f)
# keep.append(pose)
report_memuse("loaded pose")
def mpi_init(*args, **kargs):
comm = MPI.COMM_WORLD
rank = comm.Get_rank()
size = comm.Get_size()
kargs['extra_options'] = kargs.get('extra_options', '') + ' -seed_offset {}'.format(rank*10000)
pyrosetta.init(*args, **kargs)
def init_check(options='-beta_nov15', fail_if_options_dont_match=True):
global pyrosetta_init_options
if pyrosetta_init_options is None:
pyrosetta.init(options=options)
pyrosetta_init_options = options
elif options != pyrosetta_init_options:
if fail_if_options_dont_match:
raise ReInitError(
'attempt to init rosetta with different options: previous: {}, thiscall: {}'
.format(pyrosetta_init_options, options))
def main():
pyrosetta.init('-beta -include_patches patches/VirtualBB.txt')
chem_manager = rosetta.core.chemical.ChemicalManager
rts = chem_manager.get_instance().residue_type_set("fa_standard")
ggg = rosetta.core.pose.Pose()
core.pose.make_pose_from_sequence(ggg, 'AAA', rts)
virt_bb = rosetta.core.chemical.VIRTUAL_BB
core.pose.remove_lower_terminus_type_from_pose_residue(ggg, 1)
core.pose.remove_upper_terminus_type_from_pose_residue(ggg, 3)
core.pose.add_variant_type_to_pose_residue(ggg, virt_bb, 1)
def boot_pyrosetta(param_string=None):
"""Boot PyRosetta"""
if param_string is None:
param_string = ""
booted = os.environ.get(PYROSETTA_BOOTED, "no") == "yes"
if not booted:
pyrosetta.init(param_string)
os.environ['PYROSETTA_BOOTED'] = "yes"
return True
def init_check(options=None, strict=True):
if options is None:
strict = False
options = '-corrections:beta_nov16 -mute all'
global pyrosetta_init_options
if pyrosetta_init_options is None:
pyrosetta.init(options=options)
pyrosetta_init_options = options
elif options != pyrosetta_init_options:
if strict:
raise ReInitError(
'attempt to init rosetta with different options: previous: {}, thiscall: {}'
.format(pyrosetta_init_options, options))
def __init__(self, pdb_file, rf, tw):
import pyrosetta
from pyrosetta import teaching
import pyrosetta.rosetta.numeric
self.rose = pyrosetta.rosetta.numeric
self.rf = rf
pyrosetta.init()
with open(pdb_file, 'r') as f:
self.prior_detail = "".join(f.readlines()[:-1]) # strip off end.
self.ligand_maker = pyrosetta.pose_from_pdb
self.score = teaching.get_fa_scorefxn()
self.reset(tw)
def worms_main(argv):
pyrosetta.init("-mute all -beta -preserve_crystinfo --prevent_repacking")
blosc.set_releasegil(True)
criteria_list, kw = build_worms_setup_from_cli_args(argv)
try:
worms_main2(criteria_list, kw)
except Exception as e:
bbdb = kw["db"][0]
bbdb.clear()
raise e
def main():
args = docopt.docopt(__doc__)
folder = args['<folder>']
init()
target = pose_from_file(args['<input>'])
workspace = pipeline.workspace_from_dir(folder)
loop = workspace.largest_loop
#mobile = pose_from_file('/Users/benjaminrjagger/UCSF/cas_des/CPP_sims/4un3_1051_penetratin/input.pdb.gz')
# ins_len = chain_end_res(mobile, 1) - chain_end_res(target, 1)
# des_res = list(range(1, int(loop.start)-1)) + list(range(int(loop.end)+1, chain_end_res(mobile, 1)))
# wt_res = list(range(1,int(loop.start) -1)) + list(range(int(loop.end)+1 - ins_len, chain_end_res(target, 1)))
# res_map = map_unsigned_long_unsigned_long()
# for i in range(len(des_res)):
# res_map[des_res[i]] = wt_res[i]
# rmsd = CA_rmsd(mobile, target, res_map)
for root, dirs, files in os.walk(workspace.output_dir):
for name in files:
if name.endswith('.pdb.gz') or name.endswith('.pdb'):
pdbpath = os.path.join(root, name)
mobile = pose_from_file(pdbpath)
ins_len = chain_end_res(mobile, 1) - chain_end_res(target, 1)
des_res = list(range(
1,
int(loop.start) - 1)) + list(
range(int(loop.end) + 1, chain_end_res(mobile, 1)))
wt_res = list(range(1,
int(loop.start) - 1)) + list(
range(
int(loop.end) + 1 - ins_len,
chain_end_res(target, 1)))
res_map = map_unsigned_long_unsigned_long()
for i in range(len(des_res)):
res_map[des_res[i]] = wt_res[i]
rmsd = CA_rmsd(mobile, target, res_map)
metric_name = 'EXTRA_METRIC_CA_RMSD_NO_LOOP [[-]]'
if name.endswith('.pdb.gz'):
add_lines_to_gzip(pdbpath, [metric_name + ' ' + str(rmsd)])
if name.endswith('.pdb'):
add_lines_reg(pdbpath, [metric_name + ' ' + str(rmsd)])
#rmsd = all_atom_rmsd(mobile, target)
print(rmsd)
def main(nseg, workers=0):
pyrosetta.init("-corrections:beta_nov16 -mute all")
helix = Spliceable(poselib.curved_helix, sites=[(1, "N"), ("-4:", "C")])
dimer = Spliceable(poselib.c2, sites=[("1,:1", "N"), ("2,-1:", "C")])
segments = ([Segment([helix], exit="C")] +
[Segment([dimer], entry="N", exit="C")] +
[Segment([helix], entry="N", exit="C")] * (nseg - 2) +
[Segment([helix], entry="N")])
t = perf_counter()
worms = grow(
segments,
Cyclic("C13", lever=40),
thresh=1.0,
max_workers=workers,
executor=ProcessPoolExecutor,
# executor=dask.distributed.Client,
max_results=10000,
max_samples=10000000,
)
print("number of results:", len(worms))
t = perf_counter() - t
count = np.prod([len(s) for s in segments])
s = worms.scores
try:
ptile = np.percentile(s, range(0, 100, 20))
except:
ptile = []
print("quantile", ptile)
print("best10 ", s[:10])
print(
"nseg %2i" % nseg,
"best %7.3f" % (s[0] if len(s) else 999),
"tgrow %7.2f" % t,
"rate %7.3fM/s" % (count / t / 1000000),
"npass %8i" % len(s),
)
print("going through poses:")
sys.stdout.flush()
for i in range(min(10, len(worms))):
fname = "worm_nseg%i_%i.pdb" % (nseg, i)
pose, score0 = worms.sympose(i, fullatom=True, score=True)
print("worm", i, worms.scores[i], score0, worms.indices[i])
sys.stdout.flush()
if score0 < 250:
print(" dumping to", fname)
pose.dump_pdb(fname)
def design(input_dir,
data_path,
selected_designs_file,
num_jobs,
job_id,
num_seq_per_model=1,
do_ex_rot_run=True):
pyrosetta.init(options='-mute all')
# Get all the tasks
df_selected = pd.read_csv(selected_designs_file, sep='\t')
tasks = []
for i, row in df_selected.iterrows():
for j in range(num_seq_per_model):
tasks.append(row['design_id'])
# Make designs
for i, t in enumerate(tasks):
if i % num_jobs == job_id:
output_path = os.path.join(data_path, str(i))
os.makedirs(output_path, exist_ok=True)
input_pdb = os.path.join(input_dir, str(t), 'design.pdb.gz')
with open(os.path.join(input_dir, str(t), 'design_info.json'),
'r') as f:
input_design_info = json.load(f)
if 'sequence_symmetry_map' in input_design_info.keys():
ssm_serial = input_design_info['sequence_symmetry_map']
sequence_symmetry_map = {}
for x in ssm_serial:
sequence_symmetry_map[(x[0], x[1])] = (x[2], x[3])
else:
sequence_symmetry_map = None
LPSD.sequence_design.make_one_design(
output_path,
input_pdb,
input_design_info['bb_remodeled_residues'],
designable_residues=input_design_info['designable_residues'],
repackable_residues=input_design_info['repackable_residues'],
do_ex_rot_run=do_ex_rot_run,
sequence_symmetry_map=sequence_symmetry_map)
def main():
args = docopt.docopt(__doc__)
print(args)
df = pd.DataFrame()
init('-ignore_unrecognized_res')
if 'SGE_TASK_ID' in os.environ:
idx = int(os.environ['SGE_TASK_ID']) - 1
else:
idx = int(args['--task']) - 1
ntasks = int(args['--ntasks'])
start = idx * ntasks
stop = idx * ntasks + ntasks - 1
print('START: {}'.format(start))
print('STOP: {}'.format(stop))
folder = args['<pdbfolder>']
workspace = ws.workspace_from_dir(args['<workspace>'])
exts = ('.pdb', '.pdb.gz')
if args['--recursive']:
files = [
str(p) for p in Path(folder).rglob('*') if p.name.endswith(exts)
]
else:
files = [
str(p) for p in Path(folder).iterdir() if p.name.endswith(exts)
]
print(files)
for f in files:
pose = pose_from_file(f)
scanner = PoseScanner(pose)
posename = os.path.basename(f).split('.')[0]
helices = pd.DataFrame(
scanner.scan_pose_helices(name=posename,
split_chains=args['--split-chains']))
df = pd.concat([df, helices], ignore_index=True)
today = date.today()
outdir = os.path.join(workspace.project_params_dir, 'database')
os.makedirs(outdir, exist_ok=True)
out = os.path.join(
outdir, 'helixdf_custom_{0}.'.format(today.strftime("%m-%d-%Y")))
df.to_pickle(out + 'pkl')
# Comment this out later - no need for csv in final
df.to_csv(out + 'csv')
def main(fasta_path, feature_path, input_dir, output_dir, n_workers):
pyrosetta.init(
"-hb_cen_soft -relax:default_repeats 5 -default_max_cycles 200 -out:level 100"
)
os.makedirs(output_dir, exist_ok=True)
seq = open(fasta_path).readlines()[1].strip()
with Pool(n_workers) as p:
args = []
for path in os.listdir(input_dir):
args.append((
seq,
feature_path,
os.path.join(input_dir, path),
os.path.join(output_dir, path),
))
p.starmap(relex_from_pdb, args)
def main():
init()
pose = pose_from_file('test_files/6r9d.cif')
# pose = pose_from_file('test_cas9.pdb.gz')
import time
start = time.time()
scanner = PoseScanner(pose)
helices = scanner.scan_pose_helices(test=False)
print('CALC TIME = {}'.format(
time.time() - start
))
helices = pd.DataFrame(helices)
print(helices)
print(helices['name'])
helices.to_pickle('out.pkl')
helices.to_csv('out.csv')
def runAnnealingProcess(rep, kts, sigma, epsilon):
import cg_pyrosetta
import pyrosetta
pyrosetta.init()
folding_object = cg_pyrosetta.CG_folding.CGFoldingAlgorithm('X[CG11]X[CG11]X[CG11]X[CG11]X[CG11]X[CG11]X[CG11]X[CG11]X[CG11]X[CG11]X[CG11]X[CG11]X[CG11]X[CG11]X[CG11]')
# folding_object.scorefxn.set_weight(pyrosetta.rosetta.core.scoring.mm_twist, 1)
# folding_object.scorefxn.set_weight(pyrosetta.rosetta.core.scoring.mm_bend, 1)
folding_object.add_folding_move('default', folding_object.pymol)
assert(folding_object.pose.residue(2).atom_type(2).lj_radius() == sigma) # Throws error if SC isn't actually scanning
assert(folding_object.pose.residue(2).atom_type(2).lj_wdepth() == epsilon) # Should include more of these in scripts to make sure parameter scans are actually happening
folding_object.run_anneal_fold('default', 1, kts)
folding_object.mc.lowest_score_pose().dump_pdb(os.path.join('outputs', 'sigma_'+str(round(sigma, 3)), 'epsilon_'+str(round(epsilon,3)), 'CG11_rep_'+str(rep)+'.pdb'))
def init_rosetta(test_cycles=False, constant_seed=False):
flags = [
'-relax:dna_move on',
'-relax:coord_cst_stdev 0.5', # default: 0.5
'-relax:constrain_relax_to_start_coords on',
'-relax:ramp_constraints off',
'-run:test_cycles', 'on' if test_cycles else 'off',
'-dna:specificity:exclude_dna_dna off',
'-out:levels core.pack.rotamer_set.RotamerSet_.extra_rotamers:500',
]
if constant_seed:
flags += [
'-constant_seed',
]
pyrosetta.init(' '.join(flags), set_logging_handler='logging')
def main():
pyrosetta.init()
print "foo"
dirname = os.path.dirname(__file__)
testfile = dirname + '/1pgx.pdb'
pose = rosetta.core.import_pose.pose_from_file(testfile)
print pose
x = Xform(Mat(), Vec(10, 0, 0))
for ir in range(1, pose.size() + 1):
for ia in range(1, pose.residue(ir).natoms() + 1):
aid = rosetta.core.id.AtomID(ia, ir)
oldxyz = Vec(pose.xyz(aid))
# manipulate the atom position here!!!!
newxyz = x * oldxyz
pose.set_xyz(aid, newxyz.to_rosetta())
print 'dumping' + dirname + '/test_out.pdb'
pose.dump_pdb(dirname + '/test_out.pdb')
def main(nseg, workers=0):
pyrosetta.init('-corrections:beta_nov16 -mute all')
helix = Spliceable(poselib.curved_helix, sites=[(1, 'N'), ('-4:', 'C')])
dimer = Spliceable(poselib.c2, sites=[('1,:1', 'N'), ('2,-1:', 'C')])
segments = ([
Segment([helix], exit='C'),
] + [Segment([dimer], entry='N', exit='C')] +
[Segment([helix], entry='N', exit='C')] *
(nseg - 2) + [Segment([helix], entry='N')])
t = perf_counter()
worms = grow(
segments,
Cyclic('C13', lever=40),
thresh=1.0,
max_workers=workers,
executor=ProcessPoolExecutor,
# executor=dask.distributed.Client,
max_results=10000,
max_samples=10000000)
print('number of results:', len(worms))
t = perf_counter() - t
count = np.prod([len(s) for s in segments])
s = worms.scores
try:
ptile = np.percentile(s, range(0, 100, 20))
except:
ptile = []
print('quantile', ptile)
print('best10 ', s[:10])
print('nseg %2i' % nseg, 'best %7.3f' % (s[0] if len(s) else 999),
'tgrow %7.2f' % t, 'rate %7.3fM/s' % (count / t / 1000000),
'npass %8i' % len(s))
print('going through poses:')
sys.stdout.flush()
for i in range(min(10, len(worms))):
fname = 'worm_nseg%i_%i.pdb' % (nseg, i)
pose, score0 = worms.sympose(i, fullatom=True, score=True)
print('worm', i, worms.scores[i], score0, worms.indices[i])
sys.stdout.flush()
if score0 < 250:
print(' dumping to', fname)
pose.dump_pdb(fname)
def main():
# Needed for PyRosetta to work
pyrosetta.init()
pdb_files = list(filter(lambda f: '.pdb' in f, os.listdir(PDB_DIR)))
total = len(pdb_files)
batch = math.ceil(total / NUM_THREADS)
thread_list = []
for i in range(NUM_THREADS):
pdb_file_batch = pdb_files[i * batch:(i + 1) * batch]
thread_list.append(PDB2DataThread(pdb_file_batch))
for t in thread_list:
t.start()
for t in thread_list:
t.join()
def get_metrics(data_path, input_path, num_jobs, job_id):
'''Get rosetta metrics for all structures in the
input path.
'''
pyrosetta.init('-ignore_unrecognized_res true')
for i, f in enumerate(os.listdir(input_path)):
if i % num_jobs != job_id:
continue
if f.endswith('.pdb') or f.endswith('.pdb.gz'):
pose = rosetta.core.pose.Pose()
rosetta.core.import_pose.pose_from_file(pose, os.path.join(input_path, f))
print("Here")
d_of_data = get_metrics_for_one_pose(pose, f.split('.')[0])
for key in d_of_data.keys():
append_to_csv(d_of_data[key], os.path.join(data_path, '{0}.csv'.format(key)))
def main():
pyrosetta.init()
for id, c in enumerate(RESIDUE_LETTERS):
atom_count = None
chi_count = None
try:
pose = pyrosetta.pose_from_sequence(c, 'fa_standard')
residue = pose.residue(1)
atom_count = pose.residue(1).natoms()
chi_count = len(residue.chi())
except Exception as e:
print('Error processing {}: {}'.format(c, e))
ATOM_COUNT[id] = atom_count
CHI_COUNT[id] = chi_count
print('Max atom count: {}'.format(max(ATOM_COUNT)))
print('Max chi angles count: {}'.format(max(CHI_COUNT)))
def buildProtein(sequence, outdir, start_idx=1):
from htmd.builder.preparation import proteinPrepare
from htmd.ui import Molecule, amber
import sys
sys.path.append(
"/home/pablo/PyRosetta4.Release.python36.linux.release-197")
import pyrosetta
pyrosetta.init()
pose = pyrosetta.pose_from_sequence(sequence, 'fa_standard')
pose.dump_pdb('/tmp/test.pdb')
mol = Molecule('/tmp/test.pdb')
mol = proteinPrepare(mol)
mol.resid = mol.resid + start_idx
mol.set('segid', 'P1')
mol.filter('backbone')
_ = amber.build(mol, outdir=outdir, ionize=False
# , caps=None
)
return outdir + '/structure.prmtop'
def select_linkers(data_path,
input_pdb,
input_insertion_points_file,
insertion_ids_for_selection=None):
pyrosetta.init()
# Load insertion points
with open(input_insertion_points_file, 'r') as f:
insertion_points = json.load(f)
if insertion_ids_for_selection is None:
insertion_ids_for_selection = range(len(insertion_points))
for insertion_id in insertion_ids_for_selection:
start_ss = insertion_points[insertion_id]['start_ss']
stop_ss = insertion_points[insertion_id]['stop_ss']
for linker_length in [2, 3, 4, 5]:
# Select front linkers
input_database = 'database/linker_database/linker_{0}_helix_{1}_non_redundant.json'.format(
start_ss, linker_length)
output_database = os.path.join(
data_path, 'selected_linkers_{0}_{1}_front.json'.format(
insertion_id, linker_length))
select_and_dump_linkers(input_pdb, input_database, output_database,
linker_length,
copy.deepcopy(insertion_points),
insertion_id, True)
# Select back linkers
input_database = 'database/linker_database/linker_helix_{0}_{1}_non_redundant.json'.format(
stop_ss, linker_length)
output_database = os.path.join(
data_path, 'selected_linkers_{0}_{1}_back.json'.format(
insertion_id, linker_length))
select_and_dump_linkers(input_pdb, input_database, output_database,
linker_length,
copy.deepcopy(insertion_points),
insertion_id, False)
def test():
args = docopt.docopt(__doc__)
results = pd.read_pickle(args['<results>'])
df = pd.read_pickle(args['--dataframe'])
# Re-build query dataframe
init()
helixpath = os.path.expanduser('~/intelligent_design/helix_matcher')
helices = pd.read_pickle(
os.path.join(
helixpath,
'test_files/boundary/cluster_representatives/query_helices.pkl'))
results = results.sort_values(by='matches', ascending=False)
alphapath = helices.iloc[0]['path']
alpha = clash.get_alphashape(alphapath, chain='B')
for i in range(0, 100): # Review top 100 matches for now.
testrow = results.iloc[i]
# testgraph = testrow['graph']
session_from_graph(testrow, helices, df, alpha)
def compare_openmm_energy_pyrosetta_score(cgmodel):
"""
Given a cgmodel class object, this function determines if PyRosetta and OpenMM give the same score/energy with identical model settings.
Parameters
----------
cgmodel: Coarse grained model class object.
"""
#build_params_files(cgmodel)
pyrosetta.init()
pyrosetta_sequence = ''.join([
str('X[' + str(monomer['monomer_name']) + ']')
for monomer in cgmodel.sequence
])
# Build a PyRosetta pose
pose = pyrosetta.pose_from_sequence(pyrosetta_sequence)
# Define a PyRosetta scoring function
pose.dump_pdb("test_pyrosetta.pdb")
scorefxn = build_scorefxn(cgmodel)
cgmodel.positions = PDBFile("test_pyrosetta.pdb").getPositions()
cgmodel.topology = build_topology(cgmodel)
write_pdbfile_without_topology(cgmodel, "test_foldamers.pdb")
# get the PyRosetta score
score = scorefxn(pose)
# Build an OpenMM simulation object so that we can calculate the energy using a simulation Context()
temperature = 300.0 * unit.kelvin
simulation = build_mm_simulation(cgmodel.topology,
cgmodel.system,
cgmodel.positions,
temperature=temperature,
simulation_time_step=5.0 *
unit.femtosecond)
# Obtain a state for our simulation context
energy = simulation.context.getState(getEnergy=True).getPotentialEnergy()
print("The PyRosetta score is: " + str(score) + "\n")
print("The OpenMM potential energy is: " + str(energy) + "\n")
return
def __init__(self, pdb_file: str, sigmoid_center: float,
sigmoid_norm_value: float):
"""
Create a RosettaFolding landscape from a .pdb file with structure.
Args:
pdb_file: Path to .pdb file with structure information.
sigmoid_center: Center of sigmoid function.
sigmoid_norm_value: 1 / scale of sigmoid function.
"""
super().__init__(name="RosettaFolding")
# Inform the user if pyrosetta is not available.
try:
prs
except NameError as e:
raise ImportError(
"Error: Pyrosetta not installed. "
"Source, binary, and conda installations available "
"at http://www.pyrosetta.org/dow") from e
# Initialize pyrosetta and suppress output messages
prs.init("-mute all")
# We will reuse this pose over and over, mutating it to match
# whatever sequence we are given to measure.
# This is necessary since sequence identity can only be mutated
# one residue at a time in Rosetta, because the atom coords of the
# backbone of the previous residue are copied into the new one.
self.pose = prs.pose_from_pdb(pdb_file)
self.wt_pose = self.pose.clone()
# Change self.pose from full-atom to centroid representation
to_centroid_mover = prs.SwitchResidueTypeSetMover("centroid")
to_centroid_mover.apply(self.pose)
# Use 1 - sigmoid(centroid energy / norm_value) as the fitness score
self.score_function = prs.create_score_function("cen_std")
self.sigmoid_center = sigmoid_center
self.sigmoid_norm_value = sigmoid_norm_value
print( mutant_name )
import pyrosetta
import rosetta
from sys import argv
fmt = dict( zip( 'ANDRCQEGHILKMPFSTWYV', [
'ALA','ASN','ASP','ARG','CYS','GLN','GLU',
'GLY','HIS','ILE','LEU','LYS','MET','PRO','PHE','SER',
'THR','TRP','TYR','VAL' ] ) )
with open( 'input_files/flags' ) as fn:
flags = fn.read().replace( '\n', ' ' )
# init PyRosetta
pyrosetta.init( ''.join( flags ) )
ligand_params = pyrosetta.Vector1( [ 'input_files/pNPG.params' ] )
new_res_set = pyrosetta.generate_nonstandard_residue_set( ligand_params )
p = pyrosetta.Pose()
pyrosetta.pose_from_file( p, new_res_set, 'input_files/bglb.pdb' )
scorefxn = pyrosetta.create_score_function( 'beta_cst' )
add_cst = rosetta.protocols.enzdes.AddOrRemoveMatchCsts()
add_cst.cstfile( 'input_files/pNPG.enzdes.cst' )
add_cst.set_cst_action( rosetta.protocols.enzdes.CstAction.ADD_NEW )
add_cst.apply( p )
target = int( mutant_name[ 1:-1 ] )
new_res = fmt[ mutant_name[ -1 ] ]
import rosetta
import pyrosetta
import math
from pyrosetta.toolbox import mutate_residue
from itertools import groupby
from operator import itemgetter
pyrosetta.init()
def resi_within(pose, angstrom, the_sun):
def resi_atom_coords(res_in_pose): # input = the pose.residue(number) object
xyz_coords_list = [float(i) for i in str(res_in_pose.atoms())[31:-1].split(',')] # All atom coords in a residue
atoms_coords_list = [xyz_coords_list[j:j+3] for j in range(0, len(xyz_coords_list), 3)] # List of lists. xyz of individual residue
return atoms_coords_list
def distance_between_two_xyz_coords(a,b):
distance = math.sqrt((a[0]-b[0])**2 + (a[1]-b[1])**2 + (a[2]-b[2])**2)
return distance
resi_within = []
center = resi_atom_coords(pose.residue(the_sun))
for resi in range(1, pose.total_residue()+1): # loop over protein
planets = resi_atom_coords(pose.residue(resi))
for coords in center:
for other_coords in planets:
distance = distance_between_two_xyz_coords(coords,other_coords)
if distance <= angstrom:
resi_within.append(resi)
return sorted(list(set(resi_within)))[0:-1]
import pyrosetta
import math
pyrosetta.init('')
def resi_within(pose, angstrom, the_sun):
def resi_atom_coords(res_in_pose): # input = the pose.residue(number) object
xyz_coords_list = [float(i) for i in str(res_in_pose.atoms())[31:-1].split(',')] # All atom coords in a residue
atoms_coords_list = [xyz_coords_list[j:j+3] for j in range(0, len(xyz_coords_list), 3)] # List of lists. xyz of individual residue
return atoms_coords_list
def distance_between_two_xyz_coords(a,b):
distance = math.sqrt((a[0]-b[0])**2 + (a[1]-b[1])**2 + (a[2]-b[2])**2)
return distance
resi_within = []
center = resi_atom_coords(pose.residue(the_sun))
for resi in range(1, pose.total_residue()+1): # loop over protein
planets = resi_atom_coords(pose.residue(resi))
for coords in center:
for other_coords in planets:
distance = distance_between_two_xyz_coords(coords,other_coords)
if distance <= angstrom:
resi_within.append(resi)
return sorted(list(set(resi_within)))[0:-1]
def CA_distance(pose, res_num_1, res_num_2):
res_1 = {}
