def exercise_2(): inp = iotbx.pdb.input(lines=pdb_str_1, source_info=None) model = mmtbx.model.manager( model_input = inp) model.setup_scattering_dictionaries(scattering_table="wk1995") g_stat = model.geometry_statistics()
def run(args, out=None, log=sys.stdout): if (len(args) == 0) or (args == ["--help"]): print(msg, file=log) defaults(log=log, silent=False) return parsed = defaults(log=log, silent=True) # processed_args = utils.process_command_line_args(args=args, log=log, master_params=parsed) params = processed_args.params.extract() # reflection_files = processed_args.reflection_files if (len(reflection_files) == 0): raise Sorry("No reflection file found.") crystal_symmetry = processed_args.crystal_symmetry if (crystal_symmetry is None): raise Sorry("No crystal symmetry found.") if (len(processed_args.pdb_file_names) == 0): raise Sorry("No PDB file found.") pdb_file_names = processed_args.pdb_file_names # rfs = reflection_file_server(crystal_symmetry=crystal_symmetry, reflection_files=reflection_files) parameters = extract_xtal_data.data_and_flags_master_params().extract() if (params.f_obs_label is not None): parameters.labels = params.f_obs_label if (params.r_free_flags_label is not None): parameters.r_free_flags.label = params.r_free_flags_label if (params.high_resolution is not None): parameters.high_resolution = params.high_resolution determine_data_and_flags_result = extract_xtal_data.run( reflection_file_server=rfs, parameters=parameters, data_parameter_scope="refinement.input.xray_data", flags_parameter_scope="refinement.input.xray_data.r_free_flags", data_description="X-ray data", keep_going=True, log=StringIO()) f_obs = determine_data_and_flags_result.f_obs # Data show_header(l="Data:", log=log) f_obs.show_comprehensive_summary(prefix=" ", f=log) # R-free-flags show_header(l="R-free-flags:", log=log) r_free_flags = determine_data_and_flags_result.r_free_flags test_flag_value = determine_data_and_flags_result.test_flag_value if (r_free_flags is None): r_free_flags = f_obs.array(data=flex.bool(f_obs.data().size(), False)) test_flag_value = None print(" not available", file=log) else: print(" flag value:", test_flag_value, file=log) # Model pdb_combined = iotbx.pdb.combine_unique_pdb_files( file_names=processed_args.pdb_file_names) pdb_combined.report_non_unique(out=log) if (len(pdb_combined.unique_file_names) == 0): raise Sorry("No coordinate file given.") raw_records = pdb_combined.raw_records try: pdb_inp = iotbx.pdb.input(source_info=None, lines=flex.std_string(raw_records)) except ValueError as e: raise Sorry("Model format (PDB or mmCIF) error:\n%s" % str(e)) model = mmtbx.model.manager(model_input=pdb_inp, crystal_symmetry=crystal_symmetry, log=StringIO()) # scattering_table = params.scattering_table exptl_method = pdb_inp.get_experiment_type() if (exptl_method is not None) and ("NEUTRON" in exptl_method): scattering_table = "neutron" model.setup_scattering_dictionaries(scattering_table=scattering_table, d_min=f_obs.d_min()) # # Model vs data # show_header(l="Model vs Data:", log=log) fmodel = mmtbx.f_model.manager(xray_structure=model.get_xray_structure(), f_obs=f_obs, r_free_flags=r_free_flags, twin_law=params.twin_law) fmodel.update_all_scales(update_f_part1=True) fmodel.show(log=log, show_header=False, show_approx=False) print(" r_work: %6.4f" % fmodel.r_work(), file=log) if (test_flag_value is not None): print(" r_free: %6.4f" % fmodel.r_free(), file=log) else: print(" r_free: None", file=log) print(file=log) n_outl = f_obs.data().size() - fmodel.f_obs().data().size() print(" Number of F-obs outliers:", n_outl, file=log) # # Extract information from PDB file header and output (if any) # pub_r_work = None pub_r_free = None pub_high = None pub_low = None pub_sigma = None pub_program_name = None pub_solv_cont = None pub_matthews = None published_results = pdb_inp.get_r_rfree_sigma(file_name=pdb_file_names[0]) if (published_results is not None): pub_r_work = published_results.r_work pub_r_free = published_results.r_free pub_high = published_results.high pub_low = published_results.low pub_sigma = published_results.sigma pub_program_name = pdb_inp.get_program_name() pub_solv_cont = pdb_inp.get_solvent_content() pub_matthews = pdb_inp.get_matthews_coeff() # show_header(l="Information extracted from PDB file header:", log=log) print(" program_name : %-s" % format_value("%s", pub_program_name), file=log) print(" year : %-s" % format_value("%s", pdb_inp.extract_header_year()), file=log) print(" r_work : %-s" % format_value("%s", pub_r_work), file=log) print(" r_free : %-s" % format_value("%s", pub_r_free), file=log) print(" high_resolution : %-s" % format_value("%s", pub_high), file=log) print(" low_resolution : %-s" % format_value("%s", pub_low), file=log) print(" sigma_cutoff : %-s" % format_value("%s", pub_sigma), file=log) print(" matthews_coeff : %-s" % format_value("%s", pub_matthews), file=log) print(" solvent_cont : %-s" % format_value("%s", pub_solv_cont), file=log) if (exptl_method is not None): print(" exptl_method : %-s" % format_value("%s", exptl_method), file=log) # # Recompute R-factors using published cutoffs fmodel_cut = fmodel tmp_sel = flex.bool(fmodel.f_obs().data().size(), True) if (pub_sigma is not None and fmodel.f_obs().sigmas() is not None): tmp_sel &= fmodel.f_obs().data() > fmodel.f_obs().sigmas() * pub_sigma if (pub_high is not None and abs(pub_high - fmodel.f_obs().d_min()) > 0.03): tmp_sel &= fmodel.f_obs().d_spacings().data() > pub_high if (pub_low is not None and abs(pub_low - fmodel.f_obs().d_max_min()[0]) > 0.03): tmp_sel &= fmodel.f_obs().d_spacings().data() < pub_low if (tmp_sel.count(True) != tmp_sel.size() and tmp_sel.count(True) > 0): show_header(l="After applying resolution and sigma cutoffs:", log=log) fmodel = mmtbx.f_model.manager( xray_structure=model.get_xray_structure(), f_obs=fmodel.f_obs().select(tmp_sel), r_free_flags=fmodel.r_free_flags().select(tmp_sel), twin_law=params.twin_law) fmodel.update_all_scales(update_f_part1=True) fmodel.show(log=log, show_header=False, show_approx=False) print(" r_work: %6.4f" % fmodel.r_work(), file=log) if (test_flag_value is not None): print(" r_free: %6.4f" % fmodel.r_free(), file=log) else: print(" r_free: None", file=log) print(file=log) n_outl = f_obs.data().size() - fmodel.f_obs().data().size() print(" Number of F-obs outliers:", n_outl, file=log)
def exercise_2(eps = 1.e-6): ###> Get started from PDB mon_lib_srv = monomer_library.server.server() ener_lib = monomer_library.server.ener_lib() pdb_file = libtbx.env.find_in_repositories( relative_path="phenix_regression/pdb/phe_abc_tlsanl_out_geometry_minimized.pdb", test=os.path.isfile) model = mmtbx.model.manager( model_input=iotbx.pdb.input(file_name=pdb_file), build_grm=True) model.setup_scattering_dictionaries(scattering_table="wk1995") model.get_xray_structure().convert_to_isotropic() u_iso_start = model.get_xray_structure().extract_u_iso_or_u_equiv() model.get_xray_structure().convert_to_anisotropic() selections = [] selection_strings = ["chain A", "chain B", "chain C"] for string in selection_strings: selections.append(model.selection(string = string)) ################ selection = flex.bool(model.get_number_of_atoms(), True) class refinement_flags: pass refinement_flags.adp_tls = selections model.set_refinement_flags(refinement_flags) model.determine_tls_groups(selection_strings=selections, generate_tlsos=selections) model.set_refinement_flags(refinement_flags) xray_structure = model.get_xray_structure() ################ ###> Get TLS <-> Ucart T_initial = [] L_initial = [] S_initial = [] T_initial.append([0.11,0.22,0.33,0.12,0.13,0.23]) L_initial.append([1.11,1.22,1.33,1.12,1.13,1.23]) S_initial.append([0.11,0.12,0.13,0.21,0.22,0.23,0.31,0.32,-0.33]) T_initial.append([0.22,0.44,0.66,0.24,0.26,0.46]) L_initial.append([2.22,2.44,2.66,2.24,2.26,2.46]) S_initial.append([0.22,0.24,0.26,0.42,0.44,0.46,0.62,0.64,-0.66]) T_initial.append([0.33,0.66,0.99,0.36,0.39,0.69]) L_initial.append([2.33,2.66,2.99,2.36,2.39,2.69]) S_initial.append([0.22,0.24,0.26,0.42,0.44,0.46,0.62,0.64,-0.66]) tlsosA = tools.generate_tlsos(selections = selections, xray_structure = xray_structure, T = T_initial, L = L_initial, S = S_initial) tlsos = tools.generate_tlsos(selections = selections, xray_structure = xray_structure, T = T_initial, L = L_initial, S = S_initial) tlsos = tools.make_tlso_compatible_with_u_positive_definite( tlsos = tlsos, xray_structure = xray_structure.deep_copy_scatterers(), selections = selections, max_iterations = 50, number_of_u_nonpositive_definite = 0, eps = eps, number_of_macro_cycles_for_tls_from_uanisos = 30) u_cart_answer = tools.u_cart_from_tls(sites_cart = xray_structure.sites_cart(), selections = selections, tlsos = tlsos) xray_structure.scatterers().set_u_cart(xray_structure.unit_cell(), u_cart_answer) assert approx_equal(u_cart_answer, xray_structure.scatterers().extract_u_cart(xray_structure.unit_cell())) tools.show_tls(tlsos = tlsos, text = "ANSWER") ###> Set up fmodel sfg_params = mmtbx.f_model.sf_and_grads_accuracy_master_params.extract() sfg_params.algorithm = "direct" sfg_params.cos_sin_table = False dummy = xray_structure.structure_factors(algorithm = sfg_params.algorithm, d_min = 2.0).f_calc() f_obs = abs(dummy.structure_factors_from_scatterers( xray_structure = xray_structure, algorithm = sfg_params.algorithm, cos_sin_table = sfg_params.cos_sin_table).f_calc()) flags = f_obs.generate_r_free_flags(fraction=0.01, max_free=2000) fmodel = mmtbx.f_model.manager(xray_structure = xray_structure, f_obs = f_obs, r_free_flags = flags, target_name = "ls_wunit_k1", sf_and_grads_accuracy_params = sfg_params) fmodel.info(free_reflections_per_bin=250, max_number_of_bins=30).show_all() xray_structure.convert_to_isotropic() xray_structure.set_b_iso(value = 25.0) fmodel.update_xray_structure(xray_structure = xray_structure, update_f_calc = True) fmodel.info(free_reflections_per_bin=250, max_number_of_bins=30).show_all() print("*"*80) ###> TLS refinement against xray data if (not "--comprehensive" in sys.argv[1:]): number_of_macro_cycles = 1 max_number_of_iterations = 3 else: number_of_macro_cycles = 100 max_number_of_iterations = 50 for start_tls_value in [None]:#[0.0, tlsosA, None]: #for start_tls_value in [None]: print(" \n "+str(start_tls_value) + " \n ") fmodel_cp = fmodel.deep_copy() #for sc in fmodel_cp.xray_structure.scatterers(): # sc.flags.set_use_u_aniso(True) fmodel_cp.xray_structure.convert_to_anisotropic() if(start_tls_value is None): run_finite_differences_test = True else: run_finite_differences_test = False model.set_xray_structure(fmodel_cp.xray_structure) tls_refinement_manager = tools.tls_refinement( fmodel = fmodel_cp, model = model, selections = selections, selections_1d = None, refine_T = 1, refine_L = 1, refine_S = 1, number_of_macro_cycles = number_of_macro_cycles, max_number_of_iterations = max_number_of_iterations, start_tls_value = start_tls_value, run_finite_differences_test = run_finite_differences_test, eps = eps) u_cart = tls_refinement_manager.fmodel.xray_structure.scatterers().extract_u_cart( xray_structure.unit_cell()) if("--comprehensive" in sys.argv[1:]): format = "%10.6f %10.6f %10.6f %10.6f %10.6f %10.6f" counter = 0 if(start_tls_value == tlsosA): tolerance = 1.e-6 else: tolerance = 0.02 for m1,m2 in zip(u_cart_answer, u_cart): counter += 1 if(counter < 10): print("1=" + format % (m1[0],m1[1],m1[2],m1[3],m1[4],m1[5])) print("2=" + format % (m2[0],m2[1],m2[2],m2[3],m2[4],m2[5])) assert approx_equal(m1,m2, tolerance)
def run(args, command_name="phenix.fobs_minus_fobs_map", log=None): if (len(args) == 0): args = ["--help"] examples = """Examples: phenix.fobs_minus_fobs_map f_obs_1_file=data1.mtz f_obs_2_file=data2.sca \ f_obs_1_label=FOBS1 f_obs_2_label=FOBS2 model.pdb phenix.fobs_minus_fobs_map f_obs_1_file=data.mtz f_obs_2_file=data.mtz \ f_obs_1_label=FOBS1 f_obs_2_label=FOBS2 phase_source=model.pdb \ high_res=2.0 sigma_cutoff=2 scattering_table=neutron""" command_line = (iotbx_option_parser( usage="%s [options]" % command_name, description=examples).option("--silent", action="store_true", help="Suppress output to the screen."). enable_symmetry_comprehensive()).process(args=args) # if (log is None): log = sys.stdout if (not command_line.options.silent): utils.print_header("phenix.fobs_minus_fobs_map", out=log) print("Command line arguments: ", file=log) print(args, file=log) print(file=log) # processed_args = utils.process_command_line_args( args=command_line.args, cmd_cs=command_line.symmetry, master_params=fo_minus_fo_master_params(), absolute_angle_tolerance=5, absolute_length_tolerance=1, log=log, suppress_symmetry_related_errors=True) working_phil = processed_args.params if (not command_line.options.silent): print("*** Parameters:", file=log) working_phil.show(out=log) print(file=log) params = working_phil.extract() consensus_symmetry = None if (params.ignore_non_isomorphous_unit_cells): if (None in [ params.f_obs_1_file_name, params.f_obs_2_file_name, params.phase_source ]): raise Sorry( "The file parameters (f_obs_1_file_name, f_obs_2_file_name, " + "phase_source) must be specified explicitly when " + "ignore_non_isomorphous_unit_cells=True.") symm_manager = iotbx.symmetry.manager() pdb_in = iotbx.file_reader.any_file(params.phase_source, force_type="pdb") symm_manager.process_pdb_file(pdb_in) hkl_in_1 = iotbx.file_reader.any_file(params.f_obs_1_file_name, force_type="hkl") sg_err_1, uc_err_1 = symm_manager.process_reflections_file(hkl_in_1) hkl_in_2 = iotbx.file_reader.any_file(params.f_obs_2_file_name, force_type="hkl") sg_err_2, uc_err_2 = symm_manager.process_reflections_file(hkl_in_2) out = StringIO() symm_manager.show(out=out) if (sg_err_1) or (sg_err_2): raise Sorry(( "Incompatible space groups in input files:\n%s\nAll files " + "must have the same point group (and ideally the same space group). " + "Please note that any symmetry information in the PDB file will be " + "used first.") % out.getvalue()) elif (uc_err_1) or (uc_err_2): libtbx.call_back( message="warn", data= ("Crystal symmetry mismatch:\n%s\nCalculations will continue " + "using the symmetry in the PDB file (or if not available, the " + "first reflection file), but the maps should be treated with " + "extreme suspicion.") % out.getvalue()) crystal_symmetry = symm_manager.as_symmetry_object() else: processed_args = utils.process_command_line_args( args=command_line.args, cmd_cs=command_line.symmetry, master_params=fo_minus_fo_master_params(), suppress_symmetry_related_errors=False, absolute_angle_tolerance=5, absolute_length_tolerance=1, log=StringIO()) crystal_symmetry = processed_args.crystal_symmetry # pdb_file_names = processed_args.pdb_file_names if (len(processed_args.pdb_file_names) == 0): if (params.phase_source is not None): pdb_file_names = [params.phase_source] else: raise Sorry("No PDB file found.") # Extaract Fobs1, Fobs2 f_obss = [] if (len(processed_args.reflection_files) == 2): for reflection_file in processed_args.reflection_files: reflection_file_server = reflection_file_utils.reflection_file_server( crystal_symmetry=crystal_symmetry, force_symmetry=True, reflection_files=[reflection_file], err=null_out()) # XXX UGLY !!! try: parameters = utils.data_and_flags_master_params().extract() if (params.f_obs_1_label is not None): parameters.labels = [params.f_obs_1_label] determine_data_and_flags_result = utils.determine_data_and_flags( reflection_file_server=reflection_file_server, keep_going=True, parameters=parameters, log=null_out()) except: # intentional parameters = utils.data_and_flags_master_params().extract() if (params.f_obs_2_label is not None): parameters.labels = [params.f_obs_2_label] determine_data_and_flags_result = utils.determine_data_and_flags( reflection_file_server=reflection_file_server, keep_going=True, parameters=parameters, log=null_out()) f_obss.append(determine_data_and_flags_result.f_obs) else: if ([params.f_obs_1_file_name, params.f_obs_2_file_name].count(None) == 2): raise Sorry("No reflection data file found.") for file_name, label in zip( [params.f_obs_1_file_name, params.f_obs_2_file_name], [params.f_obs_1_label, params.f_obs_2_label]): reflection_file = reflection_file_reader.any_reflection_file( file_name=file_name, ensure_read_access=False) reflection_file_server = reflection_file_utils.reflection_file_server( crystal_symmetry=crystal_symmetry, force_symmetry=True, reflection_files=[reflection_file], err=null_out()) parameters = utils.data_and_flags_master_params().extract() if (label is not None): parameters.labels = [label] determine_data_and_flags_result = utils.determine_data_and_flags( reflection_file_server=reflection_file_server, parameters=parameters, keep_going=True, log=null_out()) f_obss.append(determine_data_and_flags_result.f_obs) if (len(f_obss) != 2): raise Sorry(" ".join(errors)) if (not command_line.options.silent): for ifobs, fobs in enumerate(f_obss): print("*** Summary for data set %d:" % ifobs, file=log) fobs.show_comprehensive_summary(f=log) print(file=log) pdb_combined = combine_unique_pdb_files(file_names=pdb_file_names) pdb_combined.report_non_unique(out=log) if (len(pdb_combined.unique_file_names) == 0): raise Sorry("No coordinate file given.") # raw_recs = flex.std_string() for rec in pdb_combined.raw_records: if (rec.upper().count("CRYST1") == 0): raw_recs.append(rec) raw_recs.append( iotbx.pdb.format_cryst1_record(crystal_symmetry=crystal_symmetry)) # pdb_in = iotbx.pdb.input(source_info=None, lines=raw_recs) model = mmtbx.model.manager(model_input=pdb_in) d_min = min(f_obss[0].d_min(), f_obss[1].d_min()) model.setup_scattering_dictionaries( scattering_table=params.scattering_table, d_min=d_min) xray_structure = model.get_xray_structure() hierarchy = model.get_hierarchy() # omit_sel = flex.bool(hierarchy.atoms_size(), False) if (params.advanced.omit_selection is not None): print("Will omit selection from phasing model:", file=log) print(" " + params.advanced.omit_selection, file=log) omit_sel = hierarchy.atom_selection_cache().selection( params.advanced.omit_selection) print("%d atoms selected for removal" % omit_sel.count(True), file=log) del hierarchy xray_structure = xray_structure.select(~omit_sel) if (not command_line.options.silent): print("*** Model summary:", file=log) xray_structure.show_summary(f=log) print(file=log) info0 = f_obss[0].info() info1 = f_obss[1].info() f_obss[0] = f_obss[0].resolution_filter( d_min=params.high_resolution, d_max=params.low_resolution).set_info(info0) f_obss[1] = f_obss[1].resolution_filter( d_min=params.high_resolution, d_max=params.low_resolution).set_info(info1) if (params.sigma_cutoff is not None): for i in [0, 1]: if (f_obss[i].sigmas() is not None): sel = f_obss[i].data( ) > f_obss[i].sigmas() * params.sigma_cutoff f_obss[i] = f_obss[i].select(sel).set_info(info0) for k, f_obs in enumerate(f_obss): if (f_obs.indices().size() == 0): raise Sorry( "No data left in array %d (labels=%s) after filtering!" % (k + 1, f_obs.info().label_string())) output_file_name = params.output_file if (output_file_name is None) and (params.file_name_prefix is not None): output_file_name = "%s_%s.mtz" % (params.file_name_prefix, params.job_id) output_files = compute_fo_minus_fo_map( data_arrays=f_obss, xray_structure=xray_structure, log=log, silent=command_line.options.silent, output_file=output_file_name, peak_search=params.find_peaks_holes, map_cutoff=params.map_cutoff, peak_search_params=params.peak_search, multiscale=params.advanced.multiscale, anomalous=params.advanced.anomalous).file_names return output_files
def run(args, log=sys.stdout): print >> log, "-" * 79 print >> log, legend print >> log, "-" * 79 inputs = mmtbx.utils.process_command_line_args( args=args, master_params=master_params()) params = inputs.params.extract() # estimate resolution d_min = params.resolution broadcast(m="Map resolution:", log=log) if (d_min is None): raise Sorry("Resolution is required.") print >> log, " d_min: %6.4f" % d_min # model broadcast(m="Input PDB:", log=log) file_names = inputs.pdb_file_names if (len(file_names) != 1): raise Sorry("PDB file has to given.") if (inputs.crystal_symmetry is None): raise Sorry("No crystal symmetry defined.") pdb_inp = iotbx.pdb.input(file_name=file_names[0]) model = mmtbx.model.manager(model_input=pdb_inp, crystal_symmetry=inputs.crystal_symmetry, build_grm=True) if model.get_number_of_models() > 1: raise Sorry("Only one model allowed.") model.setup_scattering_dictionaries( scattering_table=params.scattering_table) model.get_xray_structure().show_summary(f=log, prefix=" ") broadcast(m="Input map:", log=log) if (inputs.ccp4_map is None): raise Sorry("Map file has to given.") inputs.ccp4_map.show_summary(prefix=" ") map_data = inputs.ccp4_map.map_data() print >> log, " Actual map (min,max,mean):", \ map_data.as_1d().min_max_mean().as_tuple() make_sub_header("Histogram of map values", out=log) md = map_data.as_1d() show_histogram(data=md, n_slots=10, data_min=flex.min(md), data_max=flex.max(md), log=log) # shift origin if needed soin = maptbx.shift_origin_if_needed( map_data=map_data, sites_cart=model.get_sites_cart(), crystal_symmetry=model.crystal_symmetry()) map_data = soin.map_data model.set_sites_cart(soin.sites_cart, update_grm=True) #### # Compute and show all stats #### broadcast(m="Model statistics:", log=log) make_sub_header("Overall", out=log) info = mmtbx.model.statistics.info(model=model) info.geometry.show() # XXX - these are not available anymore due to refactoring # make_sub_header("Histogram of devations from ideal bonds", out=log) # show_histogram(data=ms.bond_deltas, n_slots=10, data_min=0, data_max=0.2, # log=log) # # # make_sub_header("Histogram of devations from ideal angles", out=log) # show_histogram(data=ms.angle_deltas, n_slots=10, data_min=0, data_max=30., # log=log) # # # make_sub_header("Histogram of non-bonded distances", out=log) # show_histogram(data=ms.nonbonded_distances, n_slots=10, data_min=0, # data_max=5., log=log) # make_sub_header("Histogram of ADPs", out=log) info.adp.show(log=log) # bs = xrs.extract_u_iso_or_u_equiv()*adptbx.u_as_b(1.) # show_histogram(data=bs, n_slots=10, data_min=flex.min(bs), # data_max=flex.max(bs), log=log) # # Compute CC broadcast(m="Map-model CC (overall):", log=log) five_cc_result = mmtbx.maps.correlation.five_cc( map=map_data, xray_structure=model.get_xray_structure(), d_min=d_min) atom_radius = five_cc_result.atom_radius if atom_radius is None: atom_radius = five_cc_result._atom_radius() print >> log, " CC_mask : %6.4f" % five_cc_result.result.cc_mask print >> log, " CC_volume: %6.4f" % five_cc_result.result.cc_volume print >> log, " CC_peaks : %6.4f" % five_cc_result.result.cc_peaks # Compute FSC(map, model) broadcast(m="Model-map FSC:", log=log) fsc = mmtbx.maps.correlation.fsc_model_vs_map( xray_structure=model.get_xray_structure(), map=map_data, atom_radius=atom_radius, d_min=d_min) fsc.show(prefix=" ") # Local CC cc_calculator = mmtbx.maps.correlation.from_map_and_xray_structure_or_fmodel( xray_structure=model.get_xray_structure(), map_data=map_data, d_min=d_min) broadcast(m="Map-model CC (local):", log=log) # per residue print >> log, "Per residue:" residue_results = list() ph = model.get_hierarchy() xrs = model.get_xray_structure() for rg in ph.residue_groups(): cc = cc_calculator.cc(selection=rg.atoms().extract_i_seq()) chain_id = rg.parent().id print >> log, " chain id: %s resid %s: %6.4f" % (chain_id, rg.resid(), cc) # per chain print >> log, "Per chain:" for chain in ph.chains(): print >> log, " chain %s: %6.4f" % ( chain.id, cc_calculator.cc(selection=chain.atoms().extract_i_seq())) # per residue detailed counts print >> log, "Per residue (histogram):" crystal_gridding = maptbx.crystal_gridding( unit_cell=xrs.unit_cell(), space_group_info=xrs.space_group_info(), pre_determined_n_real=map_data.accessor().all()) f_calc = xrs.structure_factors(d_min=d_min).f_calc() fft_map = miller.fft_map(crystal_gridding=crystal_gridding, fourier_coefficients=f_calc) fft_map.apply_sigma_scaling() map_model = fft_map.real_map_unpadded() sites_cart = xrs.sites_cart() cc_per_residue = flex.double() for rg in ph.residue_groups(): cc = mmtbx.maps.correlation.from_map_map_atoms( map_1=map_data, map_2=map_model, sites_cart=sites_cart.select(rg.atoms().extract_i_seq()), unit_cell=xrs.unit_cell(), radius=2.) cc_per_residue.append(cc) show_histogram(data=cc_per_residue, n_slots=10, data_min=-1., data_max=1.0, log=log)
raise Sorry("No coordinate file given.") raw_records = pdb_combined.raw_records try: pdb_inp = iotbx.pdb.input(source_info=None, lines=flex.std_string(raw_records)) except ValueError, e: raise Sorry("Model format (PDB or mmCIF) error:\n%s" % str(e)) model = mmtbx.model.manager(model_input=pdb_inp, crystal_symmetry=crystal_symmetry, log=StringIO()) # scattering_table = params.scattering_table exptl_method = pdb_inp.get_experiment_type() if (exptl_method is not None) and ("NEUTRON" in exptl_method): scattering_table = "neutron" model.setup_scattering_dictionaries(scattering_table=scattering_table, d_min=f_obs.d_min()) # # Model vs data # show_header(l="Model vs Data:", log=log) fmodel = mmtbx.f_model.manager(xray_structure=model.get_xray_structure(), f_obs=f_obs, r_free_flags=r_free_flags, twin_law=params.twin_law) fmodel.update_all_scales(update_f_part1=True) fmodel.show(log=log, show_header=False, show_approx=False) print >> log, " r_work: %6.4f" % fmodel.r_work() if (test_flag_value is not None): print >> log, " r_free: %6.4f" % fmodel.r_free() else: print >> log, " r_free: None"