def __init__(self, pdb_hierarchy): re_flip = re.compile(":FLIP") validation.__init__(self) in_lines = pdb_hierarchy.as_pdb_string() reduce_out = run_reduce_with_timeout( parameters="-BUILD -", stdin_lines=in_lines) check_and_report_reduce_failure( fb_object=reduce_out, input_lines=in_lines, output_fname="reduce_fail.pdb") from mmtbx.validation import utils use_segids = utils.use_segids_in_place_of_chainids( hierarchy=pdb_hierarchy) for line in reduce_out.stdout_lines: #chain format (2-char chain) #USER MOD Set 1.1: B 49 GLN :FLIP amide:sc= -2.7! C(o=-5.8!,f=-1.3!) #segid format (4-char segid) #USER MOD Set 1.1:B 49 GLN :FLIP amide:sc= -2.7! C(o=-5.8!,f=-1.3!) if re_flip.search(line): resid = line.split(":")[1] #reduce has slightly different outputs using chains versus segid if len(resid) == 15: #chain chain_id = resid[0:2].strip() segid = None if (len(chain_id) == 0): chain_id = ' ' resid_less_chain = resid[2:] elif len(resid) == 17: #segid #self.results = [] #return chain_id = None segid = resid[0:4].strip() #chain_id = resid[0:4].strip() resid_less_chain = resid[4:] else: raise Sorry("unexpected length of residue identifier in reduce USER MODs.") resname = resid_less_chain[5:8] assert (resname in ["ASN", "GLN", "HIS"]) flip = nqh_flip( chain_id=chain_id, segid=segid, resseq=resid_less_chain[0:4].strip(), icode= resid_less_chain[4:5], altloc=resid_less_chain[12:13], resname=resname, outlier=True) flip.set_coordinates_from_hierarchy(pdb_hierarchy) self.results.append(flip) self.n_outliers += 1
def __init__ (self, pdb_hierarchy, outliers_only=False, show_errors=False, out=sys.stdout, quiet=False) : # Optimization hint: make it possible to pass # ramachandran_eval.RamachandranEval() from outside. # Better - convert this to using mmtbx.model.manager where # RamachandranEval is already available. validation.__init__(self) self.n_allowed = 0 self.n_favored = 0 self.n_type = [ 0 ] * 6 self._outlier_i_seqs = flex.size_t() pdb_atoms = pdb_hierarchy.atoms() all_i_seqs = pdb_atoms.extract_i_seq() if (all_i_seqs.all_eq(0)) : pdb_atoms.reset_i_seq() use_segids = utils.use_segids_in_place_of_chainids( hierarchy=pdb_hierarchy) analysis = "" output_list = [] count_keys = [] uniqueness_keys = [] r = ramachandran_eval.RamachandranEval() ##if use_segids: ## chain_id = utils.get_segid_as_chainid(chain=chain) ## else: ## chain_id = chain.id for three in generate_protein_threes(hierarchy=pdb_hierarchy, geometry=None): main_residue = three[1] phi_psi_atoms = three.get_phi_psi_atoms() if phi_psi_atoms is None: continue phi_atoms, psi_atoms = phi_psi_atoms phi = get_dihedral(phi_atoms) psi = get_dihedral(psi_atoms) coords = get_center(main_residue) #should find the CA of the center residue if (phi is not None and psi is not None): res_type = RAMA_GENERAL #self.n_total += 1 if (main_residue.resname[0:3] == "GLY"): res_type = RAMA_GLYCINE elif (main_residue.resname[0:3] == "PRO"): is_cis = is_cis_peptide(three) if is_cis: res_type = RAMA_CISPRO else: res_type = RAMA_TRANSPRO elif (three[2].resname == "PRO"): res_type = RAMA_PREPRO elif (main_residue.resname[0:3] == "ILE" or \ main_residue.resname[0:3] == "VAL"): res_type = RAMA_ILE_VAL #self.n_type[res_type] += 1 value = r.evaluate(res_types[res_type], [phi, psi]) ramaType = self.evaluateScore(res_type, value) is_outlier = ramaType == RAMALYZE_OUTLIER c_alphas = None # XXX only save kinemage data for outliers if is_outlier : c_alphas = get_cas_from_three(three) assert (len(c_alphas) == 3) markup = self.as_markup_for_kinemage(c_alphas) else: markup = None result = ramachandran( model_id=main_residue.parent().parent().parent().id, chain_id=main_residue.parent().parent().id, resseq=main_residue.resseq, icode=main_residue.icode, resname=main_residue.resname, #altloc=main_residue.parent().altloc, altloc=get_altloc_from_three(three), segid=None, # XXX ??? phi=phi, psi=psi, rama_type=ramaType, res_type=res_type, score=value*100, outlier=is_outlier, xyz=coords, markup=markup) #if result.chain_id+result.resseq+result.icode not in count_keys: result_key = result.model_id+result.chain_id+result.resseq+result.icode if result.altloc in ['','A'] and result_key not in count_keys: self.n_total += 1 self.n_type[res_type] += 1 self.add_to_validation_counts(ramaType) count_keys.append(result_key) if (not outliers_only or is_outlier) : if (result.altloc != '' or result_key not in uniqueness_keys): #the threes/conformers method results in some redundant result # calculations in structures with alternates. Using the # uniqueness_keys list prevents redundant results being added to # the final list self.results.append(result) uniqueness_keys.append(result_key) if is_outlier : i_seqs = main_residue.atoms().extract_i_seq() assert (not i_seqs.all_eq(0)) self._outlier_i_seqs.extend(i_seqs) self.results.sort(key=lambda r: r.model_id+r.id_str()) out_count, out_percent = self.get_outliers_count_and_fraction() fav_count, fav_percent = self.get_favored_count_and_fraction() self.out_percent = out_percent * 100.0 self.fav_percent = fav_percent * 100.0
def __init__(self, pdb_hierarchy, keep_hydrogens=True, nuclear=False, force_unique_chain_ids=False, time_limit=120, b_factor_cutoff=None, save_modified_hierarchy=False, verbose=False, do_flips=False, out=sys.stdout): validation.__init__(self) self.b_factor_cutoff = b_factor_cutoff self.clashscore = None self.clashscore_b_cutoff = None self.clash_dict = {} self.clash_dict_b_cutoff = {} self.list_dict = {} self.probe_file = None if (not libtbx.env.has_module(name="probe")): raise RuntimeError( "Probe could not be detected on your system. Please make sure " + "Probe is in your path.\nProbe is available at " + "http://kinemage.biochem.duke.edu/") if verbose: if not nuclear: print "\nUsing electron cloud x-H distances and vdW radii" else: print "\nUsing nuclear cloud x-H distances and vdW radii" import iotbx.pdb.hierarchy from scitbx.array_family import flex from mmtbx.validation import utils n_models = len(pdb_hierarchy.models()) use_segids = utils.use_segids_in_place_of_chainids( hierarchy=pdb_hierarchy) for i_mod, model in enumerate(pdb_hierarchy.models()): input_str, _ = check_and_add_hydrogen( pdb_hierarchy=pdb_hierarchy, model_number=i_mod, nuclear=nuclear, verbose=verbose, time_limit=time_limit, keep_hydrogens=keep_hydrogens, do_flips=do_flips, log=out) r = iotbx.pdb.hierarchy.root() mdc = model.detached_copy() r.append_model(mdc) occ_max = flex.max(r.atoms().extract_occ()) self.probe_clashscore_manager = probe_clashscore_manager( h_pdb_string=input_str, nuclear=nuclear, largest_occupancy=occ_max, b_factor_cutoff=b_factor_cutoff, use_segids=use_segids, verbose=verbose) if (save_modified_hierarchy): self.pdb_hierarchy = iotbx.pdb.hierarchy.input( pdb_string=self.probe_clashscore_manager.h_pdb_string ).hierarchy self.clash_dict[ model.id] = self.probe_clashscore_manager.clashscore self.clash_dict_b_cutoff[model.id] = self.probe_clashscore_manager.\ clashscore_b_cutoff self.list_dict[ model.id] = self.probe_clashscore_manager.bad_clashes if (n_models == 1) or (self.clashscore is None): self.results = self.probe_clashscore_manager.bad_clashes self.n_outliers = len(self.results) self.clashscore = self.probe_clashscore_manager.clashscore self.clashscore_b_cutoff = self.probe_clashscore_manager.\ clashscore_b_cutoff
def __init__(self, pdb_hierarchy, nontrans_only=False, out=sys.stdout, quiet=True): validation.__init__(self) self.residue_count = [0, 0] #[OMEGA_GENERAL, OMEGA_PRO] self.omega_count = [[0,0,0], [0,0,0]] #[OMEGA_GENERAL, OMEGA_PRO], then #[OMEGALYZE_TRANS, OMEGALYZE_CIS, OMEGALYZE_TWISTED] from mmtbx.validation import utils from scitbx.array_family import flex self._outlier_i_seqs = flex.size_t() pdb_atoms = pdb_hierarchy.atoms() all_i_seqs = pdb_atoms.extract_i_seq() if all_i_seqs.all_eq(0): pdb_atoms.reset_i_seq() use_segids = utils.use_segids_in_place_of_chainids( hierarchy=pdb_hierarchy) prev_rezes, next_rezes = None, None prev_resid = None cur_resseq = None next_resseq = None for model in pdb_hierarchy.models(): for chain in model.chains(): prev_rezes, next_rezes = None, None prev_resid = None cur_resseq = None next_resseq = None if use_segids: chain_id = utils.get_segid_as_chainid(chain=chain) else: chain_id = chain.id residues = list(chain.residue_groups()) for i, residue_group in enumerate(residues): # The reason I pass lists of atom_groups to get_phi and get_psi is to # deal with the particular issue where some residues have an A alt # conf that needs some atoms from a "" alt conf to get calculated # correctly. See 1jxt.pdb for examples. This way I can search both # the alt conf atoms and the "" atoms if necessary. prev_atom_list, next_atom_list, atom_list = None, None, None if cur_resseq is not None: prev_rezes = rezes prev_resseq = cur_resseq rezes = construct_residues(residues[i]) cur_resseq = residue_group.resseq_as_int() cur_icode = residue_group.icode.strip() if (i > 0): #check for insertion codes if (cur_resseq == residues[i-1].resseq_as_int()) : if (cur_icode == '') and (residues[i-1].icode.strip() == '') : continue elif (cur_resseq != (residues[i-1].resseq_as_int())+1): continue for atom_group in residue_group.atom_groups(): alt_conf = atom_group.altloc if rezes is not None: atom_list = rezes.get(alt_conf) if prev_rezes is not None: prev_atom_list = prev_rezes.get(alt_conf) if (prev_atom_list is None): prev_keys = sorted(prev_rezes.keys()) prev_atom_list = prev_rezes.get(prev_keys[0]) omega=get_omega(prev_atom_list, atom_list) highest_mc_b = get_highest_mc_b(prev_atom_list, atom_list) if omega is not None: resname = atom_group.resname[0:3] coords = get_center(atom_group) if resname == "PRO": res_type = OMEGA_PRO else: res_type = OMEGA_GENERAL self.residue_count[res_type] += 1 omega_type = find_omega_type(omega) is_nontrans = False if omega_type == OMEGALYZE_CIS or omega_type == OMEGALYZE_TWISTED: self.n_outliers += 1 is_nontrans = True self.omega_count[res_type][omega_type] += 1 markup_atoms = [None, None, None, None] #for kinemage markup if is_nontrans: for a in prev_atom_list: if a is None: continue a_ = atom(pdb_atom=a) if a.name.strip() == "CA": markup_atoms[0] = kin_atom( id_str=a_.atom_group_id_str(),xyz=a_.xyz) elif a.name.strip() == "C": markup_atoms[1] = kin_atom( id_str=a_.atom_group_id_str(),xyz=a_.xyz) for a in atom_list: if a is None: continue a_ = atom(pdb_atom=a) if a.name.strip() == "N": markup_atoms[2] = kin_atom( id_str=a_.atom_group_id_str(),xyz=a_.xyz) elif a.name.strip() == "CA": markup_atoms[3] = kin_atom( id_str=a_.atom_group_id_str(),xyz=a_.xyz) #------------ #prevres=residues[i-1] #find prev res identities for printing prev_alts = [] prev_resnames = {} for ag in residues[i-1].atom_groups(): prev_alts.append(ag.altloc) prev_resnames[ag.altloc] = ag.resname if alt_conf in prev_alts: prev_altloc = alt_conf else: if len(prev_alts) > 1: prev_altloc = prev_alts[1] else: prev_altloc = prev_alts[0] prev_resname = prev_resnames[prev_altloc] #done finding prev res identities result = omega_result( chain_id=chain_id, resseq=residue_group.resseq, icode=residue_group.icode, resname=atom_group.resname, altloc=atom_group.altloc, prev_resseq=residues[i-1].resseq, prev_icode=residues[i-1].icode, prev_resname=prev_resname, prev_altloc=prev_altloc, segid=None, omega=omega, omega_type=omega_type, res_type=res_type, is_nontrans=is_nontrans, outlier=is_nontrans, highest_mc_b=highest_mc_b, xyz=coords, markup_atoms=markup_atoms) if is_nontrans or not nontrans_only: #(not nontrans_only or is_nontrans) self.results.append(result) if is_nontrans: i_seqs = atom_group.atoms().extract_i_seq() assert (not i_seqs.all_eq(0)) #This assert copied from ramalyze self._outlier_i_seqs.extend(i_seqs)
def __init__(self, pdb_hierarchy, data_version="8000", outliers_only=False, show_errors=False, out=sys.stdout, quiet=False): validation.__init__(self) self.n_allowed = 0 self.n_favored = 0 from mmtbx.rotamer.sidechain_angles import SidechainAngles from mmtbx.rotamer import rotamer_eval from mmtbx.rotamer.rotamer_eval import RotamerID from mmtbx.validation import utils self.data_version = data_version # if self.data_version == "500": self.outlier_threshold = 0.01 if self.data_version == "8000": self.outlier_threshold = OUTLIER_THRESHOLD else: raise ValueError( "data_version given to RotamerEval not recognized (%s)." % data_version) sidechain_angles = SidechainAngles(show_errors) rotamer_evaluator = rotamer_eval.RotamerEval( data_version=data_version) rotamer_id = rotamer_eval.RotamerID() # loads in the rotamer names use_segids = utils.use_segids_in_place_of_chainids( hierarchy=pdb_hierarchy) current_rotamers = {} for model in pdb_hierarchy.models(): for chain in model.chains(): if use_segids: chain_id = utils.get_segid_as_chainid(chain=chain) else: chain_id = chain.id for rg in chain.residue_groups(): all_dict = construct_complete_sidechain(rg) for atom_group in rg.atom_groups(): coords = get_center(atom_group) resname = atom_group.resname occupancy = get_occupancy(atom_group) kwargs = { "chain_id" : chain_id, "resseq" : rg.resseq, "icode" : rg.icode, "altloc" : atom_group.altloc, "resname" : resname, "xyz" : coords, "occupancy" : occupancy, } atom_dict = all_dict.get(atom_group.altloc) res_key = get_residue_key(atom_group=atom_group) try: chis = sidechain_angles.measureChiAngles( atom_group, atom_dict)#.get(conformer.altloc)) except AttributeError: if show_errors: kwargs['incomplete'] = True result = rotamer(**kwargs) print >> out, '%s is missing some sidechain atoms' % \ result.id_str() self.results.append(result) continue if (chis is not None): if None in chis: continue cur_res = resname.lower().strip() if cur_res == 'mse': cur_res = 'met' value = rotamer_evaluator.evaluate(cur_res, chis) if value is not None: self.n_total += 1 kwargs['score'] = value * 100 wrap_chis = rotamer_id.wrap_chis(resname.strip(), chis, symmetry=False) sym_chis = wrap_chis[:] sym_chis = rotamer_id.wrap_sym(resname.strip(), sym_chis) evaluation = self.evaluateScore(value) kwargs['evaluation'] = evaluation if evaluation == "OUTLIER": kwargs['outlier'] = True kwargs['rotamer_name'] = evaluation else: kwargs['outlier'] = False kwargs['rotamer_name'] = rotamer_id.identify(resname, wrap_chis) #deal with unclassified rotamers if kwargs['rotamer_name'] == '': kwargs['rotamer_name'] = "UNCLASSIFIED" while (len(wrap_chis) < 4): wrap_chis.append(None) kwargs['chi_angles'] = wrap_chis result = rotamer(**kwargs) if (result.is_outlier()) or (not outliers_only): self.results.append(result) out_count, out_percent = self.get_outliers_count_and_fraction() self.out_percent = out_percent * 100.0
def __init__(self, pdb_hierarchy, nontrans_only=False, out=sys.stdout, quiet=True): validation.__init__(self) self.residue_count = [0, 0] #[OMEGA_GENERAL, OMEGA_PRO] self.omega_count = [[0,0,0], [0,0,0]] #[OMEGA_GENERAL, OMEGA_PRO], then #[OMEGALYZE_TRANS, OMEGALYZE_CIS, OMEGALYZE_TWISTED] from mmtbx.validation import utils from scitbx.array_family import flex self._outlier_i_seqs = flex.size_t() pdb_atoms = pdb_hierarchy.atoms() all_i_seqs = pdb_atoms.extract_i_seq() if all_i_seqs.all_eq(0): pdb_atoms.reset_i_seq() use_segids = utils.use_segids_in_place_of_chainids( hierarchy=pdb_hierarchy) prev_rezes, next_rezes = None, None prev_resid = None cur_resseq = None next_resseq = None for model in pdb_hierarchy.models(): for chain in model.chains(): prev_rezes, next_rezes = None, None prev_resid = None cur_resseq = None next_resseq = None if use_segids: chain_id = utils.get_segid_as_chainid(chain=chain) else: chain_id = chain.id residues = list(chain.residue_groups()) for i, residue_group in enumerate(residues): # The reason I pass lists of atom_groups to get_phi and get_psi is to # deal with the particular issue where some residues have an A alt # conf that needs some atoms from a "" alt conf to get calculated # correctly. See 1jxt.pdb for examples. This way I can search both # the alt conf atoms and the "" atoms if necessary. prev_atom_list, next_atom_list, atom_list = None, None, None if cur_resseq is not None: prev_rezes = rezes prev_resseq = cur_resseq rezes = construct_residues(residues[i]) cur_resseq = residue_group.resseq_as_int() cur_icode = residue_group.icode.strip() if (i > 0): #check for insertion codes if (cur_resseq == residues[i-1].resseq_as_int()) : if (cur_icode == '') and (residues[i-1].icode.strip() == '') : continue elif (cur_resseq != (residues[i-1].resseq_as_int())+1): continue for atom_group in residue_group.atom_groups(): alt_conf = atom_group.altloc if rezes is not None: atom_list = rezes.get(alt_conf) if prev_rezes is not None: prev_atom_list = prev_rezes.get(alt_conf) if (prev_atom_list is None): prev_keys = sorted(prev_rezes.keys()) prev_atom_list = prev_rezes.get(prev_keys[0]) omega=get_omega(prev_atom_list, atom_list) highest_mc_b = get_highest_mc_b(prev_atom_list, atom_list) if omega is not None: resname = atom_group.resname[0:3] coords = get_center(atom_group) if resname == "PRO": res_type = OMEGA_PRO else: res_type = OMEGA_GENERAL self.residue_count[res_type] += 1 omega_type = find_omega_type(omega) is_nontrans = False if omega_type == OMEGALYZE_CIS or omega_type == OMEGALYZE_TWISTED: self.n_outliers += 1 is_nontrans = True self.omega_count[res_type][omega_type] += 1 markup_atoms = [None, None, None, None] #for kinemage markup if is_nontrans: for a in prev_atom_list: if a is None: continue a_ = atom(pdb_atom=a) if a.name.strip() == "CA": markup_atoms[0] = kin_atom( id_str=a_.atom_group_id_str(),xyz=a_.xyz) elif a.name.strip() == "C": markup_atoms[1] = kin_atom( id_str=a_.atom_group_id_str(),xyz=a_.xyz) for a in atom_list: if a is None: continue a_ = atom(pdb_atom=a) if a.name.strip() == "N": markup_atoms[2] = kin_atom( id_str=a_.atom_group_id_str(),xyz=a_.xyz) elif a.name.strip() == "CA": markup_atoms[3] = kin_atom( id_str=a_.atom_group_id_str(),xyz=a_.xyz) #------------ #prevres=residues[i-1] #find prev res identities for printing prev_alts = [] prev_resnames = {} for ag in residues[i-1].atom_groups(): prev_alts.append(ag.altloc) prev_resnames[ag.altloc] = ag.resname if alt_conf in prev_alts: prev_altloc = alt_conf else: if len(prev_alts) > 1: prev_altloc = prev_alts[1] else: prev_altloc = prev_alts[0] prev_resname = prev_resnames[prev_altloc] #done finding prev res identities result = omega_result( chain_id=chain_id, resseq=residue_group.resseq, icode=residue_group.icode, resname=atom_group.resname, altloc=atom_group.altloc, prev_resseq=residues[i-1].resseq, prev_icode=residues[i-1].icode, prev_resname=prev_resname, prev_altloc=prev_altloc, segid=None, omega=omega, omega_type=omega_type, res_type=res_type, is_nontrans=is_nontrans, outlier=is_nontrans, highest_mc_b=highest_mc_b, xyz=coords, markup_atoms=markup_atoms) if is_nontrans or not nontrans_only: #(not nontrans_only or is_nontrans) self.results.append(result) if is_nontrans: i_seqs = atom_group.atoms().extract_i_seq() assert (not i_seqs.all_eq(0)) #This assert copied from ramalyze self._outlier_i_seqs.extend(i_seqs)
def __init__(self, pdb_hierarchy, nontrans_only=False, out=sys.stdout, quiet=True): validation.__init__(self) self.residue_count = [0, 0] #[OMEGA_GENERAL, OMEGA_PRO] self.omega_count = [[0, 0, 0], [0, 0, 0]] #[OMEGA_GENERAL, OMEGA_PRO], then #[OMEGALYZE_TRANS, OMEGALYZE_CIS, OMEGALYZE_TWISTED] from mmtbx.validation import utils from scitbx.array_family import flex self._outlier_i_seqs = flex.size_t() pdb_atoms = pdb_hierarchy.atoms() all_i_seqs = pdb_atoms.extract_i_seq() if all_i_seqs.all_eq(0): pdb_atoms.reset_i_seq() use_segids = utils.use_segids_in_place_of_chainids( hierarchy=pdb_hierarchy) first_conf_altloc = None prev_chain_id = None for twores in generate_protein_fragments( pdb_hierarchy, length=2, geometry=None, include_non_standard_peptides=True): main_residue = twores[ 1] #this is the relevant residue for id-ing cis-Pro conf_altloc = get_conformer_altloc(twores) prevres_altloc, mainres_altloc = get_local_omega_altlocs(twores) twores_altloc = prevres_altloc or mainres_altloc #default '' evals False chain = main_residue.parent().parent() if use_segids: chain_id = utils.get_segid_as_chainid(chain=chain) else: chain_id = chain.id if chain_id != prev_chain_id: #if we've moved to a new chain... first_conf_altloc = conf_altloc #...reset reference altloc prev_chain_id = chain_id if (conf_altloc != first_conf_altloc) and twores_altloc == '': #skip non-alternate residues unless this is the first time thru a chain continue omega_atoms = get_omega_atoms(twores) #omega_atoms is the list [CA1 C1 N2 CA2], with None for missing atoms if None in omega_atoms: continue omega = get_omega(omega_atoms) if omega is None: continue omega_type = find_omega_type(omega) if omega_type == OMEGALYZE_TRANS: is_nontrans = False else: is_nontrans = True self.n_outliers += 1 if main_residue.resname == "PRO": res_type = OMEGA_PRO else: res_type = OMEGA_GENERAL self.residue_count[res_type] += 1 self.omega_count[res_type][omega_type] += 1 highest_mc_b = get_highest_mc_b(twores[0].atoms(), twores[1].atoms()) coords = get_center(main_residue) markup_atoms = [] for omega_atom in omega_atoms: markup_atoms.append( kin_atom(omega_atom.parent().id_str(), omega_atom.xyz)) result = omega_result( model_id=twores[0].parent().parent().parent().id, chain_id=chain_id, resseq=main_residue.resseq, icode=main_residue.icode, resname=main_residue.resname, altloc=mainres_altloc, prev_resseq=twores[0].resseq, prev_icode=twores[0].icode, prev_resname=twores[0].resname, prev_altloc=prevres_altloc, segid=None, omega=omega, omega_type=omega_type, res_type=res_type, is_nontrans=is_nontrans, outlier=is_nontrans, highest_mc_b=highest_mc_b, xyz=coords, markup_atoms=markup_atoms) if is_nontrans or not nontrans_only: #(not nontrans_only or is_nontrans) self.results.append(result) if is_nontrans: i_seqs = main_residue.atoms().extract_i_seq() assert (not i_seqs.all_eq(0) ) #This assert copied from ramalyze self._outlier_i_seqs.extend(i_seqs) self.results.sort(key=lambda x: x.model_id + ':' + x.id_str())
def __init__(self, pdb_hierarchy, outliers_only=False, out=sys.stdout, collect_ideal=False, quiet=False): validation.__init__(self) self._outlier_i_seqs = flex.size_t() self.beta_ideal = {} relevant_atom_names = { " CA ": None, " N ": None, " C ": None, " CB ": None } # FUTURE: set output_list = [] self.stats = group_args(n_results=0, n_weighted_results=0, n_weighted_outliers=0) from mmtbx.validation import utils use_segids = utils.use_segids_in_place_of_chainids( hierarchy=pdb_hierarchy) for model in pdb_hierarchy.models(): for chain in model.chains(): if use_segids: chain_id = utils.get_segid_as_chainid(chain=chain) else: chain_id = chain.id for rg in chain.residue_groups(): for i_cf, cf in enumerate(rg.conformers()): for i_residue, residue in enumerate(cf.residues()): if (residue.resname == "GLY"): continue is_first = (i_cf == 0) is_alt_conf = False relevant_atoms = {} for atom in residue.atoms(): if (atom.name in relevant_atom_names): relevant_atoms[atom.name] = atom if (len(atom.parent().altloc) != 0): is_alt_conf = True if ((is_first or is_alt_conf) and len(relevant_atoms) == 4): result = calculate_ideal_and_deviation( relevant_atoms=relevant_atoms, resname=residue.resname) dev = result.deviation dihedralNABB = result.dihedral betaxyz = result.ideal if (dev is None): continue resCB = relevant_atoms[" CB "] self.stats.n_results += 1 self.stats.n_weighted_results += resCB.occ if (dev >= 0.25 or outliers_only == False): if (dev >= 0.25): self.n_outliers += 1 self.stats.n_weighted_outliers += resCB.occ self._outlier_i_seqs.append(atom.i_seq) if (is_alt_conf): altchar = cf.altloc else: altchar = " " res = residue.resname.lower() sub = chain.id if (len(sub) == 1): sub = " " + sub result = cbeta(chain_id=chain_id, resname=residue.resname, resseq=residue.resseq, icode=residue.icode, altloc=altchar, xyz=resCB.xyz, occupancy=resCB.occ, deviation=dev, dihedral_NABB=dihedralNABB, ideal_xyz=betaxyz, outlier=(dev >= 0.25)) self.results.append(result) key = result.id_str() if (collect_ideal): self.beta_ideal[key] = betaxyz
def run(args): """ I suggest adding here: cctbx_project/mmtbx/validation/regression/tst_mp_geo.py test cases with just .pdb, without arguments, etc. """ master_phil = get_master_phil() import iotbx.phil input_objects = iotbx.phil.process_command_line_with_files( args=args, master_phil=master_phil, pdb_file_def="mp_geo.pdb") work_params = input_objects.work.extract() assert len(work_params.mp_geo.pdb) == 1, "Need a model file to run" file_name = work_params.mp_geo.pdb[0] out_file = None if work_params.mp_geo.out_file != None: out_file = work_params.mp_geo.out_file do_bonds_and_angles = work_params.mp_geo.bonds_and_angles do_kinemage = work_params.mp_geo.kinemage do_rna_backbone = work_params.mp_geo.rna_backbone outliers_only = work_params.mp_geo.outliers_only use_cdl = work_params.mp_geo.cdl log = StringIO() basename = os.path.basename(file_name) if out_file == None: import sys out = sys.stdout else: if do_bonds_and_angles: out = file(out_file, 'w') elif do_kinemage: out = file(out_file, 'a') elif do_rna_backbone: out = file(out_file, 'w') restraints_loading_flags = {} restraints_loading_flags["use_neutron_distances"] = False from mmtbx.validation import utils params = pdb_interpretation.master_params.extract() params.restraints_library.cdl = use_cdl params.clash_guard.nonbonded_distance_threshold = None processed_pdb_file = pdb_interpretation.process( params=params, mon_lib_srv=server.server(), ener_lib=server.ener_lib(), file_name=file_name, strict_conflict_handling=True, restraints_loading_flags=restraints_loading_flags, force_symmetry=True, substitute_non_crystallographic_unit_cell_if_necessary=True, log=log) grm = processed_pdb_file.geometry_restraints_manager() use_segids = utils.use_segids_in_place_of_chainids( hierarchy=processed_pdb_file.all_chain_proxies.pdb_hierarchy) if do_bonds_and_angles or do_kinemage: rc = get_bond_and_angle_outliers( pdb_hierarchy=processed_pdb_file.all_chain_proxies.pdb_hierarchy, xray_structure=processed_pdb_file.xray_structure(), geometry_restraints_manager=grm, use_segids=use_segids, outliers_only=outliers_only) #get chain types chain_types = {} for chain in processed_pdb_file.all_chain_proxies.\ pdb_hierarchy.models()[0].chains(): if use_segids: chain_id = utils.get_segid_as_chainid(chain=chain) else: chain_id = chain.id main_conf = chain.conformers()[0] if chain_types.get(chain_id) not in ["NA", "PROTEIN"]: if (main_conf.is_na()): chain_types[chain_id] = "NA" elif (main_conf.is_protein()): chain_types[chain_id] = "PROTEIN" else: chain_types[chain_id] = "UNK" outliers = [] #bonds #for result in rc.bonds.results: for result in sorted( rc.bonds.results, key=lambda x: (x.atoms_info[0].resseq, get_altloc(atoms_info=x.atoms_info), get_atoms_str(atoms_info=x.atoms_info))): atom_info = result.atoms_info[0] # label:chain:number:ins:alt:type:measure:value:sigmas:class atoms_str = get_atoms_str(atoms_info=result.atoms_info) altloc = get_altloc(atoms_info=result.atoms_info) chain_id = atom_info.chain_id outliers.append([ chain_id, atom_info.resseq, atom_info.icode, altloc, atom_info.resname, atoms_str, result.model, result.score, chain_types[atom_info.chain_id] ]) #angles #for result in rc.angles.results: for result in sorted( rc.angles.results, key=lambda x: (x.atoms_info[0].resseq, get_altloc(atoms_info=x.atoms_info), get_atoms_str(atoms_info=x.atoms_info))): atom_info = result.atoms_info[0] # label:chain:number:ins:alt:type:measure:value:sigmas:class atoms_str = get_atoms_str(atoms_info=result.atoms_info) altloc = get_altloc(atoms_info=result.atoms_info) chain_id = atom_info.chain_id outliers.append([ chain_id, atom_info.resseq, atom_info.icode, altloc, atom_info.resname, atoms_str, result.model, result.score, chain_types[atom_info.chain_id] ]) if do_bonds_and_angles: for outlier in outliers: print >> out, "%s:%2s:%s:%s:%s:%s:%s:%.3f:%.3f:%s" % ( basename, outlier[0], outlier[1], outlier[2], outlier[3], outlier[4], outlier[5], outlier[6], outlier[7], outlier[8]) elif do_kinemage: print >> out, rc.bonds.kinemage_header for result in rc.bonds.results: print >> out, result.as_kinemage() print >> out, rc.angles.kinemage_header for result in rc.angles.results: print >> out, result.as_kinemage() out.close() elif do_rna_backbone: from mmtbx.validation import utils rna_bb = utils.get_rna_backbone_dihedrals(processed_pdb_file) print >> out, rna_bb if out_file is not None: out.close()
def __init__ (self, pdb_hierarchy, outliers_only=False, show_errors=False, out=sys.stdout, quiet=False) : validation.__init__(self) self.n_allowed = 0 self.n_favored = 0 self.n_type = [ 0 ] * 6 self._outlier_i_seqs = flex.size_t() pdb_atoms = pdb_hierarchy.atoms() all_i_seqs = pdb_atoms.extract_i_seq() if (all_i_seqs.all_eq(0)) : pdb_atoms.reset_i_seq() use_segids = utils.use_segids_in_place_of_chainids( hierarchy=pdb_hierarchy) analysis = "" output_list = [] count_keys = [] uniqueness_keys = [] r = ramachandran_eval.RamachandranEval() ##if use_segids: ## chain_id = utils.get_segid_as_chainid(chain=chain) ## else: ## chain_id = chain.id for three in generate_protein_threes(hierarchy=pdb_hierarchy, geometry=None): main_residue = three[1] phi_psi_atoms = three.get_phi_psi_atoms() if phi_psi_atoms is None: continue phi_atoms, psi_atoms = phi_psi_atoms phi = get_dihedral(phi_atoms) psi = get_dihedral(psi_atoms) coords = get_center(main_residue) #should find the CA of the center residue if (phi is not None and psi is not None): res_type = RAMA_GENERAL #self.n_total += 1 if (main_residue.resname[0:3] == "GLY"): res_type = RAMA_GLYCINE elif (main_residue.resname[0:3] == "PRO"): is_cis = is_cis_peptide(three) if is_cis: res_type = RAMA_CISPRO else: res_type = RAMA_TRANSPRO elif (three[2].resname == "PRO"): res_type = RAMA_PREPRO elif (main_residue.resname[0:3] == "ILE" or \ main_residue.resname[0:3] == "VAL"): res_type = RAMA_ILE_VAL #self.n_type[res_type] += 1 value = r.evaluate(res_types[res_type], [phi, psi]) ramaType = self.evaluateScore(res_type, value) is_outlier = ramaType == RAMALYZE_OUTLIER c_alphas = None # XXX only save kinemage data for outliers if is_outlier : c_alphas = get_cas_from_three(three) assert (len(c_alphas) == 3) markup = self.as_markup_for_kinemage(c_alphas) else: markup = None result = ramachandran( chain_id=main_residue.parent().parent().id, resseq=main_residue.resseq, icode=main_residue.icode, resname=main_residue.resname, #altloc=main_residue.parent().altloc, altloc=get_altloc_from_three(three), segid=None, # XXX ??? phi=phi, psi=psi, rama_type=ramaType, res_type=res_type, score=value*100, outlier=is_outlier, xyz=coords, markup=markup) #if result.chain_id+result.resseq+result.icode not in count_keys: if result.altloc in ['','A'] and result.chain_id+result.resseq+result.icode not in count_keys: self.n_total += 1 self.n_type[res_type] += 1 self.add_to_validation_counts(ramaType) count_keys.append(result.chain_id+result.resseq+result.icode) if (not outliers_only or is_outlier) : if (result.altloc != '' or result.chain_id+result.resseq+result.icode not in uniqueness_keys): #the threes/conformers method results in some redundant result # calculations in structures with alternates. Using the # uniqueness_keys list prevents redundant results being added to # the final list self.results.append(result) uniqueness_keys.append(result.chain_id+result.resseq+result.icode) if is_outlier : i_seqs = main_residue.atoms().extract_i_seq() assert (not i_seqs.all_eq(0)) self._outlier_i_seqs.extend(i_seqs) self.results.sort(key=lambda r: r.id_str()) out_count, out_percent = self.get_outliers_count_and_fraction() fav_count, fav_percent = self.get_favored_count_and_fraction() self.out_percent = out_percent * 100.0 self.fav_percent = fav_percent * 100.0
def __init__ (self, pdb_hierarchy, outliers_only=False, out=sys.stdout, collect_ideal=False, quiet=False) : validation.__init__(self) self._outlier_i_seqs = flex.size_t() self.beta_ideal = {} relevant_atom_names = { " CA ": None, " N ": None, " C ": None, " CB ": None} # FUTURE: set output_list = [] from mmtbx.validation import utils use_segids = utils.use_segids_in_place_of_chainids( hierarchy=pdb_hierarchy) for model in pdb_hierarchy.models(): for chain in model.chains(): if use_segids: chain_id = utils.get_segid_as_chainid(chain=chain) else: chain_id = chain.id for rg in chain.residue_groups(): for i_cf,cf in enumerate(rg.conformers()): for i_residue,residue in enumerate(cf.residues()): if (residue.resname == "GLY") : continue is_first = (i_cf == 0) is_alt_conf = False relevant_atoms = {} for atom in residue.atoms(): if (atom.name in relevant_atom_names): relevant_atoms[atom.name] = atom if (len(atom.parent().altloc) != 0): is_alt_conf = True if ((is_first or is_alt_conf) and len(relevant_atoms) == 4): result = calculate_ideal_and_deviation( relevant_atoms=relevant_atoms, resname=residue.resname) dev = result.deviation dihedralNABB = result.dihedral betaxyz = result.ideal if (dev is None) : continue if(dev >=0.25 or outliers_only==False): if(dev >=0.25): self.n_outliers+=1 self._outlier_i_seqs.append(atom.i_seq) if (is_alt_conf): altchar = cf.altloc else: altchar = " " res=residue.resname.lower() sub=chain.id if(len(sub)==1): sub=" "+sub resCB = relevant_atoms[" CB "] result = cbeta( chain_id=chain_id, resname=residue.resname, resseq=residue.resseq, icode=residue.icode, altloc=altchar, xyz=resCB.xyz, occupancy=resCB.occ, deviation=dev, dihedral_NABB=dihedralNABB, ideal_xyz=betaxyz, outlier=(dev >= 0.25)) self.results.append(result) key = result.id_str() if (collect_ideal) : self.beta_ideal[key] = betaxyz
def __init__ (self, pdb_hierarchy, keep_hydrogens=True, nuclear=False, force_unique_chain_ids=False, time_limit=120, b_factor_cutoff=None, save_probe_unformatted_file=None, save_modified_hierarchy=False, verbose=False, out=sys.stdout) : validation.__init__(self) self.b_factor_cutoff = b_factor_cutoff self.clashscore = None self.clashscore_b_cutoff = None self.clash_dict = {} self.clash_dict_b_cutoff = {} self.list_dict = {} self.probe_file = None if (not libtbx.env.has_module(name="probe")): raise RuntimeError( "Probe could not be detected on your system. Please make sure "+ "Probe is in your path.\nProbe is available at "+ "http://kinemage.biochem.duke.edu/") if verbose: if not nuclear: print "\nUsing electron cloud x-H distances and vdW radii" else: print "\nUsing nuclear cloud x-H distances and vdW radii" import iotbx.pdb.hierarchy from scitbx.array_family import flex from mmtbx.validation import utils n_models = len(pdb_hierarchy.models()) use_segids = utils.use_segids_in_place_of_chainids( hierarchy=pdb_hierarchy) for i_mod, model in enumerate(pdb_hierarchy.models()): input_str,_ = check_and_add_hydrogen( pdb_hierarchy=pdb_hierarchy, model_number=i_mod, nuclear=nuclear, verbose=verbose, time_limit=time_limit, keep_hydrogens=keep_hydrogens, log=out) r = iotbx.pdb.hierarchy.root() mdc = model.detached_copy() r.append_model(mdc) occ_max = flex.max(r.atoms().extract_occ()) pcm = probe_clashscore_manager( h_pdb_string=input_str, nuclear=nuclear, largest_occupancy=occ_max, b_factor_cutoff=b_factor_cutoff, use_segids=use_segids, verbose=verbose) if (save_modified_hierarchy) : self.pdb_hierarchy = iotbx.pdb.hierarchy.input( pdb_string=pcm.h_pdb_string).hierarchy self.clash_dict[model.id] = pcm.clashscore self.clash_dict_b_cutoff[model.id] = pcm.clashscore_b_cutoff self.list_dict[model.id] = pcm.bad_clashes if (n_models == 1) or (self.clashscore is None) : self.results = pcm.bad_clashes self.n_outliers = len(self.results) self.clashscore = pcm.clashscore self.clashscore_b_cutoff = pcm.clashscore_b_cutoff if (save_probe_unformatted_file is not None) and (n_models == 1) : open(save_probe_unformatted_file, "w").write(pcm.probe_unformatted) self.probe_file = save_probe_unformatted_file
def __init__(self, pdb_hierarchy, outliers_only=False, out=sys.stdout, collect_ideal=False, apply_phi_psi_correction=False, display_phi_psi_correction=False, quiet=False): validation.__init__(self) self._outlier_i_seqs = flex.size_t() self.beta_ideal = {} output_list = [] self.stats = group_args(n_results=0, n_weighted_results=0, n_weighted_outliers=0) if apply_phi_psi_correction: phi_psi_angles = get_phi_psi_dict(pdb_hierarchy) new_outliers = 0 outliers_removed = 0 total_residues = 0 from mmtbx.validation import utils use_segids = utils.use_segids_in_place_of_chainids( hierarchy=pdb_hierarchy) for model in pdb_hierarchy.models(): for chain in model.chains(): if use_segids: chain_id = utils.get_segid_as_chainid(chain=chain) else: chain_id = chain.id for rg in chain.residue_groups(): for i_cf, cf in enumerate(rg.conformers()): for i_residue, residue in enumerate(cf.residues()): if (residue.resname == "GLY"): continue is_first = (i_cf == 0) is_alt_conf = False relevant_atoms = {} for atom in residue.atoms(): if (atom.name in relevant_atom_names): relevant_atoms[atom.name] = atom if (len(atom.parent().altloc) != 0): is_alt_conf = True if ((is_first or is_alt_conf) and len(relevant_atoms) == 4): result = calculate_ideal_and_deviation( relevant_atoms=relevant_atoms, resname=residue.resname) dev = result.deviation dihedralNABB = result.dihedral betaxyz = result.ideal if (dev is None): continue resCB = relevant_atoms[" CB "] self.stats.n_results += 1 self.stats.n_weighted_results += resCB.occ if (is_alt_conf): altchar = cf.altloc else: altchar = " " if apply_phi_psi_correction: total_residues += 1 id_str = '|%s:%s|' % (residue.id_str(), altchar) phi_psi = phi_psi_angles.get(id_str, None) if phi_psi: rc = cbd_utils.get_phi_psi_correction( result, residue, phi_psi, display_phi_psi_correction= display_phi_psi_correction, ) if rc: dev, dihedralNABB, start, finish = rc if start and not finish: outliers_removed += 1 elif not start and finish: new_outliers += 1 if (dev >= 0.25 or outliers_only == False): if (dev >= 0.25): self.n_outliers += 1 self.stats.n_weighted_outliers += resCB.occ self._outlier_i_seqs.append(atom.i_seq) res = residue.resname.lower() sub = chain.id if (len(sub) == 1): sub = " " + sub result = cbeta(chain_id=chain_id, resname=residue.resname, resseq=residue.resseq, icode=residue.icode, altloc=altchar, xyz=resCB.xyz, occupancy=resCB.occ, deviation=dev, dihedral_NABB=dihedralNABB, ideal_xyz=betaxyz, outlier=(dev >= 0.25)) self.results.append(result) key = result.id_str() if (collect_ideal): self.beta_ideal[key] = betaxyz if apply_phi_psi_correction: print(''' Outliers removed : %5d New outliers : %5d Num. of outliers : %5d Num. of residues : %5d ''' % ( outliers_removed, new_outliers, self.n_outliers, total_residues, ))
def __init__( self, pdb_hierarchy, data_version="8000", outliers_only=False, show_errors=False, out=sys.stdout, quiet=False ): validation.__init__(self) self.n_allowed = 0 self.n_favored = 0 from mmtbx.rotamer.sidechain_angles import SidechainAngles from mmtbx.rotamer import rotamer_eval from mmtbx.rotamer.rotamer_eval import RotamerID from mmtbx.validation import utils self.data_version = data_version # if self.data_version == "500": self.outlier_threshold = 0.01 if self.data_version == "8000": self.outlier_threshold = 0.003 else: raise ValueError("data_version given to RotamerEval not recognized (%s)." % data_version) sidechain_angles = SidechainAngles(show_errors) rotamer_evaluator = rotamer_eval.RotamerEval(data_version=data_version) rotamer_id = rotamer_eval.RotamerID() # loads in the rotamer names use_segids = utils.use_segids_in_place_of_chainids(hierarchy=pdb_hierarchy) current_rotamers = {} for model in pdb_hierarchy.models(): for chain in model.chains(): if use_segids: chain_id = utils.get_segid_as_chainid(chain=chain) else: chain_id = chain.id for rg in chain.residue_groups(): all_dict = construct_complete_sidechain(rg) for atom_group in rg.atom_groups(): coords = get_center(atom_group) resname = atom_group.resname occupancy = get_occupancy(atom_group) kwargs = { "chain_id": chain_id, "resseq": rg.resseq, "icode": rg.icode, "altloc": atom_group.altloc, "resname": resname, "xyz": coords, "occupancy": occupancy, } atom_dict = all_dict.get(atom_group.altloc) res_key = get_residue_key(atom_group=atom_group) try: chis = sidechain_angles.measureChiAngles(atom_group, atom_dict) # .get(conformer.altloc)) except AttributeError: if show_errors: kwargs["incomplete"] = True result = rotamer(**kwargs) print >> out, "%s is missing some sidechain atoms" % result.id_str() self.results.append(result) continue if chis is not None: if None in chis: continue cur_res = resname.lower().strip() if cur_res == "mse": cur_res = "met" value = rotamer_evaluator.evaluate(cur_res, chis) if value is not None: self.n_total += 1 kwargs["score"] = value * 100 wrap_chis = rotamer_id.wrap_chis(resname.strip(), chis, symmetry=False) sym_chis = wrap_chis[:] sym_chis = rotamer_id.wrap_sym(resname.strip(), sym_chis) evaluation = self.evaluateScore(value) kwargs["evaluation"] = evaluation if evaluation == "OUTLIER": kwargs["outlier"] = True kwargs["rotamer_name"] = evaluation else: kwargs["outlier"] = False kwargs["rotamer_name"] = rotamer_id.identify(resname, wrap_chis) # deal with unclassified rotamers if kwargs["rotamer_name"] == "": kwargs["rotamer_name"] = "UNCLASSIFIED" while len(wrap_chis) < 4: wrap_chis.append(None) kwargs["chi_angles"] = wrap_chis result = rotamer(**kwargs) if (result.is_outlier()) or (not outliers_only): self.results.append(result) out_count, out_percent = self.get_outliers_count_and_fraction() self.out_percent = out_percent * 100.0
def __init__ (self, pdb_hierarchy, outliers_only=False, show_errors=False, out=sys.stdout, quiet=False) : validation.__init__(self) self.n_allowed = 0 self.n_favored = 0 self.n_type = [ 0 ] * 6 from mmtbx.validation import utils import mmtbx.rotamer from mmtbx.rotamer import ramachandran_eval from scitbx.array_family import flex self._outlier_i_seqs = flex.size_t() pdb_atoms = pdb_hierarchy.atoms() all_i_seqs = pdb_atoms.extract_i_seq() if (all_i_seqs.all_eq(0)) : pdb_atoms.reset_i_seq() use_segids = utils.use_segids_in_place_of_chainids( hierarchy=pdb_hierarchy) analysis = "" output_list = [] r = ramachandran_eval.RamachandranEval() prev_rezes, next_rezes = None, None prev_resid = None cur_resseq = None next_resseq = None for model in pdb_hierarchy.models(): for chain in model.chains(): if use_segids: chain_id = utils.get_segid_as_chainid(chain=chain) else: chain_id = chain.id residues = list(chain.residue_groups()) for i, residue_group in enumerate(residues): # The reason I pass lists of atom_groups to get_phi and get_psi is to # deal with the particular issue where some residues have an A alt # conf that needs some atoms from a "" alt conf to get calculated # correctly. See 1jxt.pdb for examples. This way I can search both # the alt conf atoms and the "" atoms if necessary. prev_atom_list, next_atom_list, atom_list = None, None, None if cur_resseq is not None: prev_rezes = rezes prev_resseq = cur_resseq rezes = construct_complete_residues(residues[i]) cur_resseq = residue_group.resseq_as_int() cur_icode = residue_group.icode.strip() if (i > 0): #check for insertion codes if (cur_resseq == residues[i-1].resseq_as_int()) : if (cur_icode == '') and (residues[i-1].icode.strip() == '') : continue elif (cur_resseq != (residues[i-1].resseq_as_int())+1): continue if (i < len(residues)-1): #find next residue if residue_group.resseq_as_int() == \ residues[i+1].resseq_as_int(): if (cur_icode == '') and (residues[i+1].icode.strip() == '') : continue elif residue_group.resseq_as_int() != \ (residues[i+1].resseq_as_int())-1: continue next_rezes = construct_complete_residues(residues[i+1]) next_resid = residues[i+1].resseq_as_int() else: next_rezes = None next_resid = None for atom_group in residue_group.atom_groups(): alt_conf = atom_group.altloc if rezes is not None: atom_list = rezes.get(alt_conf) if prev_rezes is not None: prev_atom_list = prev_rezes.get(alt_conf) if (prev_atom_list is None): prev_keys = sorted(prev_rezes.keys()) prev_atom_list = prev_rezes.get(prev_keys[0]) if next_rezes is not None: next_atom_list = next_rezes.get(alt_conf) if (next_atom_list is None): next_keys = sorted(next_rezes.keys()) next_atom_list = next_rezes.get(next_keys[0]) phi = get_phi(prev_atom_list, atom_list) psi = get_psi(atom_list, next_atom_list) coords = get_center(atom_group) if (phi is not None and psi is not None): res_type = RAMA_GENERAL self.n_total += 1 if (atom_group.resname[0:3] == "GLY"): res_type = RAMA_GLYCINE elif (atom_group.resname[0:3] == "PRO"): is_cis = is_cis_peptide(prev_atom_list, atom_list) if is_cis: res_type = RAMA_CISPRO else: res_type = RAMA_TRANSPRO elif (isPrePro(residues, i)): res_type = RAMA_PREPRO elif (atom_group.resname[0:3] == "ILE" or \ atom_group.resname[0:3] == "VAL"): res_type = RAMA_ILE_VAL self.n_type[res_type] += 1 value = r.evaluate(res_types[res_type], [phi, psi]) ramaType = self.evaluateScore(res_type, value) is_outlier = ramaType == RAMALYZE_OUTLIER c_alphas = None # XXX only save kinemage data for outliers if is_outlier : c_alphas = [] for atoms in [prev_atom_list, atom_list, next_atom_list] : for a in atoms : if (a.name.strip() == "CA") : a_ = atom(pdb_atom=a) c_alphas.append(c_alpha( id_str=a_.atom_group_id_str(), xyz=a_.xyz)) assert (len(c_alphas) == 3) result = ramachandran( chain_id=chain_id, resseq=residue_group.resseq, icode=residue_group.icode, resname=atom_group.resname, altloc=atom_group.altloc, segid=None, # XXX ??? phi=phi, psi=psi, rama_type=ramaType, res_type=res_type, score=value*100, outlier=is_outlier, xyz=coords, c_alphas=c_alphas) if (not outliers_only or is_outlier) : self.results.append(result) if is_outlier : i_seqs = atom_group.atoms().extract_i_seq() assert (not i_seqs.all_eq(0)) self._outlier_i_seqs.extend(i_seqs) out_count, out_percent = self.get_outliers_count_and_fraction() fav_count, fav_percent = self.get_favored_count_and_fraction() self.out_percent = out_percent * 100.0 self.fav_percent = fav_percent * 100.0