def omega(self):
result = omegalyze.omegalyze(pdb_hierarchy=self.pdb_hierarchy, quiet=True)
# XXX Move this to omegalyze function.
n_proline = result.n_proline()
n_general = result.n_general()
n_cis_proline = result.n_cis_proline()
n_cis_general = result.n_cis_general()
n_twisted_proline = result.n_twisted_proline()
n_twisted_general = result.n_twisted_general()
cis_general = 0
twisted_general = 0
cis_proline = 0
twisted_proline = 0
if(n_proline != 0):
cis_proline = n_cis_proline *100./n_proline
twisted_proline = n_twisted_proline*100./n_proline
if(n_general != 0):
cis_general = n_cis_general *100./n_general
twisted_general = n_twisted_general*100./n_general
return group_args(
cis_proline = cis_proline,
cis_general = cis_general,
twisted_general = twisted_general,
twisted_proline = twisted_proline,
n_twisted_general = n_twisted_general,
omegalyze = result #XXX Bulky object -- REMOVE!
)
def run(self):
f = None
if self.params.result_file is not None:
try:
f = open(self.params.result_file, 'w')
self.logger.register('file', f)
except IOError:
raise Sorry("The output file could not be opened")
hierarchy = self.data_manager.get_model().get_hierarchy()
hierarchy.atoms().reset_i_seq()
result = omegalyze(pdb_hierarchy=hierarchy,
nontrans_only=self.params.nontrans_only,
out=self.logger,
quiet=False)
if self.params.kinemage:
print(result.as_kinemage(), file=self.logger)
elif self.params.oneline:
result.summary_only(out=self.logger,
pdbid=self.data_manager.get_default_model_name(
)) #params.model)
elif self.params.text:
result.show_old_output(out=self.logger, verbose=True)
if f:
try:
f.close()
except Exception:
raise Sorry("Could not close output file")
def export_molprobity_result_as_kinemage(result,
pdb_hierarchy,
geometry,
probe_file,
keep_hydrogens=False,
pdbID="PDB"):
assert (result.restraints is not None)
i_seq_name_hash = build_name_hash(pdb_hierarchy=pdb_hierarchy)
sites_cart = pdb_hierarchy.atoms().extract_xyz()
flags = geometry_restraints.flags.flags(default=True)
angle_proxies = geometry.angle_proxies
pair_proxies = geometry.pair_proxies(flags=flags, sites_cart=sites_cart)
bond_proxies = pair_proxies.bond_proxies
quick_bond_hash = {}
for bp in bond_proxies.simple:
if (i_seq_name_hash[bp.i_seqs[0]][9:14] == i_seq_name_hash[
bp.i_seqs[1]][9:14]):
if quick_bond_hash.get(bp.i_seqs[0]) is None:
quick_bond_hash[bp.i_seqs[0]] = []
quick_bond_hash[bp.i_seqs[0]].append(bp.i_seqs[1])
kin_out = get_default_header()
altid_controls = get_altid_controls(hierarchy=pdb_hierarchy)
if altid_controls != "":
kin_out += altid_controls
kin_out += "@group {%s} dominant animate\n" % pdbID
initiated_chains = []
counter = 0
for model in pdb_hierarchy.models():
for chain in model.chains():
if chain.id not in initiated_chains:
kin_out += "@subgroup {%s} dominant master= {chain %s}\n" % (
pdbID, chain.id)
initiated_chains.append(chain.id)
kin_out += get_kin_lots(chain=chain,
bond_hash=quick_bond_hash,
i_seq_name_hash=i_seq_name_hash,
pdbID=pdbID,
index=counter)
if (chain.is_protein()):
assert (not None in [result.rotalyze, result.ramalyze])
kin_out += rotamer_outliers(chain=chain,
pdbID=pdbID,
rot_outliers=result.rotalyze)
kin_out += rama_outliers(chain=chain,
pdbID=pdbID,
ram_outliers=result.ramalyze)
kin_out += result.restraints.as_kinemage(chain_id=chain.id)
if (chain.is_protein()):
assert (result.cbetadev is not None)
kin_out += result.cbetadev.as_kinemage(chain_id=chain.id)
kin_out += pperp_outliers(hierarchy=pdb_hierarchy, chain=chain)
counter += 1
kin_out += omegalyze.omegalyze(pdb_hierarchy=pdb_hierarchy,
nontrans_only=True,
out=None,
quiet=False).as_kinemage()
kin_out += make_probe_dots(hierarchy=pdb_hierarchy,
keep_hydrogens=keep_hydrogens)
kin_out += get_footer()
return kin_out
def run_omegalyze(self) :
from mmtbx.validation import omegalyze
omegalyze_result = omegalyze.omegalyze(
pdb_hierarchy = self.hierarchy,
nontrans_only = False,
out = sys.stdout,
quiet = False)
for result in omegalyze_result.results :
resd = mdb_utils.get_resd(self.pdb_code,result)
MDBRes = mdb_utils.MDBResidue(**resd)
reskey = MDBRes.get_residue_key()
if reskey not in self.residues.keys(): # alternates likely exist
reskeys = self.get_alternate_keys(resd)
for k in reskeys :
self.residues[k].add_omegalyze_result(result)
else : # No alternates
self.residues[reskey].add_omegalyze_result(result)
def __init__(
self,
pdb_hierarchy,
molprobity_scores=False,
):
self.pdb_hierarchy = pdb_hierarchy
self.clashscore = None
self.ramachandran_outliers = None
self.ramachandran_allowed = None
self.ramachandran_favored = None
self.rotamer_outliers = None
self.c_beta_dev = None
self.mpscore = None
self.omglz = None
self.n_cis_proline = None
self.n_cis_general = None
self.n_twisted_proline = None
self.n_twisted_general = None
if(molprobity_scores):
self.ramalyze_obj = ramalyze(pdb_hierarchy=pdb_hierarchy, outliers_only=False)
self.ramachandran_outliers = self.ramalyze_obj.percent_outliers
self.ramachandran_allowed = self.ramalyze_obj.percent_allowed
self.ramachandran_favored = self.ramalyze_obj.percent_favored
self.rotalyze_obj = rotalyze(pdb_hierarchy=pdb_hierarchy, outliers_only=False)
self.rotamer_outliers = self.rotalyze_obj.percent_outliers
self.cbetadev_obj = cbetadev(
pdb_hierarchy = pdb_hierarchy,
outliers_only = True,
out = null_out())
self.c_beta_dev = self.cbetadev_obj.get_outlier_count()
self.clashscore = clashscore(pdb_hierarchy=pdb_hierarchy).get_clashscore()
self.mpscore = molprobity_score(
clashscore = self.clashscore,
rota_out = self.rotamer_outliers,
rama_fav = self.ramachandran_favored)
self.omglz = omegalyze.omegalyze(
pdb_hierarchy=self.pdb_hierarchy, quiet=True)
self.n_cis_proline = self.omglz.n_cis_proline()
self.n_cis_general = self.omglz.n_cis_general()
self.n_twisted_proline = self.omglz.n_twisted_proline()
self.n_twisted_general = self.omglz.n_twisted_general()
def __init__(
self,
pdb_hierarchy,
molprobity_scores=False,
):
self.pdb_hierarchy = pdb_hierarchy
self.clashscore = None
self.ramachandran_outliers = None
self.ramachandran_allowed = None
self.ramachandran_favored = None
self.rotamer_outliers = None
self.c_beta_dev = None
self.mpscore = None
self.omglz = None
self.n_cis_proline = None
self.n_cis_general = None
self.n_twisted_proline = None
self.n_twisted_general = None
if(molprobity_scores):
self.ramalyze_obj = ramalyze(pdb_hierarchy=pdb_hierarchy, outliers_only=False)
self.ramachandran_outliers = self.ramalyze_obj.percent_outliers
self.ramachandran_allowed = self.ramalyze_obj.percent_allowed
self.ramachandran_favored = self.ramalyze_obj.percent_favored
self.rotalyze_obj = rotalyze(pdb_hierarchy=pdb_hierarchy, outliers_only=False)
self.rotamer_outliers = self.rotalyze_obj.percent_outliers
self.cbetadev_obj = cbetadev(
pdb_hierarchy = pdb_hierarchy,
outliers_only = True,
out = null_out())
self.c_beta_dev = self.cbetadev_obj.get_outlier_count()
self.clashscore = clashscore(pdb_hierarchy=pdb_hierarchy).get_clashscore()
self.mpscore = molprobity_score(
clashscore = self.clashscore,
rota_out = self.rotamer_outliers,
rama_fav = self.ramachandran_favored)
self.omglz = omegalyze.omegalyze(
pdb_hierarchy=self.pdb_hierarchy, quiet=True)
self.n_cis_proline = self.omglz.n_cis_proline()
self.n_cis_general = self.omglz.n_cis_general()
self.n_twisted_proline = self.omglz.n_twisted_proline()
self.n_twisted_general = self.omglz.n_twisted_general()
def exercise_omegalyze():
regression_pdb = libtbx.env.find_in_repositories(
relative_path="phenix_regression/pdb/2hr0.pdb",
test=os.path.isfile)
if (regression_pdb is None):
print "Skipping exercise_omegalyze(): input pdb (2hr0.pdb) not available"
return
#-----
pdb_io = pdb.input(regression_pdb)
pdbid = os.path.basename(regression_pdb)
hierarchy = pdb_io.construct_hierarchy()
text_test = omegalyze_test_string()
outliers = omegalyze.omegalyze(
pdb_hierarchy=hierarchy,
nontrans_only=True,
out=text_test,
quiet=False)
outliers.show_old_output(out=text_test, verbose=True)
assert not show_diff(text_test.output , ref_omegalyze_give_text)
def exercise_omegalyze():
regression_pdb = libtbx.env.find_in_repositories(
relative_path="phenix_regression/pdb/2hr0.pdb",
test=os.path.isfile)
if (regression_pdb is None):
print "Skipping exercise_omegalyze(): input pdb (2hr0.pdb) not available"
return
#-----
pdb_io = pdb.input(regression_pdb)
pdbid = os.path.basename(regression_pdb)
hierarchy = pdb_io.construct_hierarchy()
text_test = omegalyze_test_string()
outliers = omegalyze.omegalyze(
pdb_hierarchy=hierarchy,
nontrans_only="True",
out=text_test,
quiet=False)
outliers.show_old_output(out=text_test, verbose=True)
assert not show_diff(text_test.output , ref_omegalyze_give_text)
def __init__(self,
pdb_hierarchy,
xray_structure=None,
fmodel=None,
fmodel_neutron=None,
geometry_restraints_manager=None,
crystal_symmetry=None,
sequences=None,
flags=None,
header_info=None,
raw_data=None,
unmerged_data=None,
all_chain_proxies=None,
keep_hydrogens=True,
nuclear=False,
save_probe_unformatted_file=None,
show_hydrogen_outliers=False,
min_cc_two_fofc=0.8,
n_bins_data=10,
count_anomalous_pairs_separately=False,
use_internal_variance=True,
outliers_only=True,
use_pdb_header_resolution_cutoffs=False,
file_name=None,
ligand_selection=None,
rotamer_library="8000",
map_params=None):
assert rotamer_library == "8000", "data_version given to RotamerEval not recognized."
for name in self.__slots__:
setattr(self, name, None)
# very important - the i_seq attributes may be extracted later
pdb_hierarchy.atoms().reset_i_seq()
self.pdb_hierarchy = pdb_hierarchy
if (xray_structure is None):
if (fmodel is not None):
xray_structure = fmodel.xray_structure
elif (crystal_symmetry is not None):
xray_structure = pdb_hierarchy.extract_xray_structure(
crystal_symmetry=crystal_symmetry)
self.crystal_symmetry = crystal_symmetry
if (crystal_symmetry is None) and (fmodel is not None):
self.crystal_symmetry = fmodel.f_obs().crystal_symmetry()
self.header_info = header_info
if (flags is None):
flags = molprobity_flags()
if pdb_hierarchy.contains_protein():
self.find_missing_atoms(out=null_out())
if (flags.ramalyze):
self.ramalyze = ramalyze.ramalyze(pdb_hierarchy=pdb_hierarchy,
outliers_only=outliers_only,
out=null_out(),
quiet=True)
##### omegalyze ################################################################
if (flags.omegalyze):
self.omegalyze = omegalyze.omegalyze(
pdb_hierarchy=pdb_hierarchy,
nontrans_only=outliers_only,
out=null_out(),
quiet=True)
##### omegalyze ################################################################
if (flags.rotalyze):
self.rotalyze = rotalyze.rotalyze(pdb_hierarchy=pdb_hierarchy,
data_version=rotamer_library,
outliers_only=outliers_only,
out=null_out(),
quiet=True)
if (flags.cbetadev):
self.cbetadev = cbetadev.cbetadev(pdb_hierarchy=pdb_hierarchy,
outliers_only=outliers_only,
out=null_out(),
quiet=True)
if (flags.nqh):
self.nqh_flips = clashscore.nqh_flips(
pdb_hierarchy=pdb_hierarchy)
if (pdb_hierarchy.contains_rna() and flags.rna
and libtbx.env.has_module(name="suitename")):
if (geometry_restraints_manager is not None):
self.rna = rna_validate.rna_validation(
pdb_hierarchy=pdb_hierarchy,
geometry_restraints_manager=geometry_restraints_manager,
outliers_only=outliers_only,
params=None)
if (flags.clashscore):
self.clashes = clashscore.clashscore(
pdb_hierarchy=pdb_hierarchy,
save_probe_unformatted_file=save_probe_unformatted_file,
nuclear=nuclear,
keep_hydrogens=keep_hydrogens,
out=null_out(),
verbose=False)
if (flags.model_stats) and (xray_structure is not None):
self.model_stats = model_properties.model_statistics(
pdb_hierarchy=pdb_hierarchy,
xray_structure=xray_structure,
all_chain_proxies=all_chain_proxies,
ignore_hd=(not nuclear),
ligand_selection=ligand_selection)
if (geometry_restraints_manager is not None) and (flags.restraints):
assert (xray_structure is not None)
self.restraints = restraints.combined(
pdb_hierarchy=pdb_hierarchy,
xray_structure=xray_structure,
geometry_restraints_manager=geometry_restraints_manager,
ignore_hd=(not nuclear),
cdl=getattr(all_chain_proxies, "use_cdl", None))
if (sequences is not None) and (flags.seq):
self.sequence = sequence.validation(
pdb_hierarchy=pdb_hierarchy,
sequences=sequences,
log=null_out(),
include_secondary_structure=True,
extract_coordinates=True)
# use maps (fmodel is not used)
use_maps = False
if (map_params is not None):
use_maps = ((map_params.input.maps.map_file_name) or
((map_params.input.maps.map_coefficients_file_name) and
(map_params.input.maps.map_coefficients_label)))
if (use_maps):
if (flags.real_space):
self.real_space = experimental.real_space(
fmodel=None,
pdb_hierarchy=pdb_hierarchy,
cc_min=min_cc_two_fofc,
molprobity_map_params=map_params.input.maps)
if (flags.waters):
self.waters = waters.waters(
pdb_hierarchy=pdb_hierarchy,
xray_structure=xray_structure,
fmodel=None,
collect_all=True,
molprobity_map_params=map_params.input.maps)
if (fmodel is not None):
if (use_pdb_header_resolution_cutoffs) and (header_info
is not None):
fmodel = fmodel.resolution_filter(d_min=header_info.d_min,
d_max=header_info.d_max)
if (flags.rfactors):
self.data_stats = experimental.data_statistics(
fmodel,
raw_data=raw_data,
n_bins=n_bins_data,
count_anomalous_pairs_separately=
count_anomalous_pairs_separately)
if (not use_maps): # if maps are used, keep previous results
if (flags.real_space):
self.real_space = experimental.real_space(
fmodel=fmodel,
pdb_hierarchy=pdb_hierarchy,
cc_min=min_cc_two_fofc)
if (flags.waters):
self.waters = waters.waters(pdb_hierarchy=pdb_hierarchy,
xray_structure=xray_structure,
fmodel=fmodel,
collect_all=True)
if (unmerged_data is not None):
self.merging = experimental.merging_and_model_statistics(
f_obs=fmodel.f_obs(),
f_model=fmodel.f_model(),
r_free_flags=fmodel.r_free_flags(),
unmerged_i_obs=unmerged_data,
anomalous=count_anomalous_pairs_separately,
use_internal_variance=use_internal_variance,
n_bins=n_bins_data)
if (flags.xtriage):
import mmtbx.scaling.xtriage
f_model = abs(
fmodel.f_model()).set_observation_type_xray_amplitude()
if (raw_data is not None):
f_model, obs = f_model.common_sets(other=raw_data)
else:
obs = fmodel.f_obs()
self.xtriage = mmtbx.scaling.xtriage.xtriage_analyses(
miller_obs=obs,
miller_calc=f_model,
unmerged_obs=unmerged_data, # XXX some redundancy here...
text_out=null_out())
if (fmodel_neutron is not None) and (flags.rfactors):
self.neutron_stats = experimental.data_statistics(
fmodel_neutron,
n_bins=n_bins_data,
count_anomalous_pairs_separately=False)
if (pdb_hierarchy.models_size() == 1):
self._multi_criterion = multi_criterion_view(pdb_hierarchy)
def get_model_stat(file_name):
pdb_inp = iotbx.pdb.input(file_name=file_name)
atoms = pdb_inp.atoms()
box = uctbx.non_crystallographic_unit_cell_with_the_sites_in_its_center(
sites_cart=atoms.extract_xyz(), buffer_layer=5)
atoms.set_xyz(new_xyz=box.sites_cart)
ph = pdb_inp.construct_hierarchy()
if (all_single_atom_residues(ph=ph)): return None
raw_recs = ph.as_pdb_string(
crystal_symmetry=box.crystal_symmetry()).splitlines()
#
params = monomer_library.pdb_interpretation.master_params.extract()
params.clash_guard.nonbonded_distance_threshold = None
params.disable_uc_volume_vs_n_atoms_check = False
params.use_neutron_distances = True
params.restraints_library.cdl = False
processed_pdb_file = monomer_library.pdb_interpretation.process(
mon_lib_srv=mon_lib_srv,
ener_lib=ener_lib,
raw_records=raw_recs,
params=params,
log=null_out())
xrs = processed_pdb_file.xray_structure()
sctr_keys = xrs.scattering_type_registry().type_count_dict().keys()
has_hd = "H" in sctr_keys or "D" in sctr_keys
restraints_manager = processed_pdb_file.geometry_restraints_manager(
show_energies=False,
assume_hydrogens_all_missing=not has_hd,
plain_pairs_radius=5.0)
a_mean, b_mean = get_bonds_angles_rmsd(
restraints_manager=restraints_manager, xrs=xrs)
energies_sites = \
restraints_manager.energies_sites(
sites_cart = xrs.sites_cart(),
compute_gradients = False)
nonbonded_distances = energies_sites.nonbonded_distances()
number_of_worst_clashes = (nonbonded_distances < 0.5).count(True)
#
ramalyze_obj = ramalyze(pdb_hierarchy=ph, outliers_only=False)
ramachandran_outliers = ramalyze_obj.percent_outliers
rotamer_outliers = rotalyze(pdb_hierarchy=ph,
outliers_only=False).percent_outliers
c_beta_dev = cbetadev(pdb_hierarchy=ph, outliers_only=True,
out=null_out()).get_outlier_count()
omglz = omegalyze.omegalyze(pdb_hierarchy=ph, quiet=True)
n_cis_proline = omglz.n_cis_proline()
n_cis_general = omglz.n_cis_general()
n_twisted_proline = omglz.n_twisted_proline()
n_twisted_general = omglz.n_twisted_general()
#
clsc = clashscore(pdb_hierarchy=ph).get_clashscore()
mpscore = molprobity_score(clashscore=clsc,
rota_out=rotamer_outliers,
rama_fav=ramalyze_obj.percent_favored)
#
occ = atoms.extract_occ()
bs = atoms.extract_b()
#
return group_args(b_mean=b_mean,
a_mean=a_mean,
number_of_worst_clashes=number_of_worst_clashes,
ramachandran_outliers=ramachandran_outliers,
rotamer_outliers=rotamer_outliers,
c_beta_dev=c_beta_dev,
n_cis_proline=n_cis_proline,
n_cis_general=n_cis_general,
n_twisted_proline=n_twisted_proline,
n_twisted_general=n_twisted_general,
o=occ.min_max_mean().as_tuple(),
b=bs.min_max_mean().as_tuple(),
mpscore=mpscore,
clsc=clsc,
n_atoms=atoms.size())
def make_multikin(f, processed_pdb_file, pdbID=None, keep_hydrogens=False):
if pdbID == None:
pdbID = "PDB"
hierarchy = processed_pdb_file.all_chain_proxies.pdb_hierarchy
i_seq_name_hash = build_name_hash(pdb_hierarchy=hierarchy)
sites_cart=processed_pdb_file.all_chain_proxies.sites_cart
geometry = processed_pdb_file.geometry_restraints_manager()
flags = geometry_restraints.flags.flags(default=True)
angle_proxies = geometry.angle_proxies
pair_proxies = geometry.pair_proxies(flags=flags,
sites_cart=sites_cart)
bond_proxies = pair_proxies.bond_proxies
quick_bond_hash = {}
for bp in bond_proxies.simple:
if (i_seq_name_hash[bp.i_seqs[0]][9:14] ==
i_seq_name_hash[bp.i_seqs[1]][9:14]):
if quick_bond_hash.get(bp.i_seqs[0]) is None:
quick_bond_hash[bp.i_seqs[0]] = []
quick_bond_hash[bp.i_seqs[0]].append(bp.i_seqs[1])
kin_out = get_default_header()
altid_controls = get_altid_controls(hierarchy=hierarchy)
if altid_controls != "":
kin_out += altid_controls
kin_out += "@group {%s} dominant animate\n" % pdbID
initiated_chains = []
rot_outliers = rotalyze(pdb_hierarchy=hierarchy, outliers_only=True)
cb = cbetadev(
pdb_hierarchy=hierarchy,
outliers_only=True)
rama = ramalyze(pdb_hierarchy=hierarchy, outliers_only=True)
counter = 0
for model in hierarchy.models():
for chain in model.chains():
if chain.id not in initiated_chains:
kin_out += "@subgroup {%s} dominant master= {chain %s}\n" % (
pdbID,
chain.id)
initiated_chains.append(chain.id)
kin_out += get_kin_lots(chain=chain,
bond_hash=quick_bond_hash,
i_seq_name_hash=i_seq_name_hash,
pdbID=pdbID,
index=counter)
if (chain.is_protein()) :
kin_out += rotamer_outliers(chain=chain, pdbID=pdbID,
rot_outliers=rot_outliers)
kin_out += rama_outliers(chain=chain, pdbID=pdbID, ram_outliers=rama)
# TODO use central methods in mmtbx.validation.restraints
kin_out += get_angle_outliers(angle_proxies=angle_proxies,
chain=chain,
sites_cart=sites_cart,
hierarchy=hierarchy)
kin_out += get_bond_outliers(bond_proxies=bond_proxies,
chain=chain,
sites_cart=sites_cart,
hierarchy=hierarchy)
if (chain.is_protein()) :
kin_out += cbeta_dev(chain_id=chain.id,
outliers=cb.results)
kin_out += pperp_outliers(hierarchy=hierarchy,
chain=chain)
counter += 1
kin_out += omegalyze.omegalyze(pdb_hierarchy=hierarchy,nontrans_only=True,
out=None,quiet=False).as_kinemage()
kin_out += make_probe_dots(hierarchy=hierarchy, keep_hydrogens=keep_hydrogens)
kin_out += get_footer()
outfile = file(f, 'w')
for line in kin_out:
outfile.write(line)
outfile.close()
return f
def export_molprobity_result_as_kinemage (
result,
pdb_hierarchy,
geometry,
probe_file,
keep_hydrogens=False,
pdbID="PDB") :
assert (result.restraints is not None)
i_seq_name_hash = build_name_hash(pdb_hierarchy=pdb_hierarchy)
sites_cart = pdb_hierarchy.atoms().extract_xyz()
flags = geometry_restraints.flags.flags(default=True)
angle_proxies = geometry.angle_proxies
pair_proxies = geometry.pair_proxies(flags=flags,
sites_cart=sites_cart)
bond_proxies = pair_proxies.bond_proxies
quick_bond_hash = {}
for bp in bond_proxies.simple:
if (i_seq_name_hash[bp.i_seqs[0]][9:14] ==
i_seq_name_hash[bp.i_seqs[1]][9:14]):
if quick_bond_hash.get(bp.i_seqs[0]) is None:
quick_bond_hash[bp.i_seqs[0]] = []
quick_bond_hash[bp.i_seqs[0]].append(bp.i_seqs[1])
kin_out = get_default_header()
altid_controls = get_altid_controls(hierarchy=pdb_hierarchy)
if altid_controls != "":
kin_out += altid_controls
kin_out += "@group {%s} dominant animate\n" % pdbID
initiated_chains = []
counter = 0
for model in pdb_hierarchy.models():
for chain in model.chains():
if chain.id not in initiated_chains:
kin_out += "@subgroup {%s} dominant master= {chain %s}\n" % (
pdbID,
chain.id)
initiated_chains.append(chain.id)
kin_out += get_kin_lots(chain=chain,
bond_hash=quick_bond_hash,
i_seq_name_hash=i_seq_name_hash,
pdbID=pdbID,
index=counter)
if (chain.is_protein()) :
assert (not None in [result.rotalyze, result.ramalyze])
kin_out += rotamer_outliers(chain=chain,
pdbID=pdbID,
rot_outliers=result.rotalyze)
kin_out += rama_outliers(chain=chain,
pdbID=pdbID,
ram_outliers=result.ramalyze)
kin_out += result.restraints.as_kinemage(chain_id=chain.id)
if (chain.is_protein()) :
assert (result.cbetadev is not None)
kin_out += result.cbetadev.as_kinemage(chain_id=chain.id)
kin_out += pperp_outliers(hierarchy=pdb_hierarchy,
chain=chain)
counter += 1
kin_out += omegalyze.omegalyze(pdb_hierarchy=pdb_hierarchy,nontrans_only=True,
out=None,quiet=False).as_kinemage()
kin_out += make_probe_dots(hierarchy=pdb_hierarchy,
keep_hydrogens=keep_hydrogens)
kin_out += get_footer()
return kin_out
def __init__ (self,
pdb_hierarchy,
xray_structure=None,
fmodel=None,
fmodel_neutron=None,
geometry_restraints_manager=None,
crystal_symmetry=None,
sequences=None,
flags=None,
header_info=None,
raw_data=None,
unmerged_data=None,
all_chain_proxies=None,
keep_hydrogens=True,
nuclear=False,
save_probe_unformatted_file=None,
show_hydrogen_outliers=False,
min_cc_two_fofc=0.8,
n_bins_data=10,
count_anomalous_pairs_separately=False,
use_internal_variance=True,
outliers_only=True,
use_pdb_header_resolution_cutoffs=False,
file_name=None,
ligand_selection=None,
rotamer_library="8000",
map_params=None) :
assert rotamer_library == "8000", "data_version given to RotamerEval not recognized."
for name in self.__slots__ :
setattr(self, name, None)
# very important - the i_seq attributes may be extracted later
pdb_hierarchy.atoms().reset_i_seq()
self.pdb_hierarchy = pdb_hierarchy
if (xray_structure is None) :
if (fmodel is not None) :
xray_structure = fmodel.xray_structure
elif (crystal_symmetry is not None) :
xray_structure = pdb_hierarchy.extract_xray_structure(
crystal_symmetry=crystal_symmetry)
self.crystal_symmetry = crystal_symmetry
if (crystal_symmetry is None) and (fmodel is not None) :
self.crystal_symmetry = fmodel.f_obs().crystal_symmetry()
self.header_info = header_info
if (flags is None) :
flags = molprobity_flags()
if pdb_hierarchy.contains_protein() :
if (flags.ramalyze) :
self.ramalyze = ramalyze.ramalyze(
pdb_hierarchy=pdb_hierarchy,
outliers_only=outliers_only,
out=null_out(),
quiet=True)
##### omegalyze ################################################################
if (flags.omegalyze) :
self.omegalyze = omegalyze.omegalyze(
pdb_hierarchy=pdb_hierarchy,
nontrans_only=outliers_only,
out=null_out(),
quiet=True)
##### omegalyze ################################################################
if (flags.rotalyze) :
self.rotalyze = rotalyze.rotalyze(
pdb_hierarchy=pdb_hierarchy,
data_version=rotamer_library,
outliers_only=outliers_only,
out=null_out(),
quiet=True)
if (flags.cbetadev) :
self.cbetadev = cbetadev.cbetadev(
pdb_hierarchy=pdb_hierarchy,
outliers_only=outliers_only,
out=null_out(),
quiet=True)
if (flags.nqh) :
self.nqh_flips = clashscore.nqh_flips(
pdb_hierarchy=pdb_hierarchy)
if (pdb_hierarchy.contains_rna() and flags.rna and
libtbx.env.has_module(name="suitename")) :
if (geometry_restraints_manager is not None) :
self.rna = rna_validate.rna_validation(
pdb_hierarchy=pdb_hierarchy,
geometry_restraints_manager=geometry_restraints_manager,
outliers_only=outliers_only,
params=None)
if (flags.clashscore) :
self.clashes = clashscore.clashscore(
pdb_hierarchy=pdb_hierarchy,
save_probe_unformatted_file=save_probe_unformatted_file,
nuclear=nuclear,
keep_hydrogens=keep_hydrogens,
out=null_out(),
verbose=False)
if (flags.model_stats) and (xray_structure is not None) :
self.model_stats = model_properties.model_statistics(
pdb_hierarchy=pdb_hierarchy,
xray_structure=xray_structure,
all_chain_proxies=all_chain_proxies,
ignore_hd=(not nuclear),
ligand_selection=ligand_selection)
if (geometry_restraints_manager is not None) and (flags.restraints) :
assert (xray_structure is not None)
self.restraints = restraints.combined(
pdb_hierarchy=pdb_hierarchy,
xray_structure=xray_structure,
geometry_restraints_manager=geometry_restraints_manager,
ignore_hd=(not nuclear),
cdl=getattr(all_chain_proxies, "use_cdl", None))
if (sequences is not None) and (flags.seq) :
self.sequence = sequence.validation(
pdb_hierarchy=pdb_hierarchy,
sequences=sequences,
log=null_out(),
include_secondary_structure=True,
extract_coordinates=True)
# use maps (fmodel is not used)
use_maps = False
if (map_params is not None):
use_maps = ( (map_params.input.maps.map_file_name) or
( (map_params.input.maps.map_coefficients_file_name) and
(map_params.input.maps.map_coefficients_label) ) )
if (use_maps):
if (flags.real_space):
self.real_space = experimental.real_space(
fmodel=None,
pdb_hierarchy=pdb_hierarchy,
cc_min=min_cc_two_fofc,
molprobity_map_params=map_params.input.maps)
if (flags.waters):
self.waters = waters.waters(
pdb_hierarchy=pdb_hierarchy,
xray_structure=xray_structure,
fmodel=None,
collect_all=True,
molprobity_map_params=map_params.input.maps)
if (fmodel is not None) :
if (use_pdb_header_resolution_cutoffs) and (header_info is not None) :
fmodel = fmodel.resolution_filter(
d_min=header_info.d_min,
d_max=header_info.d_max)
if (flags.rfactors) :
self.data_stats = experimental.data_statistics(fmodel,
raw_data=raw_data,
n_bins=n_bins_data,
count_anomalous_pairs_separately=count_anomalous_pairs_separately)
if (not use_maps): # if maps are used, keep previous results
if (flags.real_space):
self.real_space = experimental.real_space(
fmodel=fmodel,
pdb_hierarchy=pdb_hierarchy,
cc_min=min_cc_two_fofc)
if (flags.waters) :
self.waters = waters.waters(
pdb_hierarchy=pdb_hierarchy,
xray_structure=xray_structure,
fmodel=fmodel,
collect_all=True)
if (unmerged_data is not None) :
self.merging = experimental.merging_and_model_statistics(
f_obs=fmodel.f_obs(),
f_model=fmodel.f_model(),
r_free_flags=fmodel.r_free_flags(),
unmerged_i_obs=unmerged_data,
anomalous=count_anomalous_pairs_separately,
use_internal_variance=use_internal_variance,
n_bins=n_bins_data)
if (flags.xtriage) :
import mmtbx.scaling.xtriage
f_model = abs(fmodel.f_model()).set_observation_type_xray_amplitude()
if (raw_data is not None) :
f_model, obs = f_model.common_sets(other=raw_data)
else :
obs = fmodel.f_obs()
self.xtriage = mmtbx.scaling.xtriage.xtriage_analyses(
miller_obs=obs,
miller_calc=f_model,
unmerged_obs=unmerged_data, # XXX some redundancy here...
text_out=null_out())
if (fmodel_neutron is not None) and (flags.rfactors) :
self.neutron_stats = experimental.data_statistics(fmodel_neutron,
n_bins=n_bins_data,
count_anomalous_pairs_separately=False)
if (pdb_hierarchy.models_size() == 1) :
self._multi_criterion = multi_criterion_view(pdb_hierarchy)
def __init__(
self,
pdb_hierarchy,
molprobity_scores=False,
):
""" This class is being pickled. Try not to introduce huge members, e.g.
self.hierarchy, etc. This is the reason ramalyze_obj, rotalyze_obj etc
are not members of the class (not self.ramalyze_obj). """
self.clashscore = None
self.ramachandran_outliers = None
self.ramachandran_allowed = None
self.ramachandran_favored = None
self.rotamer_outliers = None
self.c_beta_dev = None
self.mpscore = None
self.omglz = None
self.n_cis_proline = None
self.n_cis_general = None
self.n_twisted_proline = None
self.n_twisted_general = None
if(molprobity_scores):
ramalyze_obj = ramalyze(pdb_hierarchy=pdb_hierarchy, outliers_only=False)
self.ramachandran_outliers = ramalyze_obj.percent_outliers
self.ramachandran_outliers_cf = ramalyze_obj.get_outliers_count_and_fraction()
self.ramachandran_allowed = ramalyze_obj.percent_allowed
self.ramachandran_allowed_cf = ramalyze_obj.get_allowed_count_and_fraction()
self.ramachandran_favored = ramalyze_obj.percent_favored
self.ramachandran_favored_cf = ramalyze_obj.get_favored_count_and_fraction()
rotalyze_obj = rotalyze(pdb_hierarchy=pdb_hierarchy, outliers_only=False)
self.rotamer_outliers = rotalyze_obj.percent_outliers
self.rotamer_cf = rotalyze_obj.get_outliers_count_and_fraction()
cbetadev_obj = cbetadev(
pdb_hierarchy = pdb_hierarchy,
outliers_only = True,
out = null_out())
self.c_beta_dev = cbetadev_obj.get_outlier_count()
self.c_beta_dev_percent = cbetadev_obj.get_weighted_outlier_percent()
self.clashscore = clashscore(pdb_hierarchy=pdb_hierarchy).get_clashscore()
self.mpscore = molprobity_score(
clashscore = self.clashscore,
rota_out = self.rotamer_outliers,
rama_fav = self.ramachandran_favored)
omglz = omegalyze.omegalyze(
pdb_hierarchy=pdb_hierarchy, quiet=True)
self.n_proline = omglz.n_proline()
self.n_general = omglz.n_general()
self.n_cis_proline = omglz.n_cis_proline()
self.n_cis_general = omglz.n_cis_general()
self.n_twisted_proline = omglz.n_twisted_proline()
self.n_twisted_general = omglz.n_twisted_general()
self.cis_general = 0
self.twisted_general = 0
self.cis_proline = 0
self.twisted_proline = 0
if self.n_proline != 0:
self.cis_proline = self.n_cis_proline*100./self.n_proline
self.twisted_proline = self.n_twisted_proline*100./self.n_proline
if self.n_general != 0:
self.cis_general = self.n_cis_general*100./self.n_general
self.twisted_general = self.n_twisted_general*100./self.n_general
self.cablam_outliers=None
self.cablam_disfavored=None
self.cablam_ca_outliers=None
try:
cablam_results = cablam.cablamalyze(pdb_hierarchy, outliers_only=False,
out=null_out(), quiet=True)
self.cablam_outliers = cablam_results.percent_outliers()
self.cablam_disfavored = cablam_results.percent_disfavored()
self.cablam_ca_outliers = cablam_results.percent_ca_outliers()
except Exception as e:
print "CaBLAM failed with exception:"
print " %s" % str(e)
pass
