def exercise_clashscore(): if (not libtbx.env.has_module(name="probe")): print "Skipping exercise_clashscore(): probe not configured" return pdb_io = pdb.input(source_info=None, lines=pdb_str_1) pdb_hierarchy = pdb_io.construct_hierarchy() cs = clashscore.clashscore(pdb_hierarchy=pdb_hierarchy, fast=False, condensed_probe=True, out=null_out()) for unpickle in [False, True]: if unpickle: cs = loads(dumps(cs)) c_score = cs.get_clashscore() assert approx_equal(c_score, 35.29, eps=0.01) bad_clashes_list = cs.results assert ([c.format_old() for c in bad_clashes_list] == [ ' A 72 ARG HG2 A 72 ARG O :1.048', ' A 71 LEU HA A 71 LEU HD12 :0.768', ' A 72 ARG CG A 72 ARG O :0.720' ]), [c.format_old() for c in bad_clashes_list] #test nuclear distances cs = clashscore.clashscore(pdb_hierarchy=pdb_hierarchy, fast=False, condensed_probe=True, nuclear=True) for unpickle in [False, True]: if (unpickle): cs = loads(dumps(cs)) c_score = cs.get_clashscore() assert approx_equal(c_score, 58.82, eps=0.01) bad_clashes_list = cs.results assert ([c.format_old() for c in bad_clashes_list] == [ ' A 72 ARG HG2 A 72 ARG O :1.085', ' A 71 LEU HA A 71 LEU HD12 :0.793', ' A 72 ARG CG A 72 ARG O :0.720', ' A 72 ARG HD3 A 72 ARG HH11 :0.669', ' A 72 ARG HB3 A 72 ARG HE :0.647' ]), [c.format_old() for c in bad_clashes_list] #test B factor cutoff cs = clashscore.clashscore(pdb_hierarchy=pdb_hierarchy, fast=False, condensed_probe=True, b_factor_cutoff=40) for unpickle in [False, True]: if (unpickle): cs = loads(dumps(cs)) c_score = cs.get_clashscore() assert approx_equal(c_score, 35.29, eps=0.01) c_score_b_cutoff = cs.get_clashscore_b_cutoff() assert approx_equal(c_score_b_cutoff, 39.47, eps=0.01) bad_clashes_list = cs.results assert ([c.format_old() for c in bad_clashes_list] == [ ' A 72 ARG HG2 A 72 ARG O :1.048', ' A 71 LEU HA A 71 LEU HD12 :0.768', ' A 72 ARG CG A 72 ARG O :0.720' ]), [c.format_old() for c in bad_clashes_list]
def exercise_clashscore (): if (not libtbx.env.has_module(name="probe")): print "Skipping exercise_clashscore(): probe not configured" return pdb_io = pdb.input(source_info=None, lines=pdb_str_1) pdb_hierarchy = pdb_io.construct_hierarchy() cs = clashscore.clashscore(pdb_hierarchy=pdb_hierarchy, out=null_out()) for unpickle in [False, True] : if (unpickle) : cs = loads(dumps(cs)) c_score = cs.get_clashscore() assert approx_equal(c_score, 35.29, eps=0.01) bad_clashes_list = cs.results assert ([ c.format_old() for c in bad_clashes_list ] == [' A 72 ARG HG2 A 72 ARG O :-1.038', ' A 72 ARG CG A 72 ARG O :-0.465', ' A 71 LEU HA A 71 LEU HD12 :-0.446']) #test nuclear distances cs = clashscore.clashscore(pdb_hierarchy=pdb_hierarchy, nuclear=True) for unpickle in [False, True] : if (unpickle) : cs = loads(dumps(cs)) c_score = cs.get_clashscore() assert approx_equal(c_score, 58.82, eps=0.01) bad_clashes_list = cs.results assert ([ c.format_old() for c in bad_clashes_list ] == [ ' A 72 ARG HG2 A 72 ARG O :-1.082', ' A 72 ARG CG A 72 ARG O :-0.622', ' A 71 LEU HA A 71 LEU HD12 :-0.535', ' A 72 ARG HB3 A 72 ARG HE :-0.475', ' A 72 ARG HD3 A 72 ARG HH11 :-0.451']) #test B factor cutoff cs = clashscore.clashscore(pdb_hierarchy=pdb_hierarchy, b_factor_cutoff=40) for unpickle in [False, True] : if (unpickle) : cs = loads(dumps(cs)) c_score = cs.get_clashscore() assert approx_equal(c_score, 35.29, eps=0.01) c_score_b_cutoff = cs.get_clashscore_b_cutoff() assert approx_equal(c_score_b_cutoff, 39.47, eps=0.01) bad_clashes_list = cs.results assert ([ c.format_old() for c in bad_clashes_list ] == [' A 72 ARG HG2 A 72 ARG O :-1.038', ' A 72 ARG CG A 72 ARG O :-0.465', ' A 71 LEU HA A 71 LEU HD12 :-0.446'])
def run(self, quiet=None): #preserved how quiet was passed to the old run, not sure why """ Calculates nonbonded clashscore using MolProbity (PROBE) Returns: When verbose=True the function print detailed results to log When verbose=False it will print clashscore """ # if do_flips, make keep_hydrogens false if self.params.do_flips : self.params.keep_hydrogens = False hierarchy = self.data_manager.get_model().get_hierarchy() result = clashscore( pdb_hierarchy=hierarchy, fast = self.params.fast, condensed_probe = self.params.condensed_probe, keep_hydrogens=self.params.keep_hydrogens, nuclear=self.params.nuclear, out=self.logger, verbose=self.params.verbose and not quiet, b_factor_cutoff=self.params.b_factor_cutoff, do_flips=self.params.do_flips) if self.params.verbose: result.show_old_output(out=self.logger) else: print(round(result.get_clashscore(),2), file=self.logger)
def run(args, out=sys.stdout, quiet=None): """ Calculates nonbonded clashscore using MolProbity (PROBE) Returns: When verbose=True the function print detailed results to log When verbose=False it will print clashscore """ cmdline = iotbx.phil.process_command_line_with_files( args=args, master_phil_string=master_phil_str, pdb_file_def="model", usage_string=usage_string) params = cmdline.work.extract() if (params.model is None): raise Usage(usage_string) # if do_flips, make keep_hydrogens false if params.do_flips : params.keep_hydrogens = False pdb_in = cmdline.get_file(params.model, force_type="pdb") hierarchy = pdb_in.file_object.hierarchy result = clashscore( pdb_hierarchy=hierarchy, fast = params.fast, condensed_probe = params.condensed_probe, keep_hydrogens=params.keep_hydrogens, nuclear=params.nuclear, out=out, verbose=params.verbose and not quiet, b_factor_cutoff=params.b_factor_cutoff, do_flips=params.do_flips) if params.verbose: result.show_old_output(out=out) else: print >> out,round(result.get_clashscore(),2)
def run (args, out=sys.stdout, quiet=None) : """ Calculates nonbonded clashscore using MolProbity (PROBE) Returns: When verbose=True the function print detailed results to log When verbose=False it will print clashscore """ cmdline = iotbx.phil.process_command_line_with_files( args=args, master_phil_string=master_phil_str, pdb_file_def="model", usage_string=usage_string) params = cmdline.work.extract() if (params.model is None) : raise Usage(usage_string) pdb_in = cmdline.get_file(params.model, force_type="pdb") hierarchy = pdb_in.file_object.hierarchy result = clashscore( pdb_hierarchy=hierarchy, keep_hydrogens=params.keep_hydrogens, nuclear=params.nuclear, out=out, verbose=params.verbose and not quiet, b_factor_cutoff=params.b_factor_cutoff) if params.verbose: result.show_old_output(out=out) else: print >> out,round(result.get_clashscore(),2)
def clash(self): if self.cached_clash is None: self.cached_clash = clashscore(pdb_hierarchy=self.pdb_hierarchy, keep_hydrogens=self.use_hydrogens, nuclear=self.use_nuclear) return group_args( score=self.cached_clash.get_clashscore(), clashes=self.cached_clash #XXX Bulky object -- REMOVE! )
def clash(self): if self.cached_clash is None: self.cached_clash = clashscore( pdb_hierarchy = self.pdb_hierarchy, fast = self.fast_clash, condensed_probe = self.condensed_probe, keep_hydrogens = self.use_hydrogens, nuclear = self.model.is_neutron()) return group_args( score = self.cached_clash.get_clashscore(), clashes = self.cached_clash #XXX Bulky object -- REMOVE! - Not kidding, # it contains 1 probe output, which can be GigaBytes! )
def test_identifying_and_addition_of_hydrogen(self): """ test identifying and addition of hydrogen """ has_reduce = libtbx.env.has_module(name="reduce") if has_reduce: pdb_inp = iotbx.pdb.input(file_name=self.file_name) pdb_hierarchy = pdb_inp.construct_hierarchy() # don't do flip result = clashscore(pdb_hierarchy=pdb_hierarchy, keep_hydrogens=False) #verbose=True) self.assertAlmostEqual(result.clashscore, 22.9885057471, places=4) # do flip result = clashscore( pdb_hierarchy=pdb_hierarchy, keep_hydrogens=False, #verbose=True) do_flips=True) self.assertEqual(result.clashscore, 0) else: # Skip test if reduce is not present pass
def test_identifying_and_addition_of_hydrogen(self): """ test identifying and addition of hydrogen """ has_reduce = libtbx.env.has_module(name="reduce") if has_reduce: pdb_inp = iotbx.pdb.input(file_name=self.file_name) pdb_hierarchy = pdb_inp.construct_hierarchy() # don't do flip result = clashscore( pdb_hierarchy=pdb_hierarchy, keep_hydrogens=False)#verbose=True) self.assertAlmostEqual(result.clashscore,22.9885057471,places=4) # do flip result = clashscore( pdb_hierarchy=pdb_hierarchy, keep_hydrogens=False,#verbose=True) do_flips=True) self.assertEqual(result.clashscore,0) else: # Skip test if reduce is not present pass
def run_validation(self) : out = sys.stderr keep_hydrogens=True nuclear=False verbose=True quiet=False pdb_in = file_reader.any_file(self.pdb_file) pdb_in.check_file_type('pdb') input_pdb = iotbx.pdb.input(file_name=self.pdb_file) pdb_hierarchy = input_pdb.construct_hierarchy() out=sys.stdout self.result = clashscore( pdb_hierarchy=pdb_hierarchy, keep_hydrogens=keep_hydrogens, nuclear=nuclear, out=out, verbose=verbose and not quiet, do_flips=self.do_flips)
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 get_scores(self, model): rama_fav = ramalyze(pdb_hierarchy=model.get_hierarchy(), outliers_only=False).percent_favored cbeta = cbetadev(pdb_hierarchy=model.get_hierarchy(), outliers_only=True, out=null_out()).get_outlier_percent() rota = rotalyze(pdb_hierarchy=model.get_hierarchy(), outliers_only=False).percent_outliers b_rmsd = get_bonds_rmsd( restraints_manager=self.geometry_rmsd_manager.geometry, xrs=model.get_xray_structure()) clash = clashscore(pdb_hierarchy=model.get_hierarchy(), keep_hydrogens=False, fast=True, condensed_probe=True).get_clashscore() print "DEV: b_rmsd= %7.4f clash= %6.4f rota= %6.4f rama_fav= %5.4f cbeta= %6.4f" % ( b_rmsd, clash, rota, rama_fav, cbeta) return group_args(rama_fav=rama_fav, cbeta=cbeta, rota=rota, b_rmsd=b_rmsd, clash=clash)
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, 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 load_refinement(self, ref): self._pdb_file = ref.replace('.dat', '.pdb') self._ins_file = ref.replace('.dat', '.ins') self._lst_file = ref.replace('.dat', '.lst') lst = LSTParser(self._lst_file) pdb_io = pdb.input(file_name=self._pdb_file) self._chain_lookup = PDBTools().get_chains(self._pdb_file) r = clashscore() self._clash_score, self._clashes = clashscore.analyze_clashes(r,pdb_io)# verbose=True) self._clashes = self._clashes[''].split('\n') rama = ramalyze() output, self._rama_data = rama.analyze_pdb(pdb_io=pdb_io, outliers_only=False) rota = rotalyze() output, self._rotamer_data = rota.analyze_pdb(pdb_io, outliers_only=False) r = cbetadev() output, summary, self._cb_data = cbetadev.analyze_pdb(r,pdb_io=pdb_io,outliers_only=True) self.sizer = wx.BoxSizer(wx.VERTICAL) self._rmsds = lst.get_stats() # Summary self.stats_sizer = wx.FlexGridSizer(cols=3, rows=0, vgap=5, hgap=5) self.stats_sizer.Add(wx.StaticText(self, -1, 'RMSD Bonds')) self.stats_sizer.Add(wx.StaticText(self, -1, '%.3f' % (self._rmsds[0]))) self.stats_sizer.Add(wx.StaticText(self, -1, '')) self.stats_sizer.Add(wx.StaticText(self, -1, 'RMSD Angles')) self.stats_sizer.Add(wx.StaticText(self, -1, '%.3f' % (self._rmsds[1]))) self.stats_sizer.Add(wx.StaticText(self, -1, ''), 0, wx.EXPAND|wx.BOTTOM, 10) self.stats_sizer.Add(wx.StaticText(self, -1, 'B Factor (Protein)')) self.stats_sizer.Add(wx.StaticText(self, -1, '%.2f' % (self._residues['avg']['pro']))) self.stats_sizer.Add(wx.StaticText(self, -1, ''), 0, wx.EXPAND|wx.BOTTOM) self.stats_sizer.Add(wx.StaticText(self, -1, 'B Factor (Solvent)')) self.stats_sizer.Add(wx.StaticText(self, -1, '%.2f' % (self._residues['avg']['sol']))) self.stats_sizer.Add(wx.StaticText(self, -1, ''), 0, wx.EXPAND|wx.BOTTOM) self.stats_sizer.Add(wx.StaticText(self, -1, 'B Factor (All)')) self.stats_sizer.Add(wx.StaticText(self, -1, '%.2f' % (self._residues['avg']['all']))) self.stats_sizer.Add(wx.StaticText(self, -1, ''), 0, wx.EXPAND|wx.BOTTOM, 10) self.stats_sizer.Add(wx.StaticText(self, -1, 'Ramachandran Outliers')) self.stats_sizer.Add(wx.StaticText(self, -1, '%.1f' % (rama.get_outliers_count_and_fraction()[1]*100) + '%')) self.stats_sizer.Add(wx.StaticText(self, -1, '(Goal ' + rama.get_outliers_goal()+')')) self.stats_sizer.Add(wx.StaticText(self, -1, 'Ramachandran Favoured')) self.stats_sizer.Add(wx.StaticText(self, -1, '%.1f' % (rama.get_favored_count_and_fraction()[1]*100) + '%')) self.stats_sizer.Add(wx.StaticText(self, -1, '(Goal ' + rama.get_favored_goal()+')'), 0, wx.EXPAND|wx.BOTTOM, 10) self.stats_sizer.Add(wx.StaticText(self, -1, 'Rotamer Outliers')) self.stats_sizer.Add(wx.StaticText(self, -1, '%.1f' % (rota.get_outliers_count_and_fraction()[1]*100) + '%')) self.stats_sizer.Add(wx.StaticText(self, -1, '(Goal ' + rota.get_outliers_goal()+')')) self.stats_sizer.Add(wx.StaticText(self, -1, 'C-beta Outliers')) self.stats_sizer.Add(wx.StaticText(self, -1, '%d' % len(self._cb_data))) self.stats_sizer.Add(wx.StaticText(self, -1, '(Goal 0)')) self.stats_sizer.Add(wx.StaticText(self, -1, 'Clashscore')) self.stats_sizer.Add(wx.StaticText(self, -1, '%d' % self._clash_score[''])) self.sizer.Add(self.stats_sizer, 0, wx.ALL, 10) # Ramachandran Outliers self.rama_sizer = wx.StaticBoxSizer(wx.StaticBox(self, -1, 'Ramachandran Outliers'),wx.VERTICAL) if rama.get_outliers_count_and_fraction()[1] > 0: rama_list = wx.ListCtrl(self, -1, style=wx.LC_REPORT) self.Bind(wx.EVT_LIST_ITEM_SELECTED, self._show_rama, rama_list) sizes = [50, 50, 150, 80, 80, 80] for i, item in enumerate(['Chain', 'No', 'Residue', 'Score', 'Phi', 'Psi']): rama_list.InsertColumn(i, item, width = sizes[i]) i = 0 self._rama_outliers = [] for r in self._rama_data: (chain_id,resseq,resname,quality,phi,psi,status,pos_name,xyz) = r if status == 'OUTLIER': self._rama_outliers.append(r) rama_list.InsertStringItem(i, str(chain_id)) rama_list.SetStringItem(i, 1, str(resseq)) rama_list.SetStringItem(i, 2, resname) rama_list.SetStringItem(i, 3, '%.2f' % quality) rama_list.SetStringItem(i, 4, '%.1f' % phi) rama_list.SetStringItem(i, 5, '%.1f' % psi) i += 1 self.rama_sizer.Add(wx.StaticText(self, -1, '%d Ramachandran outliers found' % i), 0) self.rama_sizer.Add(rama_list, 0, wx.EXPAND|wx.ALL, 10) self.rama_list = rama_list else: self.rama_sizer.Add(wx.StaticText(self, -1, 'No Ramachandran Outliers'), 0) self.rama_sizer.Add(wx.Button(self, 0, 'Show Ramachandran Plot'), 0) self.Bind(wx.EVT_BUTTON, self.show_ramachandran, id=0) self.sizer.Add(self.rama_sizer, 0, wx.EXPAND|wx.ALL, 10) # Rotamer Outliers self.rota_sizer = wx.StaticBoxSizer(wx.StaticBox(self, -1, 'Rotamer Outliers'),wx.VERTICAL) if rota.get_outliers_count_and_fraction()[1] > 0: rota_list = wx.ListCtrl(self, -1, style=wx.LC_REPORT) self.Bind(wx.EVT_LIST_ITEM_SELECTED, self._show_rota, rota_list) sizes = [50, 50, 150, 80, 80, 80, 80, 80] for i, item in enumerate(['Chain', 'No', 'Residue', 'Score', 'Chi1', 'Chi2', 'Chi3', 'Chi4']): rota_list.InsertColumn(i, item, width = sizes[i]) i = 0 self._rota_outliers = [] for r in self._rotamer_data: (chain_id,resseq,resname,quality,chi1,chi2,chi3,chi4,status,xyz) = r if status == 'OUTLIER': self._rota_outliers.append(r) rota_list.InsertStringItem(i, str(chain_id)) rota_list.SetStringItem(i, 1, str(resseq)) rota_list.SetStringItem(i, 2, resname) rota_list.SetStringItem(i, 3, '%.2f' % quality) rota_list.SetStringItem(i, 4, '%.1f' % chi1) rota_list.SetStringItem(i, 5, '%.1f' % chi2 if chi2 is not None else 'None') rota_list.SetStringItem(i, 6, '%.1f' % chi3 if chi3 is not None else 'None') rota_list.SetStringItem(i, 7, '%.1f' % chi4 if chi4 is not None else 'None') i += 1 self.rota_sizer.Add(wx.StaticText(self, -1, '%d rotamer outliers found' % i), 0) self.rota_sizer.Add(rota_list, 1, wx.EXPAND|wx.ALL, 5) self.rota_list = rota_list else: self.rota_sizer.Add(wx.StaticText(self, -1, 'No Rotamer Outliers')) self.rota_sizer.Add(wx.Button(self, 1, 'Show Chi1-Chi2 Plots')) self.Bind(wx.EVT_BUTTON, self.show_rotamer, id=1) self.sizer.Add(self.rota_sizer, 0, wx.EXPAND|wx.ALL, 10) # C-beta Outliers self.cb_sizer = wx.StaticBoxSizer(wx.StaticBox(self, -1, 'C-beta Outliers'),wx.VERTICAL) if len(self._cb_data) > 0: cb_list = wx.ListCtrl(self, -1, style=wx.LC_REPORT) self.Bind(wx.EVT_LIST_ITEM_SELECTED, self._show_cb, cb_list) sizes = [50, 50, 150, 100, 100] for i, item in enumerate(['Chain', 'No', 'Residue', 'Deviation', 'Angle']): cb_list.InsertColumn(i, item, width = sizes[i]) for i,r in enumerate(self._cb_data): (pdbf, alt, resname, chain_id, resseq, resseq2, dev, diheral, occ, altchar, xyz) = r cb_list.InsertStringItem(i, str(chain_id)) cb_list.SetStringItem(i, 1, str(resseq+resseq2)) cb_list.SetStringItem(i, 2, resname.upper()) cb_list.SetStringItem(i, 3, '%.3f' % dev) cb_list.SetStringItem(i, 4, '%.2f' % diheral) self.cb_sizer.Add(wx.StaticText(self, -1, '%d C-beta outliers found' % len(self._cb_data)), 0) self.cb_sizer.Add(cb_list, 1, wx.EXPAND|wx.ALL, 5) self.cb_list = cb_list else: self.cb_sizer.Add(wx.StaticText(self, -1, 'No C-beta Outliers')) self.sizer.Add(self.cb_sizer, 0, wx.EXPAND|wx.ALL, 10) # Bad Clashes self.clash_sizer = wx.StaticBoxSizer(wx.StaticBox(self, -1, 'All Atom Contacts'), wx.VERTICAL) if len(self._clashes) > 0: clash_list = wx.ListCtrl(self, -1, style=wx.LC_REPORT) self.Bind(wx.EVT_LIST_ITEM_SELECTED, self._show_clash, clash_list) sizes = [50, 50, 80, 80, 50, 50, 80, 80, 100] for i, item in enumerate(['Chain', 'No', 'Residue', 'Atom', 'Chain', 'No', 'Residue', 'Atom', 'Overlap']): clash_list.InsertColumn(i, item, width = sizes[i]) for i,r in enumerate(self._clashes): ' 78 ILE CD1 83 LEU HD21 :-0.402' clash_list.InsertStringItem(i, r[0:2].strip()) clash_list.SetStringItem(i, 1, r[2:6].strip()) clash_list.SetStringItem(i, 2, r[7:10].strip()) clash_list.SetStringItem(i, 3, r[11:15].strip()) clash_list.SetStringItem(i, 4, r[16:18].strip()) clash_list.SetStringItem(i, 5, r[19:22].strip()) clash_list.SetStringItem(i, 6, r[23:26].strip()) clash_list.SetStringItem(i, 7, r[28:32].strip()) clash_list.SetStringItem(i, 8, r[34:39].strip()) self.clash_sizer.Add(wx.StaticText(self, -1, '%d bad clashes found' % i), 0) self.clash_sizer.Add(clash_list, 1, wx.EXPAND|wx.ALL, 5) self.clash_list = clash_list else: self.clash_sizer.Add(wx.StaticText(self, -1, 'No Bad Clashes')) self.sizer.Add(self.clash_sizer, 0, wx.EXPAND|wx.ALL, 10) self._split_sites, self._npds = lst.get_site_info() # Split Sites self.split_sizer = wx.StaticBoxSizer(wx.StaticBox(self, -1, 'Split Sites'), wx.VERTICAL) if len(self._split_sites) > 0: split_list = wx.ListCtrl(self, -1, style=wx.LC_REPORT) self.Bind(wx.EVT_LIST_ITEM_SELECTED, self._show_split, split_list) sizes = [100,100,100,50,80,100] for i, item in enumerate(['U1', 'U2', 'U3', 'No', 'Residue', 'Atom']): split_list.InsertColumn(i, item, width=sizes[i]) i = 0 for j,s in enumerate(self._split_sites): if '_' in s[3]: split_list.InsertStringItem(i, str(s[0])) split_list.SetStringItem(i, 1, str(s[1])) split_list.SetStringItem(i, 2, str(s[2])) atom,id = s[3].split('_') split_list.SetStringItem(i, 3, str(id)) split_list.SetStringItem(i, 4, str()) split_list.SetStringItem(i, 5, str(atom)) i += 1 self.split_sizer.Add(wx.StaticText(self, -1, '%d possible split sites found' % len(self._split_sites))) self.split_sizer.Add(split_list, 0, wx.EXPAND|wx.ALL, 5) self.split_list = split_list else: self.split_sizer.Add(wx.StaticText(self, -1, 'No split sites found')) self.sizer.Add(self.split_sizer, 0, wx.EXPAND|wx.ALL, 10) # NPDs self.npd_sizer = wx.StaticBoxSizer(wx.StaticBox(self, -1, 'Non Positive Definites'), wx.VERTICAL) if len(self._npds) > 0: npd_list = wx.ListCtrl(self, -1, style=wx.LC_REPORT) self.Bind(wx.EVT_LIST_ITEM_SELECTED, self._show_npd, npd_list) sizes = [100,100,100,50,80,100] for i, item in enumerate(['U1', 'U2', 'U3', 'No', 'Residue', 'Atom']): npd_list.InsertColumn(i, item, width=sizes[i]) for i, s in enumerate(self._npds): npd_list.InsertStringItem(i, str(s[0])) npd_list.SetStringItem(i, 1, str(s[1])) npd_list.SetStringItem(i, 2, str(s[2])) atom, id = s[3].split('_') npd_list.SetStringItem(i, 3, str(id)) npd_list.SetStringItem(i, 4, str()) npd_list.SetStringItem(i, 5, str(atom)) self.npd_sizer.Add(wx.StaticText(self, -1, '%d non positive definite sites found' % len(self._npds))) self.npd_sizer.Add(npd_list, 0, wx.EXPAND|wx.ALL, 5) self.npd_list = npd_list else: self.npd_sizer.Add(wx.StaticText(self, -1, 'No non positive definite sites found')) self.sizer.Add(self.npd_sizer, 0, wx.EXPAND|wx.ALL, 10) self.SetSizer(self.sizer) self.SetAutoLayout(1) self.SetupScrolling()
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
def __init__( self, pdb_hierarchy, restraints_manager, molprobity_scores=False, n_histogram_slots=10, cdl_restraints=False, ignore_hydrogens=False, #only used by amber ): self.cdl_restraints=cdl_restraints sites_cart = pdb_hierarchy.atoms().extract_xyz() energies_sites = \ restraints_manager.energies_sites( sites_cart = sites_cart, compute_gradients = False) # molprobity scores 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 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) # if(hasattr(energies_sites, "geometry")): esg = energies_sites.geometry else: esg = energies_sites self.a = None self.b = None if not hasattr(esg, "angle_deviations"): return if hasattr(esg, "amber"): amber_parm = restraints_manager.amber_structs.parm self.a, angle_deltas = esg.angle_deviations(sites_cart, amber_parm, ignore_hd=ignore_hydrogens, get_deltas=True) self.b, bond_deltas = esg.bond_deviations(sites_cart, amber_parm, ignore_hd=ignore_hydrogens, get_deltas=True) self.a_number = esg.n_angle_proxies(amber_parm, ignore_hd=ignore_hydrogens) self.b_number = esg.n_bond_proxies(amber_parm, ignore_hd=ignore_hydrogens) self.c, self.p, self.ll, self.d, self.n = None, None, None, None, None self.c_number=0 self.p_number=0 self.d_number=0 self.bond_deltas_histogram = \ flex.histogram(data = flex.abs(bond_deltas), n_slots = n_histogram_slots) self.angle_deltas_histogram = \ flex.histogram(data = flex.abs(angle_deltas), n_slots = n_histogram_slots) # nonbonded_distances = esg.nonbonded_distances() # self.nonbonded_distances_histogram = flex.histogram( # data = flex.abs(nonbonded_distances), n_slots = n_histogram_slots) for restraint_type in ["b", "a", "c", "p", "ll", "d", "n"] : for value_type in [("mean",2), ("max",1), ("min",0)] : name = "%s_%s" % (restraint_type, value_type[0]) if getattr(self, restraint_type) is None: setattr(self, name, None) continue setattr(self, name, getattr(self, restraint_type)[value_type[1]]) return self.a = esg.angle_deviations() self.b = esg.bond_deviations() self.a_number = esg.get_filtered_n_angle_proxies() self.b_number = esg.get_filtered_n_bond_proxies() self.c = esg.chirality_deviations() self.d = esg.dihedral_deviations() self.p = esg.planarity_deviations() self.ll = esg.parallelity_deviations() self.n = esg.nonbonded_deviations() self.c_number = esg.n_chirality_proxies self.d_number = esg.n_dihedral_proxies self.p_number = esg.n_planarity_proxies self.n_number = esg.n_nonbonded_proxies # for restraint_type in ["b", "a", "c", "p", "ll", "d", "n"] : for value_type in [("mean",2), ("max",1), ("min",0)] : name = "%s_%s" % (restraint_type, value_type[0]) if getattr(self, restraint_type) is None: continue setattr(self, name, getattr(self, restraint_type)[value_type[1]]) # if(hasattr(restraints_manager, "geometry")): rmg = restraints_manager.geometry else: rmg = restraints_manager bond_deltas = geometry_restraints.bond_deltas( sites_cart = sites_cart, sorted_asu_proxies = rmg.pair_proxies().bond_proxies) angle_deltas = geometry_restraints.angle_deltas( sites_cart = sites_cart, proxies = rmg.angle_proxies) nonbonded_distances = esg.nonbonded_distances() self.bond_deltas_histogram = \ flex.histogram(data = flex.abs(bond_deltas), n_slots = n_histogram_slots) self.angle_deltas_histogram = \ flex.histogram(data = flex.abs(angle_deltas), n_slots = n_histogram_slots) self.nonbonded_distances_histogram = flex.histogram( data = flex.abs(nonbonded_distances), n_slots = n_histogram_slots) # assert approx_equal( esg.target, esg.angle_residual_sum+ esg.bond_residual_sum+ esg.chirality_residual_sum+ esg.dihedral_residual_sum+ esg.nonbonded_residual_sum+ esg.planarity_residual_sum+ esg.parallelity_residual_sum+ esg.reference_coordinate_residual_sum+ esg.reference_dihedral_residual_sum+ esg.ncs_dihedral_residual_sum+ esg.den_residual_sum+ esg.ramachandran_residual_sum) del energies_sites, esg # we accumulate this object, so make it clean asap