def run_test1():
'''
Test if iselection for ligand PG5 (chain A resseq 201) is correct.
'''
pdb_fname = libtbx.env.find_in_repositories(
relative_path="mmtbx/regression/pdbs/one_chain_ligand_water.pdb",
test=os.path.isfile)
pdb_inp = iotbx.pdb.input(pdb_fname)
model = mmtbx.model.manager(model_input = pdb_inp, stop_for_unknowns=False)
model.process(make_restraints=True)
model.set_log(null_out())
params = iotbx.phil.parse(
input_string=master_params_str, process_includes=True).extract()
# do not place H atoms for this test
#params.validate_ligands.place_hydrogens = False
vl_manager = validate_ligands.manager(
model = model,
fmodel = None,
params = params.validate_ligands,
log = null_out())
vl_manager.run()
tst_get_ligands(vl_manager = vl_manager)
tst_get_overlaps(vl_manager = vl_manager)
def exercise3(pdb_str, type_list_known):
pdb_inp = iotbx.pdb.input(lines=pdb_str.split("\n"), source_info=None)
params = mmtbx.model.manager.get_default_pdb_interpretation_scope(
).extract()
params.pdb_interpretation.allow_polymer_cross_special_position = True
model = mmtbx.model.manager(model_input=pdb_inp, log=null_out())
model.process(pdb_interpretation_params=params, make_restraints=True)
pdb_hierarchy = model.get_hierarchy()
sites_cart = model.get_sites_cart()
atoms = pdb_hierarchy.atoms()
model.setup_riding_h_manager()
riding_h_manager = model.get_riding_h_manager()
h_para = riding_h_manager.h_parameterization
diagnostics = riding_h_manager.diagnostics(sites_cart=sites_cart,
threshold=0.05)
h_distances = diagnostics.h_distances
type_list = diagnostics.type_list
number_h = model.get_hd_selection().count(True)
number_h_para = len(h_para) - h_para.count(None)
assert (number_h_para == number_h - 2), 'Not all H atoms are parameterized'
for ih in h_distances:
labels = atoms[ih].fetch_labels()
assert (h_distances[ih] < 0.2), \
'distance too large: %s atom: %s (%s) residue: %s ' \
% (h_para[ih].htype, atoms[ih].name, ih, labels.resseq.strip())
for type1, type2 in zip(type_list, type_list_known):
assert (type1 == type2)
def run(self):
r = self.parse_cl()
if r != 0:
return
r = self.read_model_file()
if r != 0:
return
pi_params = self.get_pdb_interpretation_params()
model = mmtbx.model.manager(
model_input = self.pdb_inp,
stop_for_unknowns = False,
restraint_objects = self.input_objects.cif_objects)
model.process(pdb_interpretation_params=pi_params,
make_restraints=True)
print("Model object created from file %s:" % \
getattr(self.work_params, self.pdbf_def), file=self.log)
# If needed, this could be wrapped in try...except to catch errors.
c = validate_H(model = model,
use_neutron_distances = pi_params.pdb_interpretation.use_neutron_distances)
c.validate_inputs()
c.run()
results = c.get_results()
self.print_results(results)
def run():
pdb_inp = iotbx.pdb.input(source_info=None, lines=pdb_str)
model = mmtbx.model.manager(model_input=pdb_inp, log=null_out())
model.process(make_restraints=True)
a = aev.AEV(model=model)
print('forward AEVs')
print(a.BAEVs)
print('backward AEVs')
print(a.EAEVs)
gv = a.get_values()
for key in gv:
outl = key
for cc in gv[key]:
outl += ' %0.3f' % cc
print(outl)
# print('backward AEVs')
# print(a.EAEVs)
# print('middle AEVs')
# print(a.MAEVs)
b = aev.compare(a)
print(b)
assert b['GLY A 1']['E'] is None
print(b['GLY A 5'])
assert b['GLY A 5']['E'] > 0.99
assert b['GLY A 5']['M'] > 0.99
assert b['GLY A 5']['B'] > 0.99
assert b['GLY A 10']['B'] is None
recs = aev.format_HELIX_records_from_AEV(b, 0.9)
assert len(recs) == 1
r = "HELIX 1 1 GLY A 2 GLY A 9 8"
assert r == recs[0]
#
with open("development.aev.pdb", "w") as fo:
fo.write(pdb_str)
easy_run.call("mmtbx.development.aev development.aev.pdb 0.9")
def main(filename=None):
if filename is None:
filename = 'ala_term.pdb'
with open(filename, 'w') as f:
f.write(pdb_str)
pdb_inp = pdb.input(filename)
hierarchy = pdb_inp.construct_hierarchy()
params = mmtbx.model.manager.get_default_pdb_interpretation_params()
params.pdb_interpretation.use_neutron_distances = True
params.pdb_interpretation.restraints_library.cdl = False
print(len(hierarchy.atoms()))
asc = hierarchy.atom_selection_cache()
sel = asc.selection("element H or element D")
print('sel len', len(sel))
print(len(hierarchy.atoms()))
hierarchy.show()
model = mmtbx.model.manager(
model_input=None,
pdb_hierarchy=hierarchy,
crystal_symmetry=pdb_inp.crystal_symmetry(),
log=null_out(),
)
print('m1', len(model.get_hierarchy().atoms()))
for atom in model.get_hierarchy().atoms():
print(atom.format_atom_record())
model.process(make_restraints=True,
grm_normalization=True,
pdb_interpretation_params=params)
print('m2', len(model.get_hierarchy().atoms()))
for atom in model.get_hierarchy().atoms():
print(atom.format_atom_record())
model.idealize_h_riding()
model.set_occupancies(0., selection=sel)
def exercise_2():
"""
Same as 1 but automatic NCS search procedure does not match short chains,
in this case chains B,C, so they left out of NCS.
Not clear if we should utilize MTRIX instead of searching for NCS
because currently we don't output them and in consecutive runs NCS
search would be utilized anyway, potentially yelding different groups.
"""
inp = iotbx.pdb.input(source_info=None, lines=pdb_str_2)
pdb_int_params = mmtbx.model.manager.get_default_pdb_interpretation_params(
)
pdb_int_params.pdb_interpretation.ncs_search.enabled = True
model = mmtbx.model.manager(model_input=inp, log=null_out())
model.process(pdb_interpretation_params=pdb_int_params)
# model.get_xray_structure()
ss = model.get_ss_annotation()
assert ss.get_n_helices() == 3
assert ss.get_n_sheets() == 3
assert not model.ncs_constraints_present()
assert model.get_ncs_obj() is not None
model.setup_ncs_constraints_groups()
# print model.get_ncs_obj()
assert model.ncs_constraints_present()
assert model.get_master_hierarchy().atoms_size() == 15
# print model.get_master_hierarchy().as_pdb_string()
assert list(model.get_master_selection()).count(True) == 15
def test_reference_model(mon_lib_srv, ener_lib, prefix="tst_reference_model"):
from mmtbx.geometry_restraints.torsion_restraints.tst_reference_model import \
model_raw_records, reference_raw_records
from mmtbx.geometry_restraints.torsion_restraints.reference_model import \
reference_model
import mmtbx.model
# mstream = StringIO()
from libtbx.utils import multi_out
mstream = multi_out()
mstream.register("stdout", sys.stdout)
mstream_file_name = "polder.log"
mstreamfile = open(mstream_file_name, "w")
mstream.register("logfile", mstreamfile)
work_params = mmtbx.model.manager.get_default_pdb_interpretation_params()
work_params.reference_model.enabled = True
work_params.reference_model.use_starting_model_as_reference = True
work_params.reference_model.fix_outliers = False
pdb_inp = iotbx.pdb.input(lines=model_raw_records.split('\n'),
source_info=None)
model = mmtbx.model.manager(model_input=pdb_inp)
model.process(pdb_interpretation_params=work_params, make_restraints=True)
reference_hierarchy_list = []
tmp_hierarchy = iotbx.pdb.input(
source_info=None,
lines=reference_raw_records.split('\n')).construct_hierarchy()
reference_hierarchy_list.append(tmp_hierarchy)
rm = reference_model(model=model,
reference_hierarchy_list=reference_hierarchy_list,
params=work_params.reference_model,
log=mstream)
assert rm.get_n_proxies() == 5, "Got %d, expected 5" % rm.get_n_proxies()
geometry, xrs = make_initial_grm(mon_lib_srv, ener_lib, model_raw_records)
geometry.adopt_reference_dihedral_manager(rm)
make_geo_pickle_unpickle(geometry, xrs, prefix)
def get_pdb_inputs(pdb_str):
pdb_inp = iotbx.pdb.input(source_info=None, lines=pdb_str.split('\n'))
model = mmtbx.model.manager(model_input=pdb_inp)
model.process(make_restraints=True)
return group_args(ph=model.get_hierarchy(),
grm=model.get_restraints_manager(),
xrs=model.get_xray_structure())
def exercise(pdb_str):
params = mmtbx.model.manager.get_default_pdb_interpretation_params()
params.pdb_interpretation.use_neutron_distances = True
pdb_inp = iotbx.pdb.input(lines=pdb_str.split("\n"), source_info=None)
model = mmtbx.model.manager(model_input=pdb_inp, log=null_out())
model.process(pdb_interpretation_params=params, make_restraints=True)
pdb_hierarchy = model.get_hierarchy()
sites_cart = model.get_sites_cart()
atoms = pdb_hierarchy.atoms()
model.setup_riding_h_manager()
riding_h_manager = model.get_riding_h_manager()
h_parameterization = riding_h_manager.h_parameterization
diagnostics = riding_h_manager.diagnostics(sites_cart=sites_cart,
threshold=0.05)
h_distances = diagnostics.h_distances
number_h = model.get_hd_selection().count(True)
number_h_para = len(h_parameterization) - h_parameterization.count(None)
if (pdb_str != pdb_str_02):
assert (number_h_para == number_h), 'Not all H atoms are parameterized'
# For each H atom, check if distance between computed H and that in input model is
# not too large
for ih in h_distances:
labels = atoms[ih].fetch_labels()
assert (h_distances[ih] < 0.1), \
'distance too large: %s atom: %s (%s) residue: %s ' \
% (h_parameterization[ih].htype, atoms[ih].name, ih, labels.resseq.strip())
def tst_02():
# Test for remove_clashes
import mmtbx.model
from mmtbx.clashes import remove_clashes
import iotbx.pdb
import sys
pdb_inp = iotbx.pdb.input(lines=pdb_poor.splitlines(), source_info='None')
model = mmtbx.model.manager(model_input=pdb_inp)
model.process(make_restraints=True)
model.set_log(log=null_out())
print("\n", "-" * 79)
print(" Summary of input model statistics ")
print("-" * 79)
model.get_restraints_manager()
geometry = model.geometry_statistics()
geometry.show(log=sys.stdout)
rc = remove_clashes(model=model)
print("\n", "-" * 79)
print("Starting residues: %d " %
(rc.model.get_hierarchy().overall_counts().n_residues))
print("Side-chains removed: %d Residues removed: %d" %
(rc.side_chains_removed, rc.residues_removed))
print("Final residues: %d " %
(rc.new_model.get_hierarchy().overall_counts().n_residues))
rc.new_model.set_log(log=null_out())
rc.new_model.get_restraints_manager()
new_geometry = rc.new_model.geometry_statistics()
new_geometry.show(log=sys.stdout)
assert rc.side_chains_removed == 1
assert rc.residues_removed == 0
def exercise_presence_of_h():
tst_pdb_1 = """\
HELIX 2 2 GLY A 100 TRP A 101 1 2
ATOM 866 N GLY A 100 -128.903-139.939-104.460 1.00 27.58 N
ATOM 867 CA GLY A 100 -128.223-140.890-103.603 1.00 27.58 C
ATOM 868 C GLY A 100 -128.381-142.356-103.959 1.00 27.58 C
ATOM 869 O GLY A 100 -129.283-142.755-104.686 1.00 27.58 O
ATOM 870 H GLY A 100 -129.862-139.777-104.337 1.00 36.09 H
ATOM 871 N TRP A 101 -127.491-143.163-103.397 1.00 25.83 N
ATOM 872 CA TRP A 101 -127.455-144.601-103.619 1.00 25.83 C
ATOM 873 C TRP A 101 -128.824-145.274-103.752 1.00 25.83 C
ATOM 874 O TRP A 101 -129.091-145.962-104.734 1.00 25.83 O
ATOM 875 CB TRP A 101 -126.659-145.240-102.480 1.00 42.04 C
ATOM 876 CG TRP A 101 -126.207-146.635-102.729 1.00 42.04 C
ATOM 877 CD1 TRP A 101 -126.180-147.300-103.922 1.00 42.04 C
ATOM 878 CD2 TRP A 101 -125.677-147.528-101.760 1.00 42.04 C
ATOM 879 NE1 TRP A 101 -125.663-148.557-103.751 1.00 42.04 N
ATOM 880 CE2 TRP A 101 -125.347-148.723-102.429 1.00 42.04 C
ATOM 881 CE3 TRP A 101 -125.446-147.437-100.384 1.00 42.04 C
ATOM 882 CZ2 TRP A 101 -124.799-149.820-101.767 1.00 42.04 C
ATOM 883 CZ3 TRP A 101 -124.899-148.528 -99.725 1.00 42.04 C
ATOM 884 CH2 TRP A 101 -124.581-149.703-100.415 1.00 42.04 C
ATOM 885 H TRP A 101 -126.863-142.797-102.745 1.00 42.04 H
"""
pdb_inp = iotbx.pdb.input(source_info=None, lines=tst_pdb_1)
ann = pdb_inp.extract_secondary_structure()
model = mmtbx.model.manager(model_input=pdb_inp)
model.process(make_restraints=True)
model.set_ss_annotation(ann)
rm = ssb.substitute_ss(model, )
def tst_1():
'''
input model: bond lengths close to neutron but not quite
input grm: neutron bond lengths
'''
pdb_inp = iotbx.pdb.input(lines=pdb_str1.split("\n"), source_info=None)
params = mmtbx.model.manager.get_default_pdb_interpretation_params()
params.pdb_interpretation.use_neutron_distances = True
model = mmtbx.model.manager(
model_input = pdb_inp,
log = null_out())
model.process(pdb_interpretation_params=params,
make_restraints=True)
# request neutron bond lengths
model.set_hydrogen_bond_length(use_neutron_distances=True,
show=False,
log=sys.stdout)
compare_XH_bond_length_to_ideal(model = model)
#STOP()
# request X-ray bond lengths
pdb_inp = iotbx.pdb.input(lines=pdb_str1.split("\n"), source_info=None)
model = mmtbx.model.manager(
model_input = pdb_inp,
log = null_out())
model.process(pdb_interpretation_params=params, make_restraints=False)
model.set_hydrogen_bond_length(use_neutron_distances=False,
show=False,
log=sys.stdout)
compare_XH_bond_length_to_ideal(model = model)
def exercise(pdb_str):
pdb_inp = iotbx.pdb.input(lines=pdb_str.split("\n"), source_info=None)
model = mmtbx.model.manager(model_input=pdb_inp, log=null_out())
model.process(make_restraints=True)
pdb_hierarchy = model.get_hierarchy()
sites_cart = model.get_sites_cart()
atoms = pdb_hierarchy.atoms()
model.setup_riding_h_manager()
riding_h_manager = model.get_riding_h_manager()
h_parameterization = riding_h_manager.h_parameterization
diagnostics = riding_h_manager.diagnostics(sites_cart=sites_cart,
threshold=0.05)
diagnostics = riding_h_manager.diagnostics(sites_cart=sites_cart,
threshold=0.05)
h_distances = diagnostics.h_distances
number_h = model.get_hd_selection().count(True)
number_h_para = len(h_parameterization) - h_parameterization.count(None)
# There are 90 H atoms in pdb_string, check if all of them are recognized
assert (number_h_para == number_h), 'Not all H atoms are parameterized'
for ih in h_distances:
labels = atoms[ih].fetch_labels()
assert (h_distances[ih] < 0.01), \
'distance too large: %s atom: %s (%s) residue: %s ' \
% (h_parameterization[ih].htype, atoms[ih].name, ih, labels.resseq.strip())
def exercise_1():
pdb_inp = iotbx.pdb.input(lines=flex.std_string(pdb_str_1.splitlines()),
source_info=None)
model = mmtbx.model.manager(model_input=pdb_inp)
model.process(make_restraints=True)
grm = model.get_restraints_manager().geometry
pdb_hierarchy = model.get_hierarchy()
sites_cart = model.get_sites_cart()
# c-beta restraints are added by default!!!
assert len(grm.get_c_beta_torsion_proxies()) == 4
#test global selection and removing c-beta restraints
tst_boolsel = pdb_hierarchy.atom_selection_cache().selection("resname TYR")
tst_iselection = tst_boolsel.iselection()
#test global selection
grm2 = grm.select(iselection=tst_iselection)
assert len(grm2.get_c_beta_torsion_proxies()) == 2
grm2 = grm.select(selection=tst_boolsel)
assert len(grm2.get_c_beta_torsion_proxies()) == 2
#remove a selection
grm.remove_c_beta_torsion_restraints_in_place(selection=tst_iselection)
assert len(grm.get_c_beta_torsion_proxies()) == 2
#add a selection
grm.remove_c_beta_torsion_restraints_in_place()
assert len(grm.get_c_beta_torsion_proxies()) == 0
c_beta_torsion_proxies = c_beta.get_c_beta_torsion_proxies(
pdb_hierarchy, selection=tst_iselection, sigma=2.5)
assert len(c_beta_torsion_proxies) == 2
def tst_3():
'''
Test if the modification works also when cif_objects are supplied
(meaning there is a ligand cif file)
'''
pdb_inp = iotbx.pdb.input(lines=pdb_str2.split("\n"), source_info=None)
cif_object = iotbx.cif.reader(input_string = cif_str2).model()
# bla.cif does not exist, but cif_objects needs a filename in first position
# of the tuple
cif_objects = [('bla.cif', cif_object)]
params = mmtbx.model.manager.get_default_pdb_interpretation_params()
params.pdb_interpretation.use_neutron_distances = False
model = mmtbx.model.manager(
model_input = pdb_inp,
restraint_objects = cif_objects,
log = null_out())
model.process(pdb_interpretation_params = params)
# request neutron bond lengths
model.set_hydrogen_bond_length(use_neutron_distances=True,
show=False,
log=sys.stdout)
compare_XH_bond_length_to_ideal(model = model)
# request X-ray bond lengths
model.set_hydrogen_bond_length(use_neutron_distances=False,
show=False,
log=sys.stdout)
compare_XH_bond_length_to_ideal(model = model)
def exercise():
pdb_inp = iotbx.pdb.input(source_info=None, lines=pdb_str)
ann = pdb_inp.extract_secondary_structure()
pdb_int_params = mmtbx.model.manager.get_default_pdb_interpretation_params(
)
pdb_int_params.pdb_interpretation.ncs_search.enabled = True
model = mmtbx.model.manager(model_input=pdb_inp)
model.process(pdb_interpretation_params=pdb_int_params,
make_restraints=True)
model.setup_ncs_constraints_groups()
log = StringIO()
rm = ssb.substitute_ss(model, log=log)
rm.run()
# with open("res.pdb", 'w') as f:
# f.write(model.model_as_pdb())
# check that strict NCS was implemented throughout
dif = get_difference_chainsAB(strings=model.model_as_pdb())
for d in dif:
assert approx_equal(d, (0, 0, 0), eps=0.005)
log_cont = log.getvalue()
# print("===========================")
# print (log_cont)
# print("===========================")
assert log_cont.find(
"1 element(s) were skipped because they are in NCS copies") > 0
print("OK")
def exercise_some_atoms_are_absent():
""" CD1, CD2 from 101 residue are absent"""
tst_pdb_2 = """\
HELIX 2 2 GLY A 100 TRP A 101 1 2
ATOM 866 N GLY A 100 -128.903-139.939-104.460 1.00 27.58 N
ATOM 867 CA GLY A 100 -128.223-140.890-103.603 1.00 27.58 C
ATOM 868 C GLY A 100 -128.381-142.356-103.959 1.00 27.58 C
ATOM 869 O GLY A 100 -129.283-142.755-104.686 1.00 27.58 O
ATOM 871 N TRP A 101 -127.491-143.163-103.397 1.00 25.83 N
ATOM 872 CA TRP A 101 -127.455-144.601-103.619 1.00 25.83 C
ATOM 873 C TRP A 101 -128.824-145.274-103.752 1.00 25.83 C
ATOM 874 O TRP A 101 -129.091-145.962-104.734 1.00 25.83 O
ATOM 875 CB TRP A 101 -126.659-145.240-102.480 1.00 42.04 C
ATOM 876 CG TRP A 101 -126.207-146.635-102.729 1.00 42.04 C
ATOM 879 NE1 TRP A 101 -125.663-148.557-103.751 1.00 42.04 N
ATOM 880 CE2 TRP A 101 -125.347-148.723-102.429 1.00 42.04 C
ATOM 881 CE3 TRP A 101 -125.446-147.437-100.384 1.00 42.04 C
"""
pdb_inp = iotbx.pdb.input(source_info=None, lines=tst_pdb_2)
ann = pdb_inp.extract_secondary_structure()
model = mmtbx.model.manager(model_input=pdb_inp)
model.process(make_restraints=True)
model.set_ss_annotation(ann)
rm = ssb.substitute_ss(model)
rm.run()
def get_model_from_file(file_path):
pdb_inp = iotbx.pdb.input(file_name=file_path)
model = mmtbx.model.manager(model_input=pdb_inp,
stop_for_unknowns=False,
log=null_out())
model.process(make_restraints=False)
return model
def exercise(pdb_str, use_ideal_bonds_angles):
# --------------------------------------------------------------
# code to switch off CDL
# --------------------------------------------------------------
#params_line = grand_master_phil_str
#params = iotbx.phil.parse(
# input_string=params_line, process_includes=True).extract()
#params.pdb_interpretation.restraints_library.cdl=False
# ---------------------------------------------------------------
pdb_inp = iotbx.pdb.input(lines=pdb_str.split("\n"), source_info=None)
model = mmtbx.model.manager(model_input=pdb_inp, log=null_out())
model.process(make_restraints=True)
pdb_hierarchy = model.get_hierarchy()
geometry_restraints = model.get_restraints_manager().geometry
xray_structure = model.get_xray_structure()
sites_cart = model.get_sites_cart()
grf = cctbx.geometry_restraints.flags.flags(default=True)
minimized = mmtbx.refinement.geometry_minimization.lbfgs(
sites_cart=sites_cart,
correct_special_position_tolerance=1.0,
geometry_restraints_manager=geometry_restraints,
geometry_restraints_flags=grf,
lbfgs_termination_params=scitbx.lbfgs.termination_parameters(
max_iterations=500))
xray_structure.set_sites_cart(sites_cart)
pdb_hierarchy.adopt_xray_structure(xray_structure)
atoms = pdb_hierarchy.atoms()
sites_cart = xray_structure.sites_cart()
riding_h_manager = riding.manager(
pdb_hierarchy=pdb_hierarchy,
geometry_restraints=geometry_restraints,
use_ideal_bonds_angles=use_ideal_bonds_angles)
h_parameterization = riding_h_manager.h_parameterization
diagnostics = riding_h_manager.diagnostics(sites_cart=sites_cart,
threshold=0.05)
h_distances = diagnostics.h_distances
number_h = model.get_hd_selection().count(True)
number_h_para = len(h_parameterization) - h_parameterization.count(None)
assert (number_h_para == number_h), 'Not all H atoms are parameterized'
for ih in h_distances:
labels = atoms[ih].fetch_labels()
if use_ideal_bonds_angles:
assert (h_distances[ih] < 0.03), \
'distance too large: %s atom: %s (%s) residue: %s ' \
% (h_parameterization[ih].htype, atoms[ih].name, ih, labels.resseq.strip())
else:
assert (h_distances[ih] < 1e-7), \
'distance too large: %s atom: %s (%s) residue: %s distance %s' \
% (h_parameterization[ih].htype, atoms[ih].name, ih, labels.resseq.strip(), h_distances[ih])
def benchmark_structure(pdb_in, mon_lib_srv, ener_lib, verbose=False, w=1.0):
log = StringIO()
params = mmtbx.model.manager.get_default_pdb_interpretation_params()
params.pdb_interpretation.peptide_link.ramachandran_restraints = True
params.pdb_interpretation.ramachandran_plot_restraints.inject_emsley8k_into_oldfield_favored=False
model = mmtbx.model.manager(
model_input=pdb_in,
log=null_out())
model.process(pdb_interpretation_params=params, make_restraints=True)
grm = model.get_restraints_manager().geometry
pdb_hierarchy = model.get_hierarchy()
r0 = ramalyze(pdb_hierarchy=pdb_hierarchy, outliers_only=False)
atoms = pdb_hierarchy.atoms()
sites_cart_1 = atoms.extract_xyz().deep_copy()
sites_cart_2 = sites_cart_1.deep_copy()
assert (grm is not None)
e = grm.energies_sites(sites_cart=sites_cart_1)
b0 = e.bond_deviations()[-1]
a0 = e.angle_deviations()[-1]
flags = cctbx.geometry_restraints.flags.flags(default=True)
lbfgs = geometry_minimization.lbfgs(
sites_cart=sites_cart_1,
correct_special_position_tolerance=1.0,
geometry_restraints_manager=grm,
geometry_restraints_flags=flags,
lbfgs_termination_params=scitbx.lbfgs.termination_parameters(
max_iterations=500))
a1 = lbfgs.rmsd_angles
b1 = lbfgs.rmsd_bonds
atoms.set_xyz(sites_cart_1)
r1 = ramalyze(pdb_hierarchy=pdb_hierarchy, outliers_only=False)
rama_params = ramachandran.master_phil.fetch().extract().ramachandran_plot_restraints
rama_manager = ramachandran.ramachandran_manager(
pdb_hierarchy, rama_params, log)
grm.set_ramachandran_restraints(rama_manager)
lbfgs = geometry_minimization.lbfgs(
sites_cart=sites_cart_2,
correct_special_position_tolerance=1.0,
geometry_restraints_manager=grm,
geometry_restraints_flags=flags,
lbfgs_termination_params=scitbx.lbfgs.termination_parameters(
max_iterations=500))
a2 = lbfgs.rmsd_angles
b2 = lbfgs.rmsd_bonds
atoms.set_xyz(sites_cart_2)
r2 = ramalyze(pdb_hierarchy=pdb_hierarchy, outliers_only=False)
return group_args(
a0=a0,
a1=a1,
a2=a2,
b0=b0,
b1=b1,
b2=b2,
r0=r0,
r1=r1,
r2=r2)
def exercise2():
pdb_inp = iotbx.pdb.input(lines=pdb_str.split("\n"), source_info=None)
model = mmtbx.model.manager(
model_input = pdb_inp,
log = null_out())
model.process(make_restraints=True)
pdb_hierarchy = model.get_hierarchy()
#sites_cart = model.get_sites_cart()
#atoms = pdb_hierarchy.atoms()
model.setup_riding_h_manager()
riding_h_manager = model.get_riding_h_manager()
h_parameterization = riding_h_manager.h_parameterization
number_h = model.get_hd_selection().count(True)
number_h_para = len(h_parameterization) - h_parameterization.count(None)
# Check that all H atoms are parameterized in original manager
assert (number_h_para == number_h - 1), 'Not all H atoms are parameterized'
# Test several selections and compare with known answers
#
print('selection1 = not (name CE1 or name CB)')
selection1 = pdb_hierarchy.atom_selection_cache().\
selection("not (name CE1 or name CB)")
answers1 = group_args(
entries_selected_h_para = 19,
entries_cpp_selected = 2,
h_in_selected_hierarchy = 9)
apply_selection(
riding_h_manager = riding_h_manager,
selection = selection1,
answers = answers1)
#
print('selection2 = not (name CD1 or name HD2 or name C)')
selection2 = pdb_hierarchy.atom_selection_cache().\
selection("not (name CD1 or name HD2 or name C)")
answers2 = group_args(
entries_selected_h_para = 18,
entries_cpp_selected = 4,
h_in_selected_hierarchy = 8)
apply_selection(
riding_h_manager = riding_h_manager,
selection = selection2,
answers = answers2)
#
print('selection3 = not (name N or name HB2 or name CE2)')
selection3 = pdb_hierarchy.atom_selection_cache().\
selection("not (name N or name HB2 or name CE2)")
answers3 = group_args(
entries_selected_h_para = 18,
entries_cpp_selected = 4,
h_in_selected_hierarchy = 8)
apply_selection(
riding_h_manager = riding_h_manager,
selection = selection3,
answers = answers3)
def exercise_bond_near_symmetry3(mon_lib_srv, ener_lib):
""" Since neighbors_fast_pair_generator for non-symmetry interactions
provides only (i,j) pair and not (j,i), and there's no sorting involved
(no way to guess what to check), there was a bug where non-symmetry interaction
was missed in add_new_bond_restraints_in_place.
Actually testing that both bonds are added without symmetry operators.
"""
from cctbx.geometry_restraints.linking_class import linking_class
origin_ids = linking_class()
pdb_inp = iotbx.pdb.input(source_info=None, lines=raw_records8)
model = mmtbx.model.manager(model_input=pdb_inp, log=null_out())
model.process(make_restraints=True)
grm = model.get_restraints_manager().geometry
h = model.get_hierarchy()
proxy = geometry_restraints.bond_simple_proxy(
i_seqs=(64, 37),
distance_ideal=2.9,
weight=400,
origin_id=origin_ids.get_origin_id('hydrogen bonds'))
proxy2 = geometry_restraints.bond_simple_proxy(
i_seqs=(72, 37),
distance_ideal=2.9,
weight=400,
origin_id=origin_ids.get_origin_id('hydrogen bonds'))
grm.add_new_hbond_restraints_in_place(
proxies=[proxy, proxy2],
sites_cart=h.atoms().extract_xyz(),
max_distance_between_connecting_atoms=10)
sites_cart = h.atoms().extract_xyz()
site_labels = model.get_xray_structure().scatterers().extract_labels()
pair_proxies = grm.pair_proxies(flags=None, sites_cart=sites_cart)
out = StringIO()
pair_proxies.bond_proxies.show_sorted(
by_value="residual",
sites_cart=sites_cart,
site_labels=site_labels,
f=out,
prefix="",
origin_id=origin_ids.get_origin_id('hydrogen bonds'))
outtxt = out.getvalue()
assert not show_diff(
outtxt, """\
Bond restraints: 2
Sorted by residual:
bond pdb=" O ARG A 25 "
pdb=" N AASN A 29 "
ideal model delta sigma weight residual
2.900 2.934 -0.034 5.00e-02 4.00e+02 4.53e-01
bond pdb=" O ARG A 25 "
pdb=" N BASN A 29 "
ideal model delta sigma weight residual
2.900 2.888 0.012 5.00e-02 4.00e+02 5.59e-02
""")
def exercise_bond_over_symmetry(mon_lib_srv, ener_lib):
from cctbx.geometry_restraints.linking_class import linking_class
origin_ids = linking_class()
pdb_inp = iotbx.pdb.input(source_info=None, lines=raw_records9)
params = mmtbx.model.manager.get_default_pdb_interpretation_params()
params.pdb_interpretation.restraints_library.mcl = False
model = mmtbx.model.manager(model_input=pdb_inp, log=null_out())
model.process(pdb_interpretation_params=params, make_restraints=True)
grm = model.get_restraints_manager().geometry
simple, asu = grm.get_all_bond_proxies()
assert (simple.size(), asu.size()) == (29, 0)
h = model.get_hierarchy()
proxy = geometry_restraints.bond_simple_proxy(
i_seqs=(32, 4),
distance_ideal=2.9,
weight=400,
origin_id=origin_ids.get_origin_id('hydrogen bonds'))
proxy2 = geometry_restraints.bond_simple_proxy(
i_seqs=(32, 24),
distance_ideal=2.9,
weight=400,
origin_id=origin_ids.get_origin_id('hydrogen bonds'))
grm.add_new_bond_restraints_in_place(proxies=[proxy, proxy2],
sites_cart=h.atoms().extract_xyz())
simple, asu = grm.get_all_bond_proxies()
assert (simple.size(), asu.size()) == (30, 2)
sites_cart = h.atoms().extract_xyz()
site_labels = model.get_xray_structure().scatterers().extract_labels()
pair_proxies = grm.pair_proxies(flags=None, sites_cart=sites_cart)
out = StringIO()
pair_proxies.bond_proxies.show_sorted(by_value="residual",
sites_cart=sites_cart,
site_labels=site_labels,
f=out,
prefix="")
outtxt = out.getvalue()
# print(outtxt)
#
# Not clear why ZN-NE2 bond adds as 2 bonds.
assert_lines_in_text(
outtxt, """\
bond pdb="ZN ZN A 8 "
pdb=" NE2 HIS B 304 "
ideal model delta sigma weight residual sym.op.
2.900 2.969 -0.069 5.00e-02 4.00e+02 1.92e+00 -x-1/2,y+1/2,-z+3/4
""")
assert_lines_in_text(
outtxt, """\
bond pdb=" NE2 HIS B 304 "
pdb="ZN ZN A 8 "
ideal model delta sigma weight residual sym.op.
2.900 2.969 -0.069 5.00e-02 4.00e+02 1.92e+00 -x-1/2,y-1/2,-z+3/4
""")
def exercise_dihedral_edits_change():
edits = """\
geometry_restraints.edits {
dihedral {
action = *change
atom_selection_1 = resid 1 and name CA
atom_selection_2 = resid 1 and name C
atom_selection_3 = resid 2 and name N
atom_selection_4 = resid 2 and name CA
angle_ideal = 100.00
alt_angle_ideals = 90,110
sigma = 2
periodicity = 2
}
}"""
def_params = mmtbx.model.manager.get_default_pdb_interpretation_scope()
edits_phil = iotbx.phil.parse(edits)
working_phil = def_params.fetch(edits_phil)
params = working_phil.extract()
inp = iotbx.pdb.input(lines=raw_records2, source_info=None)
model = mmtbx.model.manager(model_input=inp)
model.process(make_restraints=True)
grm = model.get_restraints_manager().geometry
assert grm.dihedral_proxies.size() == 9
dih1 = grm.dihedral_proxies.proxy_select(n_seq=model.get_number_of_atoms(),
iselection=flex.size_t(
[1, 2, 5, 6]))
assert dih1.size() == 1
dp1 = dih1[0]
assert approx_equal(dp1.angle_ideal, 180)
assert dp1.alt_angle_ideals == None
assert dp1.origin_id == 0
assert dp1.periodicity == 0
assert dp1.slack == 0
assert not dp1.top_out
assert approx_equal(dp1.weight, 0.04)
# Now with modifications
inp = iotbx.pdb.input(lines=raw_records2, source_info=None)
model2 = mmtbx.model.manager(model_input=inp)
model2.process(pdb_interpretation_params=params, make_restraints=True)
grm2 = model2.get_restraints_manager().geometry
assert grm2.dihedral_proxies.size() == 9
dih2 = grm2.dihedral_proxies.proxy_select(
n_seq=model2.get_number_of_atoms(),
iselection=flex.size_t([1, 2, 5, 6]))
assert dih2.size() == 1
dp2 = dih2[0]
assert approx_equal(dp2.angle_ideal, 100)
assert dp2.alt_angle_ideals == (90, 110)
assert dp2.origin_id == origin_ids.get_origin_id('edits')
assert dp2.periodicity == 2
assert dp2.slack == 0
assert not dp2.top_out
assert approx_equal(dp2.weight, 0.25)
def exercise(pdb_str, eps):
pdb_inp = iotbx.pdb.input(lines=pdb_str.split("\n"), source_info=None)
model = mmtbx.model.manager(model_input=pdb_inp, log=null_out())
model.process(make_restraints=True)
geometry_restraints = model.restraints_manager.geometry
xray_structure = model.get_xray_structure()
model.setup_riding_h_manager()
riding_h_manager = model.get_riding_h_manager()
riding_h_manager.idealize_riding_h_positions(xray_structure=xray_structure)
sites_cart = xray_structure.sites_cart()
g_analytical = geometry_restraints.energies_sites(
sites_cart=sites_cart, compute_gradients=True).gradients
hd_selection = xray_structure.hd_selection()
g_analytical_reduced = riding_h_manager.gradients_reduced_cpp(
gradients=g_analytical,
sites_cart=sites_cart,
hd_selection=hd_selection)
#
ex = [eps, 0, 0]
ey = [0, eps, 0]
ez = [0, 0, eps]
g_fd = flex.vec3_double()
for i_site in range(sites_cart.size()):
g_fd_i = []
for e in [ex, ey, ez]:
ts = []
for sign in [-1, 1]:
sites_cart_ = sites_cart.deep_copy()
xray_structure_ = xray_structure.deep_copy_scatterers()
sites_cart_[i_site] = [
sites_cart_[i_site][j] + e[j] * sign for j in range(3)
]
xray_structure_.set_sites_cart(sites_cart_)
# after shift, recalculate H position
riding_h_manager.idealize_riding_h_positions(
xray_structure=xray_structure_)
sites_cart_ = xray_structure_.sites_cart()
ts.append(
geometry_restraints.energies_sites(
sites_cart=sites_cart_,
compute_gradients=False).target)
g_fd_i.append((ts[1] - ts[0]) / (2 * eps))
g_fd.append(g_fd_i)
g_fd_reduced = g_fd.select(~hd_selection)
for g1, g2 in zip(g_analytical_reduced, g_fd_reduced):
assert approx_equal(g1, g2, 1.e-4)
def run():
result = []
for p in [True, False]:
for mr in [True, False]:
pdb_inp = iotbx.pdb.input(source_info=None, lines = pdb_str)
hierarchy = pdb_inp.construct_hierarchy()
model = mmtbx.model.manager(model_input=pdb_inp, log=null_out())
if(p):
model.process(make_restraints=mr)
o = molprobity.molprobity(model = model)
result.append("%8.4f"%o.rms_bonds())
assert len(list(set(result)))==1
def obtain_model(raw_records, stop_for_unknowns=True):
'''
Helper function to obtain model class from raw records
'''
params = mmtbx.model.manager.get_default_pdb_interpretation_params()
params.pdb_interpretation.allow_polymer_cross_special_position = True
pdb_inp = iotbx.pdb.input(lines=raw_records.split("\n"), source_info=None)
model = mmtbx.model.manager(model_input=pdb_inp,
stop_for_unknowns=stop_for_unknowns,
log=null_out())
model.process(pdb_interpretation_params=params, make_restraints=True)
return model
def exercise1():
pdb_inp = iotbx.pdb.input(lines=pdb_str.split("\n"), source_info=None)
model = mmtbx.model.manager(
model_input = pdb_inp,
log = null_out())
model.process(make_restraints=True)
pdb_hierarchy = model.get_hierarchy()
sites_cart = model.get_sites_cart()
atoms = pdb_hierarchy.atoms()
model.setup_riding_h_manager()
riding_h_manager = model.get_riding_h_manager()
h_parameterization = riding_h_manager.h_parameterization
number_h = model.get_hd_selection().count(True)
number_h_para = len(h_parameterization) - h_parameterization.count(None)
assert (number_h_para == number_h-1), 'Not all H atoms are parameterized'
rc = h_parameterization[20]
new_manager = riding_h_manager.deep_copy()
new_h_parameterization = new_manager.h_parameterization
rc_new = new_h_parameterization[20]
assert (rc_new.htype == rc.htype)
assert (rc_new.ih == rc.ih)
assert (rc_new.a0 == rc.a0)
assert (rc_new.a1 == rc.a1)
assert (rc_new.a2 == rc.a2)
assert (rc_new.a3 == rc.a3)
assert (rc_new.a == rc.a)
assert (rc_new.b == rc.b)
assert (rc_new.h == rc.h)
assert (rc_new.n == rc.n)
assert (rc_new.disth == rc.disth)
rc_new.htype = 'unk'
rc_new.ih = 0
rc_new.a0 = 1
rc_new.a1 = 2
rc_new.a2 = 3
rc_new.a3 = 4
assert (rc_new.htype != rc.htype)
assert (rc_new.ih != rc.ih)
assert (rc_new.a0 != rc.a0)
assert (rc_new.a1 != rc.a1)
assert (rc_new.a2 != rc.a2)
assert (rc_new.a3 != rc.a3)
def check_scattering_type_registry():
pdb_inp = iotbx.pdb.input(source_info=None, lines=pdb_str)
model = mmtbx.model.manager(model_input=pdb_inp, log=null_out())
model.process(make_restraints=True)
xrs1 = model.get_xray_structure()
xrs2 = model.get_hierarchy().extract_xray_structure(
crystal_symmetry=model.crystal_symmetry())
xrs1.scattering_type_registry(table="electron")
xrs2.scattering_type_registry(table="electron")
xrs1.scattering_type_registry().show()
xrs2.scattering_type_registry().show()
# TODO: Assert to the same value once added
assert (xrs1.scattering_type_registry().gaussian("O1-") is None)
assert (xrs2.scattering_type_registry().gaussian("O1-") is None)
def get_model(file_name, log, pdb_str=None):
pdb_interpretation_params = iotbx.phil.parse(
input_string=pdb_interpretation.grand_master_phil_str,
process_includes=True).extract()
pdb_interpretation_params.pdb_interpretation.sort_atoms = False
if not pdb_str:
pdb_inp = iotbx.pdb.input(file_name=file_name)
else:
pdb_inp = iotbx.pdb.input(lines=pdb_str, source_info=None)
model = mmtbx.model.manager(model_input=pdb_inp,
stop_for_unknowns=False,
log=log)
model.process(pdb_interpretation_params=pdb_interpretation_params)
return model
