def run(mtz_data_file, d_col, mtz_template_file, t_col, mtz_out_file): # READ DATA MTZ miller_arrays_data = reflection_file_reader.any_reflection_file(file_name=mtz_data_file).as_miller_arrays() labels = [ma.info().labels[0] for ma in miller_arrays_data] try: F_data = miller_arrays_data[labels.index(d_col)] except: print "ERROR: column label not found in input data file" sys.exit() # READ TEMPLATE MTZ miller_arrays_template = reflection_file_reader.any_reflection_file(file_name=mtz_template_file).as_miller_arrays() labels = [ma.info().labels[0] for ma in miller_arrays_template] try: F_template = miller_arrays_template[labels.index(t_col)] except: print "ERROR: column label not found in reference template file" sys.exit() # SELECT REFLECTIONS # ~ print F_template.size() # ~ print F_data.size() F_data, tmp = F_data.common_sets(F_template) # ~ print tmp.size() # ~ print F_data.size() # WRITE NEW MTZ mtz_dataset = F_data.as_mtz_dataset(column_root_label="FP") mtz_object = mtz_dataset.mtz_object() mtz_object.write(file_name=mtz_out_file)
def exercise_get_experimental_phases(): crystal_symmetry = crystal.symmetry( unit_cell=(30,31,32,85,95,100), space_group_symbol="P 1") miller_set = miller.build_set( crystal_symmetry=crystal_symmetry, anomalous_flag=False, d_min=3) input_array = miller_set.array( data=flex.hendrickson_lattman(miller_set.indices().size(), (0,0,0,0))) mtz_dataset = input_array.as_mtz_dataset(column_root_label="P") mtz_dataset.mtz_object().write("tmp.mtz") reflection_files = [reflection_file_reader.any_reflection_file( file_name="tmp.mtz")] err = StringIO() reflection_file_srv = reflection_file_server( crystal_symmetry=crystal_symmetry, force_symmetry=True, reflection_files=reflection_files, err=err) experimental_phases = reflection_file_srv.get_experimental_phases( file_name=None, labels=None, ignore_all_zeros=False, parameter_scope="experimental_phases") assert str(experimental_phases.info()) == "tmp.mtz:PA,PB,PC,PD" try: reflection_file_srv.get_experimental_phases( file_name=None, labels=None, ignore_all_zeros=True, parameter_scope="experimental_phases") except Sorry, e: assert str(e) == "No array of experimental phases found." assert err.getvalue() == """\
def extract_miller_array_from_file(file_name, label=None, type=None, log=None): if(log is None): log = sys.stdout assert type in ["complex", "real", None] result = None miller_arrays = reflection_file_reader.any_reflection_file(file_name = file_name).as_miller_arrays() def get_flag(ma): return (type == "complex" and ma.is_complex_array()) or \ (type == "real" and ma.is_real_array()) or \ type is None print >> log, " Available suitable arrays:" suitable_arrays = [] suitable_labels = [] for ma in miller_arrays: if(get_flag(ma=ma)): print >> log, " ", ma.info().label_string() suitable_arrays.append(ma) suitable_labels.append(ma.info().label_string()) print >> log if( len(suitable_arrays) == 0): raise Sorry("No suitable arrays.") elif(len(suitable_arrays) == 1): result = suitable_arrays[0] elif(len(suitable_arrays) > 1): if(label is None): msg='''Multiple choices available. No map coefficients array selected. See choices listed above and use "label=" to select one. Example: label="2FOFCWT,PH2FOFCWT"''' raise Sorry(msg) else: for ma in miller_arrays: if(get_flag(ma=ma) and (ma.info().label_string() == label)): print >> log, " Selected:", ma.info().label_string() result = ma return result
def load_reflections_file (self, file_name, **kwds) : if (isinstance(file_name, unicode)) : file_name = str(file_name) if (file_name != "") : from iotbx.reflection_file_reader import any_reflection_file from cctbx import miller from scitbx.array_family import flex try : hkl_file = any_reflection_file(file_name) except Exception, e : raise Sorry(str(e)) arrays = hkl_file.as_miller_arrays(merge_equivalents=True) f_obs = f_model = None for array in arrays : labels = array.info().label_string() if labels.startswith("F-obs-filtered") : f_obs = array elif labels.startswith("F-model") : f_model = array if (f_obs is None) or (f_model is None) : raise Sorry("This does not appear to be a phenix.refine output "+ "file. The MTZ file should contain data arrays for the filtered "+ "amplitudes (F-obs) and F-model.") f_delta = f_obs.customized_copy(sigmas=None, data=flex.abs(f_obs.data()-abs(f_model).data())).set_info( miller.array_info(labels=["abs(F_obs - F_model)"])) self.set_miller_array(f_delta)
def _try_as_hkl (self) : from iotbx.reflection_file_reader import any_reflection_file # XXX this is unfortunate, but unicode breaks Boost.Python extensions hkl_file = any_reflection_file(str(self.file_name)) assert (hkl_file.file_type() is not None), "Not a valid reflections file." self._file_type = "hkl" self._file_object = hkl_file
def check(tuple_calc, selection, prefix): miller_arrays = reflection_file_reader.any_reflection_file(file_name = prefix+"polder_map_coeffs.mtz").as_miller_arrays() mc_polder = None for ma in miller_arrays: lbl = ma.info().label_string() if(lbl == "mFo-DFc_polder,PHImFo-DFc_polder"): mc_polder = ma.deep_copy() assert (mc_polder is not None) cg = maptbx.crystal_gridding( unit_cell = mc_polder.unit_cell(), d_min = mc_polder.d_min(), resolution_factor = 0.25, space_group_info = mc_polder.space_group_info()) map_polder = get_map(cg=cg, mc=mc_polder) pdb_hierarchy = iotbx.pdb.input( source_info=None, lines=pdb_str).construct_hierarchy() sel = pdb_hierarchy.atom_selection_cache().selection(string = selection) sites_cart_lig = pdb_hierarchy.atoms().extract_xyz().select(sel) sites_frac_lig = mc_polder.unit_cell().fractionalize(sites_cart_lig) mp = get_map_stats( map = map_polder, sites_frac = sites_frac_lig) # mmm_mp = mp.min_max_mean().as_tuple() print "Polder map : %7.3f %7.3f %7.3f" % mmm_mp assert approx_equal(mmm_mp, tuple_calc, eps=1.0), "\ calculated is %s and expected is %s" % (mmm_mp, tuple_calc)
def run(params): hkl_in = reflection_file_reader.any_reflection_file(params.hklin) miller_arrays = hkl_in.as_miller_arrays(merge_equivalents=False) miller_arrays = filter(lambda x: x.is_xray_intensity_array(), miller_arrays) print "Reading intensity data from %s" % params.hklin for ma in miller_arrays: print " %s" % ma.info() if len(miller_arrays) > 1: print "Using %s for analysis" % miller_arrays[0].info() elif len(miller_arrays) == 0: print "Error: No intensity data!" return iobs = miller_arrays[0] est = estimate_resolution_based_on_cc_half(iobs, params.cc_one_half_min, params.cc_half_tol, params.n_bins, params.anomalous, sys.stdout) print print "Suggested cutoff= %.2f A (CC1/2= %.4f)" %(est.d_min, est.cc_at_d_min) print "# Treated as *%s* data" % ("anomalous" if params.anomalous else "non-anomalous") if params.show_plot: est.show_plot(filename="cchalf_plot.pdf")
def get_miller_f_from_reflection_file(hklin): flag_hklin_found = False miller_array_f = None if hklin is not None: flag_hklin_found = True reflection_file = reflection_file_reader.any_reflection_file(hklin) miller_arrays = reflection_file.as_miller_arrays() is_found_as_intensity_array = False is_found_as_amplitude_array = False is_found_as_complex_array = False for miller_array in miller_arrays: if miller_array.is_xray_amplitude_array(): miller_array_f = miller_array.deep_copy() is_found_as_amplitude_array = True break elif miller_array.is_xray_intensity_array(): is_found_as_intensity_array = True miller_array_converted_to_amplitude = miller_array.enforce_positive_amplitudes() elif miller_array.is_complex_array(): is_found_as_complex_array = True miller_array_converted_to_amplitude = miller_array.amplitudes() if is_found_as_amplitude_array == False: if is_found_as_intensity_array or is_found_as_complex_array: miller_array_f = miller_array_converted_to_amplitude.deep_copy() else: flag_hklin_found = False return flag_hklin_found, miller_array_f
def run(args, command_name="iotbx.r_free_flags_accumulation"): def raise_usage(): raise Usage("%s reflection_file [label=value]" % command_name) if (len(args) == 0 or "--help" in args or "-h" in args): raise_usage() phil_objects = [] argument_interpreter = master_params.command_line_argument_interpreter( home_scope="r_free_flags_accumulation") reflection_files = [] for arg in args: if (os.path.isfile(arg)): refl_file = reflection_file_reader.any_reflection_file( file_name=arg) if (refl_file.file_type() is not None): reflection_files.append(refl_file) arg = None if (arg is not None): try: command_line_params = argument_interpreter.process(arg=arg) except KeyboardInterrupt: raise except Exception: raise Sorry("Unknown file or keyword: %s" % arg) else: phil_objects.append(command_line_params) params_scope = master_params.fetch(sources=phil_objects).extract() params = params_scope.r_free_flags_accumulation srv = reflection_file_utils.reflection_file_server( reflection_files=reflection_files) r_free_flags, test_flag_value = srv.get_r_free_flags( file_name=params.file_name, label=params.label, test_flag_value=params.test_flag_value, disable_suitability_test=params.disable_suitability_test, parameter_scope="r_free_flags_accumulation") params.file_name = r_free_flags.info().source params.label = r_free_flags.info().label_string() params.test_flag_value = test_flag_value if (params.output is None): params.output = os.path.basename(params.file_name) \ + ".r_free_flags_accumulation" working_params = master_params.format(python_object=params_scope) working_params.show() print print "#phil __OFF__" r_free_flags = r_free_flags.array( data=r_free_flags.data()==params.test_flag_value) r_free_flags.show_r_free_flags_info() print accu = r_free_flags \ .sort(by_value="resolution") \ .r_free_flags_accumulation() print "Writing file: %s" % show_string(params.output) print " 1. column: reflection counts, sorted by resolution" print " 2. column: number of free reflections / total number of reflections" sys.stdout.flush() out = open(params.output, "w") for line in params.plot_header: print >> out, line for c,f in zip(accu.reflection_counts, accu.free_fractions): print >> out, c, f out.close() print sys.stdout.flush()
def mtz2ccp4maps(filename, prefix, amplitudes, phases): ''' Creates a temporary directory and dumps all maps from the given MTZ file into this directory as CCP4 maps files. Returns the path of the temporary directory. ''' import tempfile from iotbx.reflection_file_reader import any_reflection_file hkl_in = any_reflection_file(file_name=filename) temp_dir = tempfile.mkdtemp() for i_map, array in enumerate(hkl_in.as_miller_arrays()): if not array.is_complex_array(): continue labels = array.info().labels if amplitudes and [amplitudes, phases] != labels: continue fft_map = array.fft_map(resolution_factor=0.25).apply_sigma_scaling() map_filename = os.path.join(temp_dir, prefix + '_' + '_'.join(labels)) if hasattr(fft_map, 'as_ccp4_map'): fft_map.as_ccp4_map(file_name=map_filename + '.ccp4') else: fft_map.as_xplor_map(file_name=map_filename + '.xplor') return temp_dir
def get_f_obs_and_flags(reflection_file_name, crystal_symmetry, f_obs_label = None, r_free_flags_label = None, log = None): reflection_files = [] reflection_files.append(reflection_file_reader.any_reflection_file( file_name = reflection_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_files, err = log) parameters = mmtbx.utils.data_and_flags_master_params().extract() if(f_obs_label is not None): parameters.labels = command_line.options.f_obs_label if(r_free_flags_label is not None): parameters.r_free_flags.label = command_line.options.r_free_flags_label determine_data_and_flags_result = mmtbx.utils.determine_data_and_flags( reflection_file_server = reflection_file_server, parameters = parameters, keep_going = True, log = log) f_obs = determine_data_and_flags_result.f_obs r_free_flags = determine_data_and_flags_result.r_free_flags return f_obs, r_free_flags
def get_miller_array_from_mtz(mtz_filename): flag_hklisoin_found = False miller_array_iso = None if mtz_filename is not None: flag_hklisoin_found = True reflection_file_iso = reflection_file_reader.any_reflection_file(mtz_filename) miller_arrays_iso=reflection_file_iso.as_miller_arrays() is_found_iso_as_intensity_array = False is_found_iso_as_amplitude_array = False for miller_array in miller_arrays_iso: if miller_array.is_xray_intensity_array(): miller_array_iso = miller_array.deep_copy() is_found_iso_as_intensity_array = True break elif miller_array.is_xray_amplitude_array(): is_found_iso_as_amplitude_array = True miller_array_converted_to_intensity = miller_array.as_intensity_array() if is_found_iso_as_intensity_array == False: if is_found_iso_as_amplitude_array: miller_array_iso = miller_array_converted_to_intensity.deep_copy() else: flag_hklisoin_found = False if miller_array_iso is not None: perm = miller_array_iso.sort_permutation(by_value="resolution", reverse=True) miller_array_iso = miller_array_iso.select(perm) return flag_hklisoin_found, miller_array_iso
def __init__(self, mtz_file, params=None): print 'Reading reflections from %s' %mtz_file from iotbx.reflection_file_reader import any_reflection_file result = any_reflection_file(mtz_file) assert result.file_type() == 'ccp4_mtz' mtz_object = result.file_content() mtz_object.show_summary() intensities = None for ma in result.as_miller_arrays(merge_equivalents=False): if (params.anomalous and ma.info().labels == ['I(+)', 'SIGI(+)', 'I(-)', 'SIGI(-)']): assert ma.anomalous_flag() intensities = ma.merge_equivalents().array() # XXX why is this necessary? elif (not params.anomalous and ma.info().labels == ['IMEAN', 'SIGIMEAN']): assert not ma.anomalous_flag() intensities = ma assert intensities.is_xray_intensity_array() amplitudes = intensities.french_wilson(params=params) assert amplitudes.is_xray_amplitude_array() mtz_dataset = mtz_object.crystals()[1].datasets()[0] mtz_dataset.add_miller_array(amplitudes, column_root_label='F') mtz_object.add_history('cctbx.french_wilson analysis') print 'Writing reflections to %s' %(params.hklout) mtz_object.show_summary() mtz_object.write(params.hklout)
def get_array(file_name=None,labels=None): print "Reading from %s" %(file_name) from iotbx import reflection_file_reader reflection_file = reflection_file_reader.any_reflection_file( file_name=file_name) array_to_use=None if labels: for array in reflection_file.as_miller_arrays(): if ",".join(array.info().labels)==labels: array_to_use=array break else: for array in reflection_file.as_miller_arrays(): if array.is_complex_array() or array.is_xray_amplitude_array() or\ array.is_xray_intensity_array(): array_to_use=array break if not array_to_use: text="" for array in reflection_file.as_miller_arrays(): text+=" %s " %(",".join(array.info().labels)) raise Sorry("Cannot identify array to use...possibilities: %s" %(text)) print "Using the array %s" %(",".join(array_to_use.info().labels)) return array_to_use
def get_rfree(file_name): """Return the Rfree label""" reflection_file = reflection_file_reader.any_reflection_file(file_name=file_name) if not reflection_file.file_type()=="ccp4_mtz": raise RuntimeError("File is not of type ccp4_mtz: {0}".format(file_name)) return _get_rfree(reflection_file.file_content())
def _import(self, event): self._gauge.Show() self._gauge_label.Show() self.Fit() pdb = str(self._pdb_entry.GetValue()) if not os.path.exists(self._root + '/temp'): os.mkdir(self._root + '/temp') self._set_status(0, 'Downloading PDB') urllib.urlretrieve('http://www.rcsb.org/pdb/files/' + pdb.lower() + '.pdb.gz', self._root + '/temp/' + pdb.lower() + '.pdb.gz') self._set_status(1, 'Uncompressing PDB') out = open(self._root + '/temp/' + pdb.lower() + '.pdb', 'wb') out.write(gzip.open(self._root + '/temp/' + pdb.lower() + '.pdb.gz', 'rb').read()) out.close() self._set_status(2, 'Converting PDB to INS') PDBImporter(self._root + '/temp/' + pdb.lower() + '.pdb', self._root) self._set_status(3, 'Downloading SFs') urllib.urlretrieve('http://www.rcsb.org/pdb/files/r' + pdb.upper() + 'sf.ent.gz', self._root + '/temp/r' + pdb.upper() + 'sf.ent.gz') self._set_status(4, 'Uncompressing SFs') sff = self._root + '/temp/' + pdb.lower() + '.cif' out = open(sff, 'wb') out.write(gzip.open(self._root + '/temp/r' + pdb.upper() + 'sf.ent.gz', 'rb').read()) out.close() self._set_status(5, 'Finding Columns') if os.path.exists(sff): m = reflection_file_reader.any_reflection_file(sff) fs = [] rs = [] for col in m.as_miller_arrays(): if (col.is_xray_intensity_array() or col.is_xray_amplitude_array()) and not col.anomalous_flag(): fs.append(col.info().label_string()) elif col.info().label_string().find('status') > -1: rs.append(col.info().label_string()) self._set_status(6, 'Converting CIF to HKL') if len(fs) > 0: for f in fs: if len(rs) > 0: CIFImporter(sff, f, rs[0], self._root) else: CIFImporter(sff, f, '', self._root, True) self._set_status(7, 'Cleaning Up...') os.remove(self._root + '/temp/' + pdb.lower() + '.pdb.gz') os.remove(self._root + '/temp/' + pdb.lower() + '.pdb') os.remove(self._root + '/temp/r' + pdb.upper() + 'sf.ent.gz') os.remove(self._root + '/temp/' + pdb.lower() + '.cif') self._set_status(8, 'Finished') self._close('') wx.MessageBox('Input files successfully generated for ' + pdb, 'Sucess', style=wx.OK | wx.CENTRE)
def change_space_group (file_name, space_group_info) : """ Update the space group in an MTZ file, writing it in place. """ mtz_in = reflection_file_reader.any_reflection_file(file_name) assert (mtz_in.file_type() == "ccp4_mtz") mtz_object = mtz_in.file_content() mtz_new = mtz_object.set_space_group_info(space_group_info) mtz_new.write(file_name)
def get_target_map(reflection_file_name, log=sys.stderr) : miller_arrays = reflection_file_reader.any_reflection_file(file_name = reflection_file_name).as_miller_arrays() ma = miller_arrays[0] fft_map = ma.fft_map(resolution_factor=0.25) fft_map.apply_sigma_scaling() print >> log, "\nUsing sigma scaled map.\n" target_map = fft_map.real_map_unpadded() return target_map
def resolve_indexing_ambiguity_using_reference(dirs, reidx_ops, reference_file): from iotbx import reflection_file_reader hkl_ref = filter(lambda x: x.is_xray_intensity_array(), reflection_file_reader.any_reflection_file(reference_file).as_miller_arrays(merge_equivalents=False)) if len(hkl_ref) == 0: raise Exception("No intensity data in %s"%reference_file) ref_data = hkl_ref[0].merge_equivalents(use_internal_variance=False).array() data = {} # Read all (strong) data for wd in dirs: print "reading", wd tmp = read_strong_i_from_xds_ascii(os.path.join(wd, "XDS_ASCII.HKL")) if tmp is None: continue data[wd] = tmp # Compare with reference best_op = map(lambda x: 0, xrange(len(dirs))) for i in xrange(len(dirs)): if dirs[i] not in data: continue data_i = data[dirs[i]] cc_list = [] idx_max = 0 for k, rop in enumerate(reidx_ops): if k == 0: data_i_ = data_i else: data_i_ = data_i.customized_copy(indices=rop.apply(data_i.indices())) cc_list.append(get_cc(data_i_, ref_data)) if cc_list[k] is not None: if cc_list[k] > cc_list[idx_max]: idx_max = k if len(cc_list) - cc_list.count(None) < 2: print i,"skip" continue cc_max = cc_list[idx_max] print i, for cc in cc_list: print cc, print best_op[i] = idx_max print "\n Best reindexing operators" print "=================================\n" for i in xrange(len(dirs)): print "%.3d op= %d %s" % (i, best_op[i], dirs[i]) print "\nApplying.." for i, opi in enumerate(best_op): if opi == 0: continue # XXX treat!! print "Done."
def __init__(self, refinement_type = 'None'): self.pdb_structure = pdb.hierarchy.input(command_line_args.pdb_input) self.get_crystal_symmetry() self.xray_structure = self.pdb_structure.input.xray_structure_simple() self.miller_arrays = any_reflection_file(command_line_args.reflection_input).as_miller_arrays() self.miller_arrays_work_test_partition() return
def run(processed_args, params): if(params.scattering_table not in ["n_gaussian","wk1995", "it1992","neutron"]): raise Sorry("Incorrect scattering_table.") crystal_symmetry = None crystal_symmetries = [] for f in [str(params.pdb_file_name), str(params.reflection_file_name)]: cs = crystal_symmetry_from_any.extract_from(f) if(cs is not None): crystal_symmetries.append(cs) if(len(crystal_symmetries) == 1): crystal_symmetry = crystal_symmetries[0] elif(len(crystal_symmetries) == 0): raise Sorry("No crystal symmetry found.") else: if(not crystal_symmetries[0].is_similar_symmetry(crystal_symmetries[1])): raise Sorry("Crystal symmetry mismatch between different files.") crystal_symmetry = crystal_symmetries[0] f_obs = None r_free_flags = None if(params.reflection_file_name is not None): reflection_file = reflection_file_reader.any_reflection_file( file_name = params.reflection_file_name, ensure_read_access = True) rfs = reflection_file_server( crystal_symmetry = crystal_symmetry, reflection_files = [reflection_file]) parameters = utils.data_and_flags_master_params().extract() if(params.data_labels is not None): parameters.labels = [processed_args.data_labels] determine_data_and_flags_result = utils.determine_data_and_flags( reflection_file_server = rfs, parameters = parameters, keep_going = True, log = StringIO()) f_obs = determine_data_and_flags_result.f_obs r_free_flags = determine_data_and_flags_result.r_free_flags if(r_free_flags is None): r_free_flags=f_obs.array(data=flex.bool(f_obs.data().size(), False)) test_flag_value=None xray_structure = iotbx.pdb.input(file_name = params.pdb_file_name).xray_structure_simple() xray_structure_da = None if(params.external_da_pdb_file_name is not None): xray_structure_da = iotbx.pdb.input(file_name = params.external_da_pdb_file_name).xray_structure_simple() if(f_obs is not None): f_obs = f_obs.resolution_filter(d_min = params.high_resolution, d_max = params.low_resolution) r_free_flags = r_free_flags.resolution_filter(d_min = params.high_resolution, d_max = params.low_resolution) # assert params.mode in ["build", "build_and_refine"] grow_density(f_obs = f_obs, r_free_flags = r_free_flags, xray_structure = xray_structure, xray_structure_da = xray_structure_da, params = params)
def _refresh(self): m = reflection_file_reader.any_reflection_file(self._browse.file()) self._inputs[3].Clear() self._inputs[5].Clear() for col in m.as_miller_arrays(): if col.is_xray_intensity_array() or col.is_xray_amplitude_array(): self._inputs[3].Append(col.info().label_string()) else: self._inputs[5].Append(col.info().label_string())
def npp(hklin): from iotbx.reflection_file_reader import any_reflection_file from xia2.Toolkit.NPP import npp_ify, mean_variance from scitbx.array_family import flex import math import sys reader = any_reflection_file(hklin) mtz_object = reader.file_content() intensities = [ma for ma in reader.as_miller_arrays(merge_equivalents=False) if ma.info().labels == ['I', 'SIGI']][0] indices = intensities.indices() # merging: use external variance i.e. variances derived from SIGI column merger = intensities.merge_equivalents(use_internal_variance=False) mult = merger.redundancies().data() imean = merger.array() unique = imean.indices() iobs = imean.data() # scale up variance to account for sqrt(multiplicity) effective scaling variobs = (imean.sigmas() ** 2) * mult.as_double() all = flex.double() cen = flex.double() for hkl, i, v, m in zip(unique, iobs, variobs, mult): # only consider if meaningful number of observations if m < 3: continue sel = indices == hkl data = intensities.select(sel).data() assert(m == len(data)) _x, _y = npp_ify(data, input_mean_variance=(i,v)) # perform linreg on (i) all data and (ii) subset between +/- 2 sigma sel = (flex.abs(_x) < 2) _x_ = _x.select(sel) _y_ = _y.select(sel) fit_all = flex.linear_regression(_x, _y) fit_cen = flex.linear_regression(_x_, _y_) all.append(fit_all.slope()) cen.append(fit_cen.slope()) print '%3d %3d %3d' % hkl, '%.2f %.2f %.2f' % (i, v, i/math.sqrt(v)), \ '%.2f %.2f' % (fit_all.slope(), fit_cen.slope()), '%d' % m sys.stderr.write('Mean gradients: %.2f %.2f\n' % (flex.sum(all) / all.size(), flex.sum(cen) / cen.size()))
def process_other (self, arg) : if ("=" in arg) : fields = arg.split("=") if (len(fields) == 2) and (fields[1] in ["amplitudes", "intensities", "hklf3", "hklf4"]) : from iotbx import reflection_file_reader hkl_in = reflection_file_reader.any_reflection_file(arg) if (hkl_in.file_type() is not None) : return iotbx.phil.parse("%s=%s" % (self.reflection_file_def, arg)) return False
def get_map_coeffs_from_file( map_coeffs_file=None, map_coeffs_labels=None): from iotbx import reflection_file_reader reflection_file=reflection_file_reader.any_reflection_file( map_coeffs_file) mtz_content=reflection_file.file_content() for ma in reflection_file.as_miller_arrays(merge_equivalents=True): if not ma.is_complex_array(): continue labels=",".join(ma.info().labels) if not map_coeffs_labels or labels==map_coeffs_labels: # take it return ma
def read_data(file_name, labels, xs, log=None): if log is None: log=sys.stdout if not os.path.isfile(file_name): raise Sorry("No such file: >%s<"%(file_name) ) reflection_file = reflection_file_reader.any_reflection_file( file_name= file_name) miller_arrays = reflection_file.as_miller_arrays(crystal_symmetry=xs) label_table = reflection_file_utils.label_table(miller_arrays) return label_table.select_array( label=labels, command_line_switch="xray_data.labels", f=log)
def read_reference(mtz_file): from iotbx import reflection_file_reader reflection_file = reflection_file_reader.any_reflection_file( file_name=mtz_file) reference = None for miller_array in reflection_file.as_miller_arrays(): label = miller_array.info().labels[0].lower() if label.find('imean') >= 0: reference = miller_array break assert reference is not None return reference.map_to_asu()
def smtbx_refinement_model_from(cls, ins_or_res=None, hkl=None, fo_sq=None, strictly_shelxl=True): import os from iotbx.reflection_file_reader import any_reflection_file import iotbx.builders if ins_or_res is None: assert hkl is not None root, _ = os.path.splitext(hkl) ins = "%s.ins" % root res = "%s.res" % root ins_exists = os.path.isfile(ins) res_exists = os.path.isfile(res) assert ins_exists or res_exists if res_exists: ins_or_res = res elif ins_exists: ins_or_res = ins builder = iotbx.builders.mixin_builder_class( "smtbx_builder", iotbx.builders.weighted_constrained_restrained_crystal_structure_builder, iotbx.builders.reflection_data_source_builder, iotbx.builders.twinning_builder)() stream = command_stream(filename=ins_or_res) stream = crystal_symmetry_parser(stream, builder) stream = afix_parser(stream.filtered_commands(), builder) stream = atom_parser(stream.filtered_commands(), builder, strictly_shelxl=strictly_shelxl) stream = restraint_parser(stream.filtered_commands(), builder) stream = instruction_parser(stream.filtered_commands(), builder) stream.parse() if fo_sq is None: if hkl is None: assert ins_or_res is not None root, _ = os.path.splitext(ins_or_res) hkl = "%s.hkl" % root assert os.path.isfile(hkl) fo_sq = any_reflection_file("%s=hklf4" % hkl)\ .as_miller_arrays(crystal_symmetry=builder.structure)[0]\ .merge_equivalents().array() else: assert hkl is None return cls(fo_sq.as_xray_observations(), builder.structure, builder.constraints, builder.restraints_manager, builder.weighting_scheme)
def get_map_coeffs(map_coeffs_file=None, map_coeffs_labels=None): if not map_coeffs_file: return if not os.path.isfile(map_coeffs_file): raise Sorry("Unable to find the map coeffs file %s" % (map_coeffs_file)) from iotbx import reflection_file_reader reflection_file = reflection_file_reader.any_reflection_file(map_coeffs_file) miller_arrays = reflection_file.as_miller_arrays() for ma in miller_arrays: if not ma.is_complex_array: continue if not map_coeffs_labels or map_coeffs_labels == ma.info().labels[0]: return ma raise Sorry("Unable to find map coeffs in the file %s with labels %s" % (map_coeffs_file, str(map_coeffs_labels)))
def run(args): if(len(args)!=1): raise Sorry("Reflection file expected.") reflection_file = reflection_file_reader.any_reflection_file( file_name = args[0]) miller_arrays = reflection_file.as_miller_arrays( force_symmetry=True, merge_equivalents=False) if(miller_arrays is None): raise Sorry("Warning: unknown file format:", file_name) for ma in miller_arrays: if(type(ma.data()) == type(flex.double())): print "Processing data array with labels:", ma.info().label_string() compute(miller_array=ma) print
def exercise_cif(): # .cif input cif_in = """\ data_r2etdsf # _cell.entry_id 2etd _cell.length_a 80.4540 _cell.length_b 85.2590 _cell.length_c 53.3970 _cell.angle_alpha 90.0000 _cell.angle_beta 90.0000 _cell.angle_gamma 90.0000 # _symmetry.entry_id 2etd _symmetry.space_group_name_H-M 'C 2 2 2' # loop_ _refln.crystal_id _refln.wavelength_id _refln.scale_group_code _refln.index_h _refln.index_k _refln.index_l _refln.status _refln.intensity_meas _refln.intensity_sigma 1 1 1 0 2 -8 o 1544.6 130.4 1 1 1 0 2 9 o 3450.1 264.9 1 1 1 0 -2 9 o 3243.5 268.5 1 1 1 0 -2 -9 o 3475.4 265.0 1 1 1 0 2 -9 o 3420.1 260.3 1 1 1 0 2 10 o 58.8 31.8 1 1 1 0 -2 -10 o 131.7 50.7 1 1 1 0 2 -10 o 97.9 48.7 1 1 1 0 -2 11 o 9808.3 953.5 1 1 1 0 -2 -11 o 11486.1 970.3 1 1 1 0 2 -11 o 11278.1 967.8 1 1 1 0 2 12 o 1368.9 150.7 1 1 1 0 -2 12 o 1620.9 148.7 1 1 1 0 -2 -12 o 1293.5 147.6 1 1 1 0 2 -12 o 1619.5 155.7 1 1 1 0 -2 13 o 47438.3 4104.1 1 1 1 0 2 14 o 8577.5 1188.0 1 1 1 0 -2 14 o 7996.7 1179.9 1 1 1 0 -2 -14 o 9333.7 1178.1 1 1 1 0 2 -14 o 9642.3 1197.6 1 1 1 0 2 15 o 13577.7 1852.4 1 1 1 0 -2 15 o 14100.9 1852.8 1 1 1 0 -2 -15 o 14184.2 1871.6 1 1 1 0 2 16 o 135.6 76.3 1 1 1 0 -2 16 o 117.0 60.4 """ cif_file = prefix + "_in.cif" open(cif_file, "w").write(cif_in) hkl_orig = any_reflection_file(cif_file).file_content() i_obs_orig = hkl_orig.as_miller_arrays(merge_equivalents=False)[0] ofn = export_scalepack_unmerged.run(args=[cif_file], out=null_out())[0] assert (ofn == "tst_export_scalepack_unmerged_in_w1_unmerged.sca") hkl_new = any_reflection_file(ofn).file_content() i_obs_new = hkl_new.as_miller_arrays(merge_equivalents=False)[0] assert (not i_obs_new.is_unique_set_under_symmetry()) assert i_obs_new.indices().all_eq(i_obs_orig.indices())
def exercise_mosflm_integrate(): if not have_dials_regression: print( "Skipping exercise_mosflm_integrate(): dials_regression not configured" ) return xia2_demo_data = os.path.join(dials_regression, "xia2_demo_data") template = os.path.join(xia2_demo_data, "insulin_1_%03i.img") from xia2.Wrappers.Mosflm.MosflmIndex import MosflmIndex from xia2.Wrappers.Mosflm.MosflmRefineCell import MosflmRefineCell from xia2.Wrappers.Mosflm.MosflmIntegrate import MosflmIntegrate # exercise basic indexing from two images cwd = os.path.abspath(os.curdir) tmp_dir = open_tmp_directory() os.chdir(tmp_dir) from xia2.Experts.FindImages import image2template_directory templ, directory = image2template_directory(template % 1) indexer = MosflmIndex() indexer.set_images((1, 45)) indexer.set_directory(directory) indexer.set_template(templ) indexer.run() refiner = MosflmRefineCell() refiner.set_images(((1, 3), (21, 23), (43, 45))) refiner.set_input_mat_file("xiaindex.mat") refiner.set_output_mat_file("xiarefine.mat") refiner.set_directory(directory) refiner.set_template(templ) refiner.set_beam_centre(indexer.get_refined_beam_centre()) refiner.set_mosaic( sum(indexer.get_mosaic_spreads()) / len(indexer.get_mosaic_spreads())) refiner.run() #output = ''.join(refiner.get_all_output()) #print output integrater = MosflmIntegrate() integrater.set_image_range((1, 45)) integrater.set_input_mat_file("xiaindex.mat") #integrater.set_output_mat_file("xiarefine.mat") integrater.set_directory(directory) integrater.set_template(templ) integrater.set_beam_centre( tuple(float(x) for x in refiner.get_refined_beam_centre())) integrater.set_distance(refiner.get_refined_distance()) integrater.set_mosaic(refiner.get_refined_mosaic()) integrater.set_space_group_number(197) integrater.set_unit_cell(refiner.get_refined_unit_cell()) integrater.run() hklout = integrater.get_hklout() assert os.path.exists(hklout) from iotbx.reflection_file_reader import any_reflection_file miller_arrays = any_reflection_file(hklout).as_miller_arrays( merge_equivalents=False) for ma in miller_arrays: assert ma.size() == 81011, ma.size() assert len(miller_arrays) == 13, len(miller_arrays) assert not integrater.get_bgsig_too_large() assert not integrater.get_getprof_error() assert integrater.get_batches_out() == (1, 45) assert integrater.get_mosaic_spreads() == [ 0.43, 0.42, 0.42, 0.41, 0.41, 0.41, 0.42, 0.42, 0.42, 0.42, 0.42, 0.42, 0.41, 0.41, 0.41, 0.41, 0.41, 0.41, 0.41, 0.41, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.39, 0.39, 0.39, 0.39, 0.39 ] assert integrater.get_nref() == 81011 assert len(integrater.get_postref_result()) == 45 assert integrater.get_postref_result()[1] == { 'ovrl': 0.0, 'full': 507.0, 'dist': 158.6, 'ccx': -0.01, 'yscale': 1.0, 'sdrat': 7.5, 'tilt': 25.0, 'rsym': 0.027, 'bad': 0.0, 'i/sigi': 18.1, 'i/sigi_out': 1.6, 'twist': 13.0, 'resid': 0.021, 'wresid': 1.1, 'part': 1309.0, 'nsym': 18.0, 'neg': 158.0, 'ccy': -0.01, 'ccom': -0.01, 'toff': 0.0, 'roff': 0.0 } assert integrater.get_residuals() == [ 1.1, 0.9, 1.0, 1.0, 0.8, 0.9, 1.0, 0.8, 0.9, 0.9, 0.9, 0.9, 1.0, 1.0, 1.0, 0.9, 0.9, 0.9, 0.9, 0.8, 1.0, 0.9, 0.8, 0.9, 1.0, 0.8, 1.0, 0.9, 0.8, 0.8, 0.9, 0.9, 0.9, 0.9, 0.9, 1.0, 0.8, 0.9, 1.0, 0.7, 0.8, 0.9, 0.8, 0.9, 1.0 ] assert integrater.get_spot_status() \ == 'ooooooooooooooooooooooooooooooooooooooooooooo'
def exercise(prefix="tst_polder_3"): """ Test for phenix.polder sphere radius and box buffer. """ f = open("%s.pdb" % prefix, "w") f.write(pdb_str + pdb_str_ligand) f.close() # get mtz file from model using fmodel cmd = " ".join([ "phenix.fmodel", "%s.pdb" % prefix, "high_res=2.0", "type=real", "label=f-obs", "k_sol=0.4", "b_sol=50", "output.file_name=%s.mtz" % prefix, "> %s.log" % prefix ]) print(cmd) easy_run.call(cmd) params_line = master_params_str params = iotbx.phil.parse(input_string=params_line, process_includes=True).extract() pdb_inp = iotbx.pdb.input(file_name='tst_polder_3.pdb') model = mmtbx.model.manager(model_input=pdb_inp) pdb_hierarchy = model.get_hierarchy() selection_bool = pdb_hierarchy.atom_selection_cache().selection( string='chain A') miller_arrays = reflection_file_reader.any_reflection_file( file_name="tst_polder_3.mtz").as_miller_arrays() fobs = [None] for ma in miller_arrays: if (ma.info().label_string() == "f-obs"): fobs = ma.deep_copy() mmm_list = [] mask_mmm = [[0.0, 1.0, 0.9083055555555556], [0.0, 1.0, 0.8901388888888889], [0.0, 1.0, 0.9083055555555556], [0.0, 1.0, 0.8583379629629629], [0.0, 1.0, 0.9083055555555556], [0.0, 1.0, 0.8025601851851852]] for radius in [3, 5, 7]: params.polder.sphere_radius = radius polder_object = mmtbx.maps.polder.compute_polder_map( f_obs=fobs, r_free_flags=None, model=model, params=params.polder, selection_bool=selection_bool) polder_object.validate() polder_object.run() results = polder_object.get_results() mmm_list.append( polder_object.mask_data_omit.as_1d().min_max_mean().as_tuple()) mmm_list.append( polder_object.mask_data_polder.as_1d().min_max_mean().as_tuple()) for i in range(6): assert approx_equal(mask_mmm[i], mmm_list[i], eps=0.1) #print mask_mmm[i], mmm_list[i] #------------------------------------------------------------------------- mmm_list = [] mask_mmm = [[0.0, 1.0, 0.898712962962963], [0.0, 1.0, 0.8642268518518519], [0.0, 1.0, 0.898712962962963], [0.0, 1.0, 0.7957083333333334], [0.0, 1.0, 0.898712962962963], [0.0, 1.0, 0.6772777777777778]] for box_buffer in [3, 5, 7]: params.polder.box_buffer = box_buffer params.polder.compute_box = True polder_object = mmtbx.maps.polder.compute_polder_map( f_obs=fobs, r_free_flags=None, model=model, params=params.polder, selection_bool=selection_bool) polder_object.validate() polder_object.run() results = polder_object.get_results() mmm_list.append( polder_object.mask_data_omit.as_1d().min_max_mean().as_tuple()) mmm_list.append( polder_object.mask_data_polder.as_1d().min_max_mean().as_tuple()) for i in range(6): assert approx_equal(mask_mmm[i], mmm_list[i], eps=0.1)
def _integrate_finish(self): """ Finish off the integration. If in high-pressure mode run dials.anvil_correction. Run dials.export. """ # FIXME - do we want to export every time we call this method # (the file will not have changed) and also (more important) do # we want a different exported MTZ file every time (I do not think # that we do; these can be very large) - was exporter.get_xpid() -> # now dials if self._output_format == "hkl": exporter = self.ExportMtz() exporter.set_reflections_filename( self._intgr_integrated_reflections) mtz_filename = os.path.join(self.get_working_directory(), "%s_integrated.mtz" % "dials") exporter.set_mtz_filename(mtz_filename) exporter.run() self._intgr_integrated_filename = mtz_filename # record integrated MTZ file pname, xname, dname = self.get_integrater_project_info() sweep = self.get_integrater_sweep_name() FileHandler.record_more_data_file( "%s %s %s %s INTEGRATE" % (pname, xname, dname, sweep), mtz_filename) from iotbx.reflection_file_reader import any_reflection_file miller_arrays = any_reflection_file( self._intgr_integrated_filename).as_miller_arrays() # look for profile-fitted intensities intensities = [ ma for ma in miller_arrays if ma.info().labels == ["IPR", "SIGIPR"] ] if len(intensities) == 0: # look instead for summation-integrated intensities intensities = [ ma for ma in miller_arrays if ma.info().labels == ["I", "SIGI"] ] assert len(intensities) self._intgr_n_ref = intensities[0].size() if not os.path.isfile(self._intgr_integrated_filename): raise RuntimeError("dials.export failed: %s does not exist." % self._intgr_integrated_filename) if (self._intgr_reindex_operator is None and self._intgr_spacegroup_number == lattice_to_spacegroup( self.get_integrater_refiner().get_refiner_lattice())): logger.debug("Not reindexing to spacegroup %d (%s)" % (self._intgr_spacegroup_number, self._intgr_reindex_operator)) return mtz_filename if (self._intgr_reindex_operator is None and self._intgr_spacegroup_number == 0): logger.debug("Not reindexing to spacegroup %d (%s)" % (self._intgr_spacegroup_number, self._intgr_reindex_operator)) return mtz_filename logger.debug( "Reindexing to spacegroup %d (%s)" % (self._intgr_spacegroup_number, self._intgr_reindex_operator)) hklin = mtz_filename from xia2.Wrappers.CCP4.Reindex import Reindex reindex = Reindex() reindex.set_working_directory(self.get_working_directory()) auto_logfiler(reindex) reindex.set_operator(self._intgr_reindex_operator) if self._intgr_spacegroup_number: reindex.set_spacegroup(self._intgr_spacegroup_number) else: reindex.set_spacegroup( lattice_to_spacegroup( self.get_integrater_refiner().get_refiner_lattice())) hklout = "%s_reindex.mtz" % hklin[:-4] reindex.set_hklin(hklin) reindex.set_hklout(hklout) reindex.reindex() self._intgr_integrated_filename = hklout self._intgr_cell = reindex.get_cell() pname, xname, dname = self.get_integrater_project_info() sweep = self.get_integrater_sweep_name() FileHandler.record_more_data_file( "%s %s %s %s" % (pname, xname, dname, sweep), self.get_integrated_experiments(), ) FileHandler.record_more_data_file( "%s %s %s %s" % (pname, xname, dname, sweep), self.get_integrated_reflections(), ) return hklout elif self._output_format == "pickle": if (self._intgr_reindex_operator is None and self._intgr_spacegroup_number == lattice_to_spacegroup( self.get_integrater_refiner().get_refiner_lattice())): logger.debug("Not reindexing to spacegroup %d (%s)" % (self._intgr_spacegroup_number, self._intgr_reindex_operator)) return self._intgr_integrated_reflections if (self._intgr_reindex_operator is None and self._intgr_spacegroup_number == 0): logger.debug("Not reindexing to spacegroup %d (%s)" % (self._intgr_spacegroup_number, self._intgr_reindex_operator)) return self._intgr_integrated_reflections logger.debug( "Reindexing to spacegroup %d (%s)" % (self._intgr_spacegroup_number, self._intgr_reindex_operator)) from xia2.Wrappers.Dials.Reindex import Reindex reindex = Reindex() reindex.set_working_directory(self.get_working_directory()) auto_logfiler(reindex) reindex.set_cb_op(self._intgr_reindex_operator) if self._intgr_spacegroup_number: reindex.set_space_group(self._intgr_spacegroup_number) else: reindex.set_space_group( lattice_to_spacegroup( self.get_integrater_refiner().get_refiner_lattice())) reindex.set_experiments_filename(self.get_integrated_experiments()) reindex.set_indexed_filename(self.get_integrated_reflections()) reindex.run() self._intgr_integrated_reflections = ( reindex.get_reindexed_reflections_filename()) self._intgr_integrated_filename = ( reindex.get_reindexed_reflections_filename()) self._intgr_experiments_filename = ( reindex.get_reindexed_experiments_filename()) pname, xname, dname = self.get_integrater_project_info() sweep = self.get_integrater_sweep_name() FileHandler.record_more_data_file( "%s %s %s %s" % (pname, xname, dname, sweep), self.get_integrated_experiments(), ) FileHandler.record_more_data_file( "%s %s %s %s" % (pname, xname, dname, sweep), self.get_integrated_reflections(), ) return None # this will be set to intgr_hklout - better to cause failure
def run(args): def vdw_radii_callback(option, opt_str, value, parser): # create a dict from space separated string of element types and radii radii = {} items = value.split() assert len(items) % 2 == 0 for i in range(int(len(items) / 2)): radii.setdefault(items[i*2], float(items[i*2+1])) setattr(parser.values, option.dest, radii) command_line = (option_parser( usage="smtbx.masks structure reflections [options]") .enable_symmetry_comprehensive() .option(None, "--solvent_radius", action="store", type="float", default=1.3) .option(None, "--shrink_truncation_radius", action="store", type="float", default=1.3) .option(None, "--debug", action="store_true") .option(None, "--verbose", action="store_true") .option(None, "--resolution_factor", action="store", type="float", default=1/4) .option(None, "--grid_step", action="store", type="float") .option(None, "--d_min", action="store", type="float") .option(None, "--two_theta_max", action="store", type="float") .option(None, "--cb_op", action="store", type="string") .option(None, "--vdw_radii", action="callback", callback=vdw_radii_callback, type="string", nargs=1) .option(None, "--use_space_group_symmetry", action="store_true")).process(args=args) structure_file = command_line.args[0] ext = os.path.splitext(structure_file)[-1].lower() if ext in ('.res', '.ins'): xs = xray.structure.from_shelx(filename=structure_file) elif ext == '.cif': xs = xray.structure.from_cif(filename=structure_file) else: print("%s: unsupported structure file format {shelx|cif}" %ext) return reflections_server = reflection_file_utils.reflection_file_server( crystal_symmetry = xs.crystal_symmetry(), reflection_files = [ reflection_file_reader.any_reflection_file(command_line.args[1]) ] ) fo_sq = reflections_server.get_miller_arrays(None)[0] if command_line.options.cb_op is not None: cb_op = sgtbx.change_of_basis_op(sgtbx.rt_mx(command_line.options.cb_op)) fo_sq = fo_sq.change_basis(cb_op).customized_copy( crystal_symmetry=xs) print("structure file: %s" %command_line.args[0]) print("reflection file: %s" %command_line.args[1]) if command_line.options.debug: print("debug: %s" %command_line.options.debug) print() xs.show_summary() print() d_min = command_line.options.d_min two_theta_max = command_line.options.two_theta_max assert [d_min, two_theta_max].count(None) > 0 if two_theta_max is not None: d_min = uctbx.two_theta_as_d(two_theta_max, wavelength=0.71073, deg=True) exercise_masks( xs, fo_sq, solvent_radius=command_line.options.solvent_radius, shrink_truncation_radius=command_line.options.shrink_truncation_radius, resolution_factor=command_line.options.resolution_factor, grid_step=command_line.options.grid_step, resolution_cutoff=d_min, atom_radii_table=command_line.options.vdw_radii, use_space_group_symmetry=command_line.options.use_space_group_symmetry, debug=command_line.options.debug, verbose=command_line.options.verbose) print("OK")
from iotbx import reflection_file_reader import sys import matplotlib.pyplot as plt import numpy as np from cctbx.array_family import flex hklin = sys.argv[1] reflection_file = reflection_file_reader.any_reflection_file(hklin) miller_arrays = reflection_file.as_miller_arrays() num_bins = 20 for miller_array in miller_arrays: if miller_array.sigmas() is not None: miller_array.show_summary() mean_sigI = np.mean(miller_array.sigmas()) mean_I = np.mean(miller_array.data()) std_I = np.std(miller_array.data()) ma_1 = miller_array.select((miller_array.sigmas() > 0) & (miller_array.sigmas() <= mean_sigI)) ma_2 = miller_array.select((miller_array.sigmas() > mean_sigI)) ma_3 = miller_array.select((miller_array.data() < (mean_I - (0*std_I)))) #plot plt.subplot(321) x = miller_array.sigmas().as_numpy_array() mu = np.mean(x) med = np.median(x) sigma = np.std(x) plt.hist(x, num_bins, normed=0, facecolor='green', alpha=0.5) plt.ylabel('Frequencies') plt.title('sigI distribution\nmean %5.3f median %5.3f sigma %5.3f' %(mu, med, sigma)) plt.subplot(322) plt.scatter(miller_array.data(), miller_array.sigmas(), s=10, c='b', marker='o') plt.subplot(323)
def exercise_get_amplitudes_and_get_phases_deg(): crystal_symmetry = crystal.symmetry(unit_cell=(10, 11, 12, 85, 95, 100), space_group_symbol="P 1") miller_set = miller.build_set(crystal_symmetry=crystal_symmetry, anomalous_flag=False, d_min=3) input_arrays = [ miller_set.array(data=flex.random_double(size=miller_set.indices( ).size())).set_observation_type_xray_amplitude() for i in [0, 1] ] mtz_dataset = input_arrays[0].as_mtz_dataset(column_root_label="F0") mtz_dataset.mtz_object().write("tmp_rfu1.mtz") reflection_files = [ reflection_file_reader.any_reflection_file(file_name="tmp_rfu1.mtz") ] reflection_file_srv = reflection_file_server( crystal_symmetry=crystal_symmetry, force_symmetry=True, reflection_files=reflection_files) ampl = reflection_file_srv.get_amplitudes( file_name=None, labels=None, convert_to_amplitudes_if_necessary=True, parameter_scope="amplitudes", parameter_name="labels") assert str(ampl.info()) == "tmp_rfu1.mtz:F0" ampl = reflection_file_srv.get_miller_array(labels="F0") assert str(ampl.info()) == "tmp_rfu1.mtz:F0" mtz_dataset.add_miller_array(miller_array=input_arrays[1], column_root_label="F1") mtz_dataset.mtz_object().write("tmp_rfu2.mtz") reflection_files = [ reflection_file_reader.any_reflection_file(file_name="tmp_rfu2.mtz") ] err = StringIO() reflection_file_srv = reflection_file_server( crystal_symmetry=crystal_symmetry, force_symmetry=True, reflection_files=reflection_files, err=err) try: reflection_file_srv.get_amplitudes( file_name=None, labels=None, convert_to_amplitudes_if_necessary=True, parameter_scope="amplitudes", parameter_name="labels") except Sorry: assert not show_diff( err.getvalue(), """\ Multiple equally suitable arrays of amplitudes found. Possible choices: tmp_rfu2.mtz:F0 tmp_rfu2.mtz:F1 Please use amplitudes.labels to specify an unambiguous substring of the target label. """) err = reflection_file_srv.err = StringIO() else: raise Exception_expected ampl = reflection_file_srv.get_amplitudes( file_name=None, labels=["F1"], convert_to_amplitudes_if_necessary=True, parameter_scope="amplitudes", parameter_name="labels") assert str(ampl.info()) == "tmp_rfu2.mtz:F1" try: reflection_file_srv.get_amplitudes( file_name=None, labels=["F2"], convert_to_amplitudes_if_necessary=True, parameter_name="labels", parameter_scope=None) except Sorry: assert not show_diff( err.getvalue(), """\ No matching array: labels=F2 Possible choices: tmp_rfu2.mtz:F0 tmp_rfu2.mtz:F1 Please use labels to specify an unambiguous substring of the target label. """) err = reflection_file_srv.err = StringIO() else: raise Exception_expected assert len(reflection_file_srv.file_name_miller_arrays) == 1 ampl = reflection_file_srv.get_amplitudes( file_name="tmp_rfu1.mtz", labels=None, convert_to_amplitudes_if_necessary=True, parameter_scope="amplitudes", parameter_name="labels") assert len(reflection_file_srv.file_name_miller_arrays) == 2 assert str(ampl.info()) == "tmp_rfu1.mtz:F0" ampl = reflection_file_srv.get_amplitudes( file_name=os.path.abspath("tmp_rfu1.mtz"), labels=["f0"], convert_to_amplitudes_if_necessary=True, parameter_scope="amplitudes", parameter_name="labels") assert len(reflection_file_srv.file_name_miller_arrays) == 2 assert str(ampl.info()) == "tmp_rfu1.mtz:F0" try: reflection_file_srv.get_amplitudes( file_name=None, labels=None, convert_to_amplitudes_if_necessary=True, parameter_scope=None, parameter_name=None) except Sorry: assert not show_diff( err.getvalue(), """\ Multiple equally suitable arrays of amplitudes found. Possible choices: tmp_rfu2.mtz:F0 tmp_rfu2.mtz:F1 Please specify an unambiguous substring of the target label. """) err = reflection_file_srv.err = StringIO() else: raise Exception_expected # mtz_dataset.add_miller_array(miller_array=miller_set.array( data=flex.polar(flex.random_double(size=miller_set.indices().size()), flex.random_double(size=miller_set.indices().size()))), column_root_label="F2") mtz_dataset.add_miller_array(miller_array=miller_set.array( data=flex.random_double(size=miller_set.indices().size()), sigmas=flex.random_double(size=miller_set.indices().size()) / 10).set_observation_type_xray_intensity(), column_root_label="F3") mtz_dataset.add_miller_array(miller_array=miller_set.array( data=flex.hendrickson_lattman(miller_set.indices().size(), (0, 0, 0, 0))), column_root_label="P") mtz_dataset.mtz_object().write("tmp_rfu3.mtz") reflection_files = [ reflection_file_reader.any_reflection_file(file_name="tmp_rfu3.mtz") ] err = StringIO() reflection_file_srv = reflection_file_server( crystal_symmetry=crystal_symmetry, force_symmetry=True, reflection_files=reflection_files, err=err) ampl = reflection_file_srv.get_amplitudes( file_name=None, labels=["f2"], convert_to_amplitudes_if_necessary=False, parameter_scope="amplitudes", parameter_name="labels") assert str(ampl.info()) == "tmp_rfu3.mtz:F2,PHIF2" assert ampl.is_complex_array() ampl = reflection_file_srv.get_amplitudes( file_name=None, labels=["f2"], convert_to_amplitudes_if_necessary=True, parameter_scope="amplitudes", parameter_name="labels") assert str(ampl.info()) == "tmp_rfu3.mtz:F2" assert ampl.is_real_array() ampl = reflection_file_srv.get_amplitudes( file_name=None, labels=["f3"], convert_to_amplitudes_if_necessary=False, parameter_scope="amplitudes", parameter_name="labels") assert str(ampl.info()) == "tmp_rfu3.mtz:F3,SIGF3" assert ampl.is_xray_intensity_array() ampl = reflection_file_srv.get_amplitudes( file_name=None, labels=["f3"], convert_to_amplitudes_if_necessary=True, parameter_scope="amplitudes", parameter_name="labels") assert str(ampl.info()) == "tmp_rfu3.mtz:F3,as_amplitude_array" assert ampl.is_real_array() ampl = reflection_file_srv.get_amplitudes( file_name=None, labels=None, convert_to_amplitudes_if_necessary=False, parameter_scope="amplitudes", parameter_name="labels", return_all_valid_arrays=True, strict=True) assert (len(ampl) == 2) for f in ampl: assert (not f.is_xray_intensity_array()) and (not f.is_complex_array()) # phases = reflection_file_srv.get_phases_deg( file_name=None, labels=["f2"], convert_to_phases_if_necessary=False, original_phase_units=None, parameter_scope="phases", parameter_name="labels") assert str(phases.info()) == "tmp_rfu3.mtz:F2,PHIF2" assert phases.is_complex_array() phases = reflection_file_srv.get_phases_deg( file_name=None, labels=["f2"], convert_to_phases_if_necessary=True, original_phase_units=None, parameter_scope=None, parameter_name="labels") assert str(phases.info()) == "tmp_rfu3.mtz:PHIF2" assert phases.is_real_array() assert flex.mean(phases.data()) > 5 phases = reflection_file_srv.get_phases_deg( file_name=None, labels=["PA"], convert_to_phases_if_necessary=False, original_phase_units=None, parameter_scope="phases", parameter_name="labels") assert str(phases.info()) == "tmp_rfu3.mtz:PA,PB,PC,PD" phases = reflection_file_srv.get_phases_deg( file_name=None, labels=["PA"], convert_to_phases_if_necessary=True, original_phase_units=None, parameter_scope="phases", parameter_name="labels") assert str(phases.info()) \ == "tmp_rfu3.mtz:PA,PB,PC,PD,converted_to_centroid_phases" assert phases.is_real_array() for original_phase_units in [None, "deg", "rad"]: phases = reflection_file_srv.get_phases_deg( file_name=None, labels=["F0"], convert_to_phases_if_necessary=False, original_phase_units=original_phase_units, parameter_scope=None, parameter_name="labels") if (original_phase_units != "rad"): assert str(phases.info()) == "tmp_rfu3.mtz:F0" else: assert str(phases.info()) == "tmp_rfu3.mtz:F0,converted_to_deg"
def exercise_get_r_free_flags(): crystal_symmetry = crystal.symmetry(unit_cell=(30, 31, 32, 85, 95, 100), space_group_symbol="P 1") miller_set = miller.build_set(crystal_symmetry=crystal_symmetry, anomalous_flag=False, d_min=3) n = miller_set.indices().size() exercise_flag_arrays = [] exercise_flag_arrays.append( flex.int(list(flex.random_permutation(size=n) % 10))) exercise_flag_arrays.append(flex.int(xrange(n))) exercise_flag_arrays.append(flex.int(n, 0)) for style in ["ccp4", "cns", "shelx", "bool"]: for i_exercise, exercise_flag_array in enumerate(exercise_flag_arrays): for reversed in [False, True]: if (style == "ccp4"): if (reversed): break data = exercise_flag_array test_flag_value = 3 else: if (not reversed): data = (exercise_flag_array == 0) test_flag_value = True else: data = (exercise_flag_array != 0) test_flag_value = False if (style == "cns"): data = data.as_int() test_flag_value = int(test_flag_value) elif (style == "shelx"): data = -data.as_int() data.set_selected((data == 0), 1) if (not reversed): test_flag_value = -1 else: test_flag_value = 1 input_array = miller_set.array(data=data) mtz_dataset = input_array.as_mtz_dataset( column_root_label="FreeRflags") mtz_dataset.mtz_object().write("tmp.mtz") reflection_files = [ reflection_file_reader.any_reflection_file( file_name="tmp.mtz") ] err = StringIO() reflection_file_srv = reflection_file_server( crystal_symmetry=crystal_symmetry, force_symmetry=True, reflection_files=reflection_files, err=err) for trial_test_flag_value in [None, test_flag_value]: for trial_label in [None, "free", "foo"]: try: r_free_flags, actual_test_flag_value = \ reflection_file_srv.get_r_free_flags( file_name=None, label=trial_label, test_flag_value=trial_test_flag_value, disable_suitability_test=False, parameter_scope="r_free_flags") except Sorry, e: if (trial_label != "foo"): assert i_exercise > 0 if (trial_label is None): assert str(e) == """\ No array of R-free flags found. For manual selection define: r_free_flags.label r_free_flags.test_flag_value r_free_flags.disable_suitability_test=True""" else: assert str(e) == \ "Not a suitable array of R-free flags:" \ + " r_free_flags.label=free\n" \ + "To override the suitability test define:" \ + " r_free_flags.disable_suitability_test=True" else: assert str( e ) == "No matching array: r_free_flags.label=foo" if (i_exercise == 0): assert err.getvalue() == """\ No matching array: r_free_flags.label=foo Possible choices: tmp.mtz:FreeRflags Please use r_free_flags.label to specify an unambiguous substring of the target label. """ else: assert err.getvalue() == """\ No matching array: r_free_flags.label=foo """ err = reflection_file_srv.err = StringIO() else: assert i_exercise == 0 actual_test_flag_value_2 = guess_r_free_flag_value( miller_array=r_free_flags, test_flag_value=trial_test_flag_value) assert (actual_test_flag_value_2 == actual_test_flag_value)
def __init__(self, _parameters): '''Instantiate class and perform initial processing needed before the real work is done. This includes assessment of the anomalous signal, the signal to noise and conversion to pseudo-scalepack format of the data for input into shelxc, which is used to compute FA values.''' self._hklin = _parameters.get_data() self._native_hklin = _parameters.get_native() self._native = None self._cpu = _parameters.get_cpu() self._machines = _parameters.get_machines() self._atom = _parameters.get_atom() self._ntry = _parameters.get_ntry() self._ncycle = _parameters.get_ncycle() self._ano_rlimits = _parameters.get_rlims() self._trace = _parameters.get_trace() self._mode = _parameters.get_mode() self._sge_project = _parameters.get_sge_project() self._data = None self._spacegroups = [ _parameters.get_spg(), ] if _parameters.get_spg() else None self._nsites = [ _parameters.get_nsites(), ] if _parameters.get_nsites() else None self._xml_name = _parameters.get_xml() self._json_name = _parameters.get_json() self._start_time = datetime.now().strftime("%c") if self._machines == 1: self._cluster = False else: self._cluster = True self._wd = os.getcwd() logging.info('Using %d cpus / %d machines' % (self._cpu, self._machines)) self._full_command_line = ' '.join(sys.argv) # pull information we'll need from the input MTZ file - the unit cell, # the pointgroup and the number of reflections in the file. select # first Miller array in file which has anomalous data # --- SAD DATA --- reader = any_reflection_file(self._hklin) self._file_type = reader.file_type() if self._file_type == 'ccp4_mtz': self._file_content = reader.file_content() self._is_merged = False if self._file_content.n_batches( ) > 0 else True self._all_data = [ m for m in reader.as_miller_arrays( merge_equivalents=self._is_merged) if type(m.observation_type()) is observation_types.intensity and (m.anomalous_flag() if self._is_merged else True) ] if not self._all_data: raise RuntimeError, 'no intensity data found in %s' % self._hklin if self._native_hklin: native_reader = any_reflection_file(self._native_hklin) try: self._native = next( m for m in native_reader.as_miller_arrays( merge_equivalents=True) if (type(m.observation_type()) is observation_types. intensity and not m.anomalous_flag())) except StopIteration: self._native = None else: raise RuntimeError, 'Unsupported input file type: %s' % self._file_type self._nrefl = self._file_content.n_reflections() self._pointgroup = self._file_content.space_group_number() self._dmax, self._dmin = self._file_content.max_min_resolution() self._xml_results = {} self._xml_results['LOWRES'] = self._dmax self._xml_results['HIGHRES'] = self._dmin return
except AssertionError, e: if ("No unit cell and symmetry information supplied" in str(e)): raise Sorry( "Missing or incomplete symmetry information. This program " + "will only work with reflection file formats that contain both " + "unit cell and space group records, such as MTZ files.") # reflection_files = [] reflection_file_names = [] for rfn in [ params.maps.input.reflection_data.file_name, params.maps.input.reflection_data.r_free_flags.file_name ]: if (os.path.isfile(str(rfn))) and (not rfn in reflection_file_names): reflection_files.append( reflection_file_reader.any_reflection_file( file_name=rfn, ensure_read_access=False)) reflection_file_names.append(rfn) reflection_file_server = reflection_file_utils.reflection_file_server( crystal_symmetry=crystal_symmetry, force_symmetry=True, reflection_files=reflection_files, #[], err=log) # reflection_data_master_params = mmtbx.utils.data_and_flags_master_params( master_scope_name="reflection_data") reflection_data_input_params = processed_args.params.get( "maps.input.reflection_data") reflection_data_params = reflection_data_master_params.fetch( reflection_data_input_params).extract().reflection_data # determine_data_and_flags_result = mmtbx.utils.determine_data_and_flags(
def load_reflections_file(self, file_name, set_array=True, data_only=False): file_name = to_str(file_name) if (file_name != ""): from iotbx.reflection_file_reader import any_reflection_file self.viewer.isnewfile = True #self.params.NGL_HKLviewer.mergedata = None self.params.NGL_HKLviewer.viewer.scene_id = None self.viewer.colour_scene_id = None self.viewer.radii_scene_id = None self.viewer.match_valarrays = [] self.viewer.proc_arrays = [] self.spacegroup_choices = [] display.reset_settings() self.settings = display.settings() self.viewer.settings = self.params.NGL_HKLviewer.viewer self.viewer.mapcoef_fom_dict = {} try: hkl_file = any_reflection_file(file_name) arrays = hkl_file.as_miller_arrays( merge_equivalents=False, ) #observation_type_callback=misc_dialogs.get_shelx_file_data_type) #arrays = f.file_server.miller_arrays except Exception as e: self.NewFileLoaded = False self.mprint(to_str(e)) arrays = [] valid_arrays = [] self.viewer.array_infostrs = [] self.viewer.array_infotpls = [] for array in arrays: #if array.is_hendrickson_lattman_array() : # continue #elif (data_only) : if (not array.is_real_array()) and (not array.is_complex_array()) \ and (not array.is_integer_array()) and (not array.is_bool_array()) : self.mprint('Ignoring miller array \"%s\" of %s' \ %(array.info().label_string(), type(array.data()[0]) ) ) continue self.viewer.array_infostrs.append( ArrayInfo(array, self.mprint).infostr) self.viewer.array_infotpls.append( ArrayInfo(array, self.mprint).infotpl) valid_arrays.append(array) self.valid_arrays = valid_arrays self.mprint("Miller arrays in this file:") for e in self.viewer.array_infostrs: self.mprint("%s" % e) self.NewFileLoaded = True if (len(valid_arrays) == 0): msg = "No arrays of the supported types in this file." self.mprint(msg) self.NewFileLoaded = False return False elif (len(valid_arrays) >= 1): if (set_array): self.set_miller_array() mydict = { "info": self.infostr, "array_infotpls": self.viewer.array_infotpls, "bin_infotpls": self.viewer.bin_infotpls, "html_url": self.viewer.url, "merge_data": self.params.NGL_HKLviewer.merge_data, "spacegroups": [e.symbol_and_number() for e in self.spacegroup_choices], "NewFileLoaded": self.NewFileLoaded } self.SendInfoToGUI(mydict) return True
def run(args): if len(args) == 0: master_params.show(expert_level=0) elif ("--help" in args): print "no help available as yet" elif ("--h" in args): print "no help availableas yet" elif ("--show_defaults" in args): master_params.show(expert_level=0) elif ("--show_defaults_all" in args): master_params.show(expert_level=10) else: log = multi_out() if (not "--quiet" in args): log.register(label="stdout", file_object=sys.stdout) string_buffer = StringIO() string_buffer_plots = StringIO() log.register(label="log_buffer", file_object=string_buffer) log_plots = StringIO() print >> log, "#phil __OFF__" print >> log print >> log, date_and_time() print >> log print >> log phil_objects = [] argument_interpreter = master_params.command_line_argument_interpreter( home_scope="scaling") reflection_file = None for arg in args: command_line_params = None arg_is_processed = False if arg == '--quiet': arg_is_processed = True ## The associated action with this keyword is implemented above if (os.path.isfile(arg)): ## is this a file name? ## Check if this is a phil file try: command_line_params = iotbx.phil.parse(file_name=arg) except KeyboardInterrupt: raise except Exception: pass if command_line_params is not None: phil_objects.append(command_line_params) arg_is_processed = True ## Check if this file is a reflection file if command_line_params is None: reflection_file = reflection_file_reader.any_reflection_file( file_name=arg, ensure_read_access=False) if (reflection_file is not None): reflection_file = arg arg_is_processed = True ## If it is not a file, it must be a phil command else: try: command_line_params = argument_interpreter.process(arg=arg) if command_line_params is not None: phil_objects.append(command_line_params) arg_is_processed = True except KeyboardInterrupt: raise except Exception: pass if not arg_is_processed: print >> log, "##----------------------------------------------##" print >> log, "## Unknown phil-file or phil-command:", arg print >> log, "##----------------------------------------------##" print >> log raise Sorry("Unknown file format or phil command: %s" % arg) effective_params = master_params.fetch(sources=phil_objects) params = effective_params.extract() effective_params = master_params.fetch(sources=phil_objects) new_params = master_params.format(python_object=params) ## Now please read in the reflections files ## get symmetry and cell data first please ## By default, the native cell and symmetry are used ## as reference crystal_symmetry_nat = None crystal_symmetry_nat = crystal_symmetry_from_any.extract_from( file_name=params.scaling.input.xray_data.reference.file_name) if params.scaling.input.xray_data.space_group is None: params.scaling.input.xray_data.space_group =\ crystal_symmetry_nat.space_group_info() print >> log, "Using symmetry of native data" if params.scaling.input.xray_data.unit_cell is None: params.scaling.input.xray_data.unit_cell =\ crystal_symmetry_nat.unit_cell() print >> log, "Using cell of native data" ## Check if a unit cell is defined if params.scaling.input.xray_data.space_group is None: raise Sorry("No space group defined") if params.scaling.input.xray_data.unit_cell is None: raise Sorry("No unit cell defined") crystal_symmetry = crystal_symmetry = crystal.symmetry( unit_cell=params.scaling.input.xray_data.unit_cell, space_group_symbol=str(params.scaling.input.xray_data.space_group)) effective_params = master_params.fetch(sources=phil_objects) new_params = master_params.format(python_object=params) print >> log, "Effective parameters" print >> log, "#phil __ON__" new_params.show(out=log, expert_level=params.scaling.input.expert_level) print >> log, "#phil __END__" print >> log ## define a xray data server xray_data_server = reflection_file_utils.reflection_file_server( crystal_symmetry=crystal_symmetry, force_symmetry=True, reflection_files=[]) ## Read in native data and make appropriatre selections miller_array_native = None miller_array_native = xray_data_server.get_xray_data( file_name=params.scaling.input.xray_data.reference.file_name, labels=params.scaling.input.xray_data.reference.labels, ignore_all_zeros=True, parameter_scope='scaling.input.SIR_scale.xray_data.native') info_native = miller_array_native.info() miller_array_native = miller_array_native.map_to_asu().select( miller_array_native.indices() != (0, 0, 0)) miller_array_native = miller_array_native.select( miller_array_native.data() > 0) ## Convert to amplitudes if (miller_array_native.is_xray_intensity_array()): miller_array_native = miller_array_native.f_sq_as_f() elif (miller_array_native.is_complex_array()): miller_array_native = abs(miller_array_native) if not miller_array_native.is_real_array(): raise Sorry("miller_array_native is not a real array") miller_array_native.set_info(info=info_native) ## Print info print >> log print >> log, "Reference data" print >> log, "==============" miller_array_native.show_comprehensive_summary(f=log) print >> log native_pre_scale = pre_scale.pre_scaler( miller_array_native, params.scaling.input.scaling_strategy.pre_scaler_protocol, params.scaling.input.basic) miller_array_native = native_pre_scale.x1.deep_copy() del native_pre_scale scaler = fa_estimation.ano_scaling( miller_array_native, params.scaling.input.scaling_strategy.ano_protocol) positive_miller = scaler.x1p.deep_copy() negative_miller = scaler.x1n.deep_copy() print >> log print >> log, "Making delta f's" print >> log, "----------------" print >> log delta_gen = pair_analyses.delta_generator(positive_miller, negative_miller) print >> log print >> log, "writing mtz file" print >> log, "----------------" print >> log ## some assertions to make sure nothing went weerd assert positive_miller.observation_type() is not None assert negative_miller.observation_type() is not None assert delta_gen.abs_delta_f.observation_type() is not None ## Please write out the abs_delta_f array mtz_dataset = delta_gen.abs_delta_f.as_mtz_dataset( column_root_label='F' + params.scaling.input.output.outlabel) mtz_dataset.mtz_object().write( file_name=params.scaling.input.output.hklout) if params.scaling.input.omit.perform_omit: print >> log print >> log, "writing omit files" print >> log, "------------------" print >> log omit_object = random_omit.random_omit_data( delta_gen.abs_delta_f, params.scaling.input.omit) omit_object.write_datasets()
def run(prefix="tst_00"): # Poor model that we want to refine so it matches the answer pdb_file = libtbx.env.find_in_repositories( relative_path="mmtbx/regression/real_space_refine_chain/poor_model.pdb", test=os.path.isfile) mtz_file = libtbx.env.find_in_repositories( relative_path="mmtbx/regression/real_space_refine_chain/poor_map.mtz", test=os.path.isfile) pdb_inp = iotbx.pdb.input(file_name=pdb_file) ph_poor = pdb_inp.construct_hierarchy() ph_poor.atoms().reset_i_seq() xrs_poor = pdb_inp.xray_structure_simple() # Initialize states accumulator states = mmtbx.utils.states(pdb_hierarchy=ph_poor, xray_structure=xrs_poor) states.add(sites_cart=xrs_poor.sites_cart()) # Compute target map mas = reflection_file_reader.any_reflection_file( file_name=mtz_file).as_miller_arrays() assert len(mas) == 1 fc = mas[0] fft_map = fc.fft_map(resolution_factor=0.25) fft_map.apply_sigma_scaling() target_map_data = fft_map.real_map_unpadded() ccp4_map(crystal_symmetry=fc.crystal_symmetry(), file_name="map.ccp4", map_data=target_map_data) # Build geometry restraints params = monomer_library.pdb_interpretation.master_params.extract() params.nonbonded_weight = 200 #params.peptide_link.ramachandran_restraints=True #params.peptide_link.rama_potential="oldfield" #print dir(params) #STOP() processed_pdb_file = monomer_library.pdb_interpretation.process( mon_lib_srv=monomer_library.server.server(), ener_lib=monomer_library.server.ener_lib(), file_name=pdb_file, params=params, #crystal_symmetry = fc.crystal_symmetry(), strict_conflict_handling=True, force_symmetry=True, log=None) geometry = processed_pdb_file.geometry_restraints_manager( show_energies=False, plain_pairs_radius=5, assume_hydrogens_all_missing=True) restraints_manager = mmtbx.restraints.manager(geometry=geometry, normalization=True) #for a in ph_answer.atoms(): # print a.i_seq, a.name, a.xyz #STOP() #ref_xyz = flex.vec3_double([(14.323, 35.055, 14.635), (16.099, 12.317, 16.37)]) #selection = flex.size_t([1,76]) # #restraints_manager.geometry.adopt_reference_coordinate_restraints_in_place( # reference.add_coordinate_restraints( # sites_cart = ref_xyz, # selection = selection, # sigma = 0.1)) # Do real-space refinement t0 = time.time() ear = mmtbx.refinement.real_space.explode_and_refine.run( xray_structure=xrs_poor, pdb_hierarchy=ph_poor, map_data=target_map_data, restraints_manager=restraints_manager, states=states) print("Time: %6.4f" % (time.time() - t0)) ear.pdb_hierarchy.write_pdb_file(file_name="%s_refined.pdb" % prefix) states.write(file_name="%s_refined_all_states.pdb" % prefix)
def load_reflections_file(self, file_name): file_name = to_str(file_name) ret = False if (file_name != ""): self.mprint("Reading file...") from iotbx.reflection_file_reader import any_reflection_file self.viewer.isnewfile = True #self.params.NGL_HKLviewer.mergedata = None self.params.NGL_HKLviewer.viewer.scene_id = None self.viewer.colour_scene_id = None self.viewer.radii_scene_id = None self.viewer.match_valarrays = [] self.viewer.proc_arrays = [] self.spacegroup_choices = [] display.reset_settings() self.settings = display.settings() self.viewer.settings = self.params.NGL_HKLviewer.viewer self.viewer.mapcoef_fom_dict = {} self.hklfile_history = [] self.tncsvec = None try : hkl_file = any_reflection_file(file_name) arrays = hkl_file.as_miller_arrays(merge_equivalents=False, )#observation_type_callback=misc_dialogs.get_shelx_file_data_type) #arrays = f.file_server.miller_arrays if hkl_file._file_type == 'ccp4_mtz': self.hklfile_history = list(hkl_file._file_content.history()) for e in self.hklfile_history: if "TNCS NMOL" in e and "VECTOR" in e: svec = e.split()[-3:] t1 = float(svec[0]) t2 = float(svec[1]) t3 = float(svec[2]) if (t1*t1 + t2*t2 + t3*t3) > 0.0: self.tncsvec = [ t1, t2, t3 ] self.mprint("tNCS vector found in header of mtz file: %s" %str(svec) ) except Exception as e : self.NewFileLoaded=False self.mprint(to_str(e)) arrays = [] valid_arrays = [] self.viewer.array_infostrs = [] self.viewer.array_infotpls = [] for array in arrays : if (not array.is_real_array()) and (not array.is_complex_array()) \ and (not array.is_integer_array()) and (not array.is_bool_array()) : self.mprint('Ignoring miller array \"%s\" of %s' \ %(array.info().label_string(), type(array.data()[0]) ) ) continue self.viewer.array_infostrs.append( ArrayInfo(array, self.mprint).infostr ) self.viewer.array_infotpls.append( ArrayInfo(array, self.mprint).infotpl ) valid_arrays.append(array) self.valid_arrays = valid_arrays self.mprint("%d Miller arrays in this file:" %len(arrays)) for e in self.viewer.array_infostrs: self.mprint("%s" %e) self.mprint("\n") self.NewFileLoaded = True if (len(valid_arrays) == 0): msg = "No arrays of the supported types in this file." self.mprint(msg) self.NewFileLoaded=False elif (len(valid_arrays) >= 1): self.set_miller_array() mydict = { "info": self.infostr, "array_infotpls": self.viewer.array_infotpls, "bin_infotpls": self.viewer.bin_infotpls, "html_url": self.viewer.url, "tncsvec": self.tncsvec, "merge_data": self.params.NGL_HKLviewer.merge_data, "spacegroups": [e.symbol_and_number() for e in self.spacegroup_choices], "NewFileLoaded": self.NewFileLoaded, "file_name": self.params.NGL_HKLviewer.openfilename } self.SendInfoToGUI(mydict) ret = True self.params.NGL_HKLviewer.openfilename = None return ret
def convert_scaled_intensities_to_structure_factors( scaled_intensity_mtz_filename): cwd = os.getcwd() scaled_intensity_mtz_fullpath = os.path.join( cwd, scaled_intensity_mtz_filename) scaled_structure_factor_mtz_prefix = scaled_intensity_mtz_filename.split( '.')[-2] hkl_file = any_reflection_file(scaled_intensity_mtz_fullpath) info = hkl_file.file_content() xtals = info.crystals() if len(xtals) > 1: xtal = xtals[0] else: xtal = xtals space_group = info.space_group_number() unit_cell = xtal.unit_cell_parameters() uc_a, uc_b, uc_c, uc_al, uc_be, uc_ga = unit_cell uc_str = str(unit_cell)[1:-1] RFE_def_file_fullpath = os.path.join(cwd, "reflection_file_editor.def") RFE_def_file = open(RFE_def_file_fullpath, 'w') RFE_def_text = """show_arrays = False dry_run = False verbose = True mtz_file { crystal_symmetry { unit_cell = %s space_group = %s output_unit_cell = None output_space_group = None change_of_basis = None eliminate_invalid_indices = False expand_to_p1 = False disable_unit_cell_check = True disable_space_group_check = False eliminate_sys_absent = True } d_max = None d_min = None wavelength = None output_file = %s/%s_asF.mtz job_title = None resolve_label_conflicts = True exclude_reflection = None miller_array { file_name = %s labels = Iobs,SIGIobs output_labels = FOBS SIGFOBS column_root_label = None d_min = None d_max = None output_as = auto intensities amplitudes_fw *amplitudes anomalous_data = *Auto merged anomalous force_type = *auto amplitudes intensities scale_max = None scale_factor = None remove_negatives = False massage_intensities = False filter_by_signal_to_noise = None add_b_iso = None add_b_aniso = 0 0 0 0 0 0 shuffle_values = False reset_values_to = None } r_free_flags { generate = False force_generate = False new_label = "FreeR_flag" fraction = 0.1 max_free = 2000 lattice_symmetry_max_delta = 5 use_lattice_symmetry = True use_dataman_shells = False n_shells = 20 random_seed = None extend = True old_test_flag_value = None export_for_ccp4 = False preserve_input_values = True warn_if_all_same_value = True adjust_fraction = False d_eps = 0.0001 relative_to_complete_set = False remediate_mismatches = False } } """ % (uc_str, space_group, cwd, scaled_structure_factor_mtz_prefix, scaled_intensity_mtz_fullpath) RFE_def_file.write(RFE_def_text) RFE_def_file.close() print "Wrote RFE def file successfully! - Now converting intensities to structure factor amplitudes with RFE." subprocess.call( ['iotbx.reflection_file_editor', 'reflection_file_editor.def']) output_mtz_filename = "%s_asF.mtz" % (scaled_structure_factor_mtz_prefix) return output_mtz_filename print "Conversion to Structure Factors is finished!"
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 = extract_xtal_data.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 = extract_xtal_data.run( reflection_file_server=reflection_file_server, keep_going=True, parameters=parameters, log=null_out()) except: # intentional parameters = extract_xtal_data.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 = extract_xtal_data.run( 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 = extract_xtal_data.data_and_flags_master_params( ).extract() if (label is not None): parameters.labels = [label] determine_data_and_flags_result = extract_xtal_data.run( 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 exercise_get_xtal_data(): crystal_symmetry = crystal.symmetry(unit_cell=(10, 11, 12, 85, 95, 100), space_group_symbol="P 1") miller_set = miller.build_set(crystal_symmetry=crystal_symmetry, anomalous_flag=False, d_min=3) input_arrays = [ miller_set.array( data=flex.random_double(size=miller_set.indices().size()), sigmas=flex.random_double(size=miller_set.indices().size()) / 10).set_observation_type_xray_intensity() for i in [0, 1] ] mtz_dataset = input_arrays[0].as_mtz_dataset(column_root_label="F0") mtz_dataset.mtz_object().write("tmp_rfu1.mtz") reflection_files = [ reflection_file_reader.any_reflection_file(file_name="tmp_rfu1.mtz") ] reflection_file_srv = reflection_file_server( crystal_symmetry=crystal_symmetry, force_symmetry=True, reflection_files=reflection_files) f_obs = reflection_file_srv.get_xray_data(file_name=None, labels=None, ignore_all_zeros=False, parameter_scope="xray_data") assert str(f_obs.info()) == "tmp_rfu1.mtz:F0,SIGF0" mtz_dataset.add_miller_array(miller_array=input_arrays[1], column_root_label="F1") mtz_dataset.mtz_object().write("tmp_rfu2.mtz") reflection_files = [ reflection_file_reader.any_reflection_file(file_name="tmp_rfu2.mtz") ] err = StringIO() reflection_file_srv = reflection_file_server( crystal_symmetry=crystal_symmetry, force_symmetry=True, reflection_files=reflection_files, err=err) try: f_obs = reflection_file_srv.get_xray_data(file_name=None, labels=None, ignore_all_zeros=True, parameter_scope="xray_data") except Sorry: assert err.getvalue() == """\ Multiple equally suitable arrays of observed xray data found. Possible choices: tmp_rfu2.mtz:F0,SIGF0 tmp_rfu2.mtz:F1,SIGF1 Please use xray_data.labels to specify an unambiguous substring of the target label. """ err = reflection_file_srv.err = StringIO() else: raise Exception_expected f_obs_list = reflection_file_srv.get_xray_data( file_name=None, labels=None, ignore_all_zeros=True, parameter_scope="xray_data", return_all_valid_arrays=True, minimum_score=1) assert len(f_obs_list) == 2 f_obs = reflection_file_srv.get_xray_data(file_name=None, labels=["F1", "SIGF1"], ignore_all_zeros=True, parameter_scope="xray_data") assert str(f_obs.info()) == "tmp_rfu2.mtz:F1,SIGF1" try: f_obs = reflection_file_srv.get_xray_data(file_name=None, labels=["F1", "SIGF0"], ignore_all_zeros=True, parameter_scope="xray_data") except Sorry: assert err.getvalue() == """\ No matching array: xray_data.labels=F1 SIGF0 Possible choices: tmp_rfu2.mtz:F0,SIGF0 tmp_rfu2.mtz:F1,SIGF1 Please use xray_data.labels to specify an unambiguous substring of the target label. """ err = reflection_file_srv.err = StringIO() else: raise Exception_expected assert len(reflection_file_srv.file_name_miller_arrays) == 1 f_obs = reflection_file_srv.get_xray_data(file_name="tmp_rfu1.mtz", labels=None, ignore_all_zeros=True, parameter_scope="xray_data") assert len(reflection_file_srv.file_name_miller_arrays) == 2 assert str(f_obs.info()) == "tmp_rfu1.mtz:F0,SIGF0" f_obs = reflection_file_srv.get_xray_data( file_name=os.path.abspath("tmp_rfu1.mtz"), labels=["sigf0"], ignore_all_zeros=True, parameter_scope="xray_data") assert len(reflection_file_srv.file_name_miller_arrays) == 2 assert str(f_obs.info()) == "tmp_rfu1.mtz:F0,SIGF0" try: f_obs = reflection_file_srv.get_xray_data(file_name=None, labels=None, ignore_all_zeros=True, parameter_scope="xray_data") except Sorry: assert err.getvalue() == """\ Multiple equally suitable arrays of observed xray data found. Possible choices: tmp_rfu2.mtz:F0,SIGF0 tmp_rfu2.mtz:F1,SIGF1 Please use xray_data.labels to specify an unambiguous substring of the target label. """ err = reflection_file_srv.err = StringIO() else: raise Exception_expected # test preference for anomalous (or merged) data miller_set = miller.build_set(crystal_symmetry=crystal_symmetry, anomalous_flag=True, d_min=3) i_obs = miller_set.array( data=flex.random_double(size=miller_set.indices().size()), sigmas=flex.random_double(size=miller_set.indices().size()) / 10).set_observation_type_xray_intensity() i_mean = i_obs.average_bijvoet_mates() mtz_data = i_obs.as_mtz_dataset(column_root_label="I") mtz_data.add_miller_array(i_mean, column_root_label="I") mtz_data.mtz_object().write("tmp_rfu3.mtz") reflection_files = [ reflection_file_reader.any_reflection_file(file_name="tmp_rfu3.mtz") ] reflection_file_srv = reflection_file_server( crystal_symmetry=crystal_symmetry, force_symmetry=True, reflection_files=reflection_files) err = reflection_file_srv.err = StringIO() try: i_obs = reflection_file_srv.get_xray_data(file_name=None, labels=None, ignore_all_zeros=False, parameter_scope="xray_data") except Sorry: pass i_obs = reflection_file_srv.get_xray_data(file_name=None, labels=None, ignore_all_zeros=False, parameter_scope="xray_data", prefer_anomalous=True) assert (i_obs.info().label_string() == "I(+),SIGI(+),I(-),SIGI(-)") i_obs = reflection_file_srv.get_xray_data(file_name=None, labels=None, ignore_all_zeros=False, parameter_scope="xray_data", prefer_anomalous=False) assert (i_obs.info().label_string() == "I,SIGI")
''' return self._cchalf def delta_cchalf_i(self): ''' Return the Delta CC 1/2 for each image excluded ''' return dict((k, v - self._cchalf_mean) for k, v in self._cchalf.iteritems()) if __name__ == '__main__': # Read the mtz file reader = any_reflection_file(sys.argv[1]) # Get the columns as miller arrays miller_arrays = reader.as_miller_arrays(merge_equivalents=False) # Select the desired columns intensities = None batches = None for array in miller_arrays: if array.info().labels == ['I', 'SIGI']: intensities = array if array.info().labels == ['BATCH']: batches = array assert intensities is not None assert batches is not None assert len(batches.data()) == len(intensities.data())
def exercise(prefix="tst_polder_ccs"): """ Test for phenix.polder correlation coefficients. """ # write pdb string to file f = open("%s.pdb" % prefix, "w") f.write(pdb_str) f.close() # get mtz file from model using fmodel cmd = " ".join([ "phenix.fmodel", "%s.pdb" % prefix, "high_res=2.0", "type=real", "label=f-obs", "k_sol=0.4", "b_sol=50", "output.file_name=%s.mtz" % prefix, "> %s.log" % prefix ]) print cmd easy_run.call(cmd) # get params.polder params_line = master_params_str params = iotbx.phil.parse(input_string=params_line, process_includes=True).extract() pdb_input = iotbx.pdb.input(file_name='tst_polder_ccs.pdb') pdb_hierarchy = pdb_input.construct_hierarchy() crystal_symmetry = crystal_symmetry_from_any.extract_from( 'tst_polder_ccs.pdb') xray_structure = pdb_hierarchy.extract_xray_structure( crystal_symmetry=crystal_symmetry) selection_bool = pdb_hierarchy.atom_selection_cache().selection( string='resseq 88') #f_obs = abs(xray_structure.structure_factors(d_min=2).f_calc()) #mtz = f_obs.as_mtz_dataset(column_root_label = "Fobs") #mtz.mtz_object().write("bla.mtz") miller_arrays = reflection_file_reader.any_reflection_file( file_name="tst_polder_ccs.mtz").as_miller_arrays() fobs = [None] for ma in miller_arrays: if (ma.info().label_string() == "f-obs"): fobs = ma.deep_copy() # Calculate polder map and get results polder_object = mmtbx.maps.polder_lib.compute_polder_map( f_obs=fobs, r_free_flags=None, xray_structure=xray_structure, pdb_hierarchy=pdb_hierarchy, params=params.polder, selection_bool=selection_bool) polder_object.validate() polder_object.run() results = polder_object.get_results() #mtz_dataset = results.mc_polder.as_mtz_dataset( # column_root_label = "mFo-DFc_polder") #mtz_dataset.add_miller_array( # miller_array = results.mc_omit, # column_root_label = "mFo-DFc_omit") #mtz_object = mtz_dataset.mtz_object() #mtz_object.write(file_name = "bla.mtz") box_1 = results.box_1 box_2 = results.box_2 box_3 = results.box_3 sites_cart_box = box_1.xray_structure_box.sites_cart() sel = maptbx.grid_indices_around_sites( unit_cell=box_1.xray_structure_box.unit_cell(), fft_n_real=box_1.map_box.focus(), fft_m_real=box_1.map_box.all(), sites_cart=sites_cart_box, site_radii=flex.double(sites_cart_box.size(), 2.0)) b1 = box_1.map_box.select(sel).as_1d() b2 = box_2.map_box.select(sel).as_1d() b3 = box_3.map_box.select(sel).as_1d() #print "Map 1: calculated Fobs with ligand", "CC(1,2): %6.4f" % cc12 #print "Map 2: calculated Fobs without ligand", "CC(1,3): %6.4f" % cc13 #print "Map 3: real Fobs data", "CC(2,3): %6.4f" % cc23 cc12 = flex.linear_correlation(x=b1, y=b2).coefficient() cc13 = flex.linear_correlation(x=b1, y=b3).coefficient() cc23 = flex.linear_correlation(x=b2, y=b3).coefficient() #print "CC(1,2): %6.4f" % cc12 #print "CC(1,3): %6.4f" % cc13 #print "CC(2,3): %6.4f" % cc23 #### D-function b1 = maptbx.volume_scale_1d(map=b1, n_bins=10000).map_data() b2 = maptbx.volume_scale_1d(map=b2, n_bins=10000).map_data() b3 = maptbx.volume_scale_1d(map=b3, n_bins=10000).map_data() #print "Peak CC:" cc12p = flex.linear_correlation(x=b1, y=b2).coefficient() cc13p = flex.linear_correlation(x=b1, y=b3).coefficient() cc23p = flex.linear_correlation(x=b2, y=b3).coefficient() #print "CC(1,2): %6.4f" % cc12p #print "CC(1,3): %6.4f" % cc13p #print "CC(2,3): %6.4f" % cc23p assert approx_equal([cc12, cc13, cc23], [0.4153, 0.9980, 0.4213], eps=0.1) assert approx_equal([cc12p, cc13p, cc23p], [0.4310, 0.9966, 0.4379], eps=0.1)
else: assert i_exercise == 0 actual_test_flag_value_2 = guess_r_free_flag_value( miller_array=r_free_flags, test_flag_value=trial_test_flag_value) assert (actual_test_flag_value_2 == actual_test_flag_value) for second_label in ["test", "foo"]: input_array = miller_set.array(data=exercise_flag_arrays[0]) mtz_dataset = input_array.as_mtz_dataset( column_root_label="FreeRflags") mtz_dataset.add_miller_array(miller_array=input_array, column_root_label=second_label) mtz_dataset.mtz_object().write("tmp.mtz") reflection_files = [ reflection_file_reader.any_reflection_file(file_name="tmp.mtz") ] err = StringIO() reflection_file_srv = reflection_file_server( crystal_symmetry=crystal_symmetry, force_symmetry=True, reflection_files=reflection_files, err=err) try: reflection_file_srv.get_r_free_flags( file_name=None, label=None, test_flag_value=None, disable_suitability_test=False, parameter_scope="r_free_flags") except Sorry, e: