def run(args): cmdline = iotbx.phil.process_command_line_with_files( args=args, master_phil_string=master_phil_str, reflection_file_def="data", pdb_file_def="symmetry") params = cmdline.work.extract() if (params.data is None): raise Sorry("Data file not defined") hkl_file = cmdline.get_file(params.data) crystal_symmetry = None if (params.symmetry is not None): from iotbx import crystal_symmetry_from_any crystal_symmetry = crystal_symmetry_from_any.extract_from( file_name=params.symmetry) hkl_server = reflection_file_server( crystal_symmetry=crystal_symmetry, force_symmetry=True, reflection_files=[hkl_file.file_object], err=sys.stderr) data = hkl_server.get_xray_data(file_name=params.data, labels=params.labels, ignore_all_zeros=True, parameter_scope="", minimum_score=4, prefer_anomalous=True) if (not data.anomalous_flag()): raise Sorry("Must provide anomalous data.") if data.is_xray_intensity_array(): data = data.f_sq_as_f() dano = abs(data.anomalous_differences()) dano.set_observation_type_xray_amplitude() dano.as_mtz_dataset(column_root_label="F").mtz_object().write( params.mtz_out) print("Wrote DANO to %s" % params.mtz_out)
def run(args): if (len(args) == 0): args = ["--help"] command_line = (option_parser(usage="%s [OPTIONS] FILE..." % libtbx.env.dispatcher_name).option( None, "--niggli_cell", action="store_true")).process(args=args) if (len(command_line.args) == 0): command_line.parser.show_help() return co = command_line.options for arg in command_line.args: crystal_symmetry = crystal_symmetry_from_any.extract_from(arg) if (crystal_symmetry is None): raise RuntimeError, \ "Unknown file format or unit cell and space group missing from file." if (co.niggli_cell and crystal_symmetry.unit_cell() is not None and crystal_symmetry.space_group_info() is not None): crystal_symmetry = crystal_symmetry.niggli_cell() format.crystal_symmetry(crystal_symmetry) print print "\n".join( crystal_symmetry_as_cns_inp_defines( crystal_symmetry=crystal_symmetry)) print print format_cryst1_and_scale_records( crystal_symmetry=crystal_symmetry, write_scale_records=True) print
def run(args): if (len(args) == 0): args = ["--help"] command_line = (option_parser( usage="%s [OPTIONS] FILE..." % libtbx.env.dispatcher_name) .option(None, "--niggli_cell", action="store_true") ).process(args=args) if (len(command_line.args) == 0): command_line.parser.show_help() return co = command_line.options for arg in command_line.args: crystal_symmetry = crystal_symmetry_from_any.extract_from(arg) if (crystal_symmetry is None): raise RuntimeError, \ "Unknown file format or unit cell and space group missing from file." if (co.niggli_cell and crystal_symmetry.unit_cell() is not None and crystal_symmetry.space_group_info() is not None): crystal_symmetry = crystal_symmetry.niggli_cell() format.crystal_symmetry(crystal_symmetry) print print "\n".join( crystal_symmetry_as_cns_inp_defines(crystal_symmetry=crystal_symmetry)) print print format_cryst1_and_scale_records( crystal_symmetry=crystal_symmetry, write_scale_records=True) print
def compute_map(self): log = sys.stderr # the mtz and pdb files are self.mtz_file self.pdb_file, respectively #out = maps.run(args = [self.pdb_file, self.mtz_file]) #self.map_coeff_file, self.xplor_maps = out[0],out[1] master_params = mmtbx.maps.maps_including_IO_master_params() master_params = master_params.fetch(iotbx.phil.parse(default_params)) processed_args = mmtbx.utils.process_command_line_args( args=[self.mtz_file, self.pdb_file], log=log, master_params=master_params) working_phil = processed_args.params params = working_phil.extract() if params.maps.input.pdb_file_name is None: params.maps.input.pdb_file_name = self.pdb_file if params.maps.input.reflection_data.file_name is None: params.maps.input.reflection_data.file_name = self.mtz_file pdb_inp = iotbx.pdb.input(file_name=params.maps.input.pdb_file_name) # get all crystal symmetries cs_from_coordinate_files = [pdb_inp.crystal_symmetry_from_cryst1()] csa = crystal_symmetry_from_any.extract_from( params.maps.input.reflection_data.file_name) cs_from_reflection_files = [csa] crystal_symmetry = None try: crystal_symmetry = crystal.select_crystal_symmetry( from_coordinate_files=cs_from_coordinate_files, from_reflection_files=cs_from_reflection_files) 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.")
def write(self, pdb_output_file_name="", crystal_symmetry=None): """ (string) -> text file Writes the modified protein, with the added chains, obtained by the BIOMT/MTRIX reconstruction, to a text file in a pdb format. self.assembled_multimer is the modified pdb object with the added chains Argumets: pdb_output_file_name -- string. 'name.pdb' if no pdn_output_file_name is given pdb_output_file_name=file_name >>> v = multimer('name.pdb','ba') >>> v.write('new_name.pdb') Write a file 'new_name.pdb' to the current directory >>> v.write(v.pdb_input_file_name) Write a file 'copy_name.pdb' to the current directory """ input_file_name = os.path.basename(self.pdb_input_file_name) if pdb_output_file_name == "": pdb_output_file_name = input_file_name # Avoid writing over the original file if pdb_output_file_name == input_file_name: # if file name of output is the same as the input, add 'copy_' in front of the name self.pdb_output_file_name = self.transform_type + "_" + input_file_name else: self.pdb_output_file_name = pdb_output_file_name # we need to add crystal symmetry to the new file since it is # sometimes needed when calculating the R-work factor (r_factor_calc.py) if not crystal_symmetry and os.path.isfile(self.pdb_input_file_name): crystal_symmetry = crystal_symmetry_from_any.extract_from(self.pdb_input_file_name) # using the function to write whole pdb file pdb.write_whole_pdb_file( file_name=self.pdb_output_file_name, pdb_hierarchy=self.assembled_multimer, crystal_symmetry=crystal_symmetry, )
def exercise () : open("tmp_fmodel_fake_p1.pdb", "w").write("""\ ATOM 47 N TYR A 7 8.292 1.817 6.147 1.00 14.70 N ATOM 48 CA TYR A 7 9.159 2.144 7.299 1.00 15.18 C ATOM 49 C TYR A 7 10.603 2.331 6.885 1.00 15.91 C ATOM 50 O TYR A 7 11.041 1.811 5.855 1.00 15.76 O ATOM 51 CB TYR A 7 9.061 1.065 8.369 1.00 15.35 C ATOM 52 CG TYR A 7 7.665 0.929 8.902 1.00 14.45 C ATOM 53 CD1 TYR A 7 6.771 0.021 8.327 1.00 15.68 C ATOM 54 CD2 TYR A 7 7.210 1.756 9.920 1.00 14.80 C ATOM 55 CE1 TYR A 7 5.480 -0.094 8.796 1.00 13.46 C ATOM 56 CE2 TYR A 7 5.904 1.649 10.416 1.00 14.33 C ATOM 57 CZ TYR A 7 5.047 0.729 9.831 1.00 15.09 C ATOM 58 OH TYR A 7 3.766 0.589 10.291 1.00 14.39 O ATOM 59 OXT TYR A 7 11.358 2.999 7.612 1.00 17.49 O """) args = ["phenix.fmodel", "tmp_fmodel_fake_p1.pdb", "high_resolution=2", "output.file_name=tmp_fmodel_fake_p1.mtz"] result = easy_run.fully_buffered(args) assert (result.return_code != 0) and (len(result.stderr_lines) > 0) args.append("generate_fake_p1_symmetry=True") result = easy_run.fully_buffered(args).raise_if_errors() assert (result.return_code == 0) assert os.path.isfile("tmp_fmodel_fake_p1.mtz") from iotbx import crystal_symmetry_from_any symm = crystal_symmetry_from_any.extract_from("tmp_fmodel_fake_p1.mtz") assert (str(symm.space_group_info()) == "P 1") # FIXME this should fail but doesn't due to a bug in the program #args.append("reference_file=tmp_fmodel_fake_p1.mtz") #args.append("data_column_label=FMODEL,PHIFMODEL") #result = easy_run.fully_buffered(args).raise_if_errors() #print result.return_code print "OK"
def check_symmetry(inputs, params, log): #check for usable and consistent symmetry #somehow, this happens beforehand sometimes? #inputs finds a symmetry object from somewhere? print >> log, "_" * 79 print >> log, "Checking Crystal Symmetry:" crystal_symmetry = None crystal_symmetry = inputs.crystal_symmetry if (crystal_symmetry is None): crystal_symmetries = [] for f in [ str(params.input.pdb.model_pdb), str(params.input.reflection_data.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] print >> log, " Unit Cell: ", crystal_symmetry.unit_cell().parameters() return crystal_symmetry
def compute_map(self) : log = sys.stderr # the mtz and pdb files are self.mtz_file self.pdb_file, respectively #out = maps.run(args = [self.pdb_file, self.mtz_file]) #self.map_coeff_file, self.xplor_maps = out[0],out[1] master_params = mmtbx.maps.maps_including_IO_master_params() master_params = master_params.fetch(iotbx.phil.parse(default_params)) processed_args = mmtbx.utils.process_command_line_args( args=[self.mtz_file, self.pdb_file], log=log, master_params=master_params) working_phil = processed_args.params params = working_phil.extract() if params.maps.input.pdb_file_name is None : params.maps.input.pdb_file_name = self.pdb_file if params.maps.input.reflection_data.file_name is None : params.maps.input.reflection_data.file_name = self.mtz_file pdb_inp = iotbx.pdb.input(file_name = params.maps.input.pdb_file_name) # get all crystal symmetries cs_from_coordinate_files = [pdb_inp.crystal_symmetry_from_cryst1()] csa =crystal_symmetry_from_any.extract_from(params.maps.input.reflection_data.file_name) cs_from_reflection_files = [csa] crystal_symmetry = None try : crystal_symmetry = crystal.select_crystal_symmetry( from_coordinate_files=cs_from_coordinate_files, from_reflection_files=cs_from_reflection_files) 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.")
def run(args): if (len(args) != 2): raise Usage("""\ iotbx.cns.transfer_crystal_symmetry any_symmetry_source_file cns_input_file ********************************************* NOTE: the cns_input_file is changed in place. *********************************************""") # for file_name in args: if (not os.path.exists(file_name)): raise Sorry("No such file: %s" % show_string(file_name)) source, target = args crystal_symmetry = crystal_symmetry_from_any.extract_from(source) if (crystal_symmetry is None): raise Sorry( "Unknown file format or unit cell and/or space group" " missing from file: " + show_string(source)) cns_space_group_symbol = cns.space_group_symbols.cns_format( space_group_info=crystal_symmetry.space_group_info()) if (cns_space_group_symbol is None): raise Sorry("Space group not available in CNS: %s" % show_string(str(crystal_symmetry.space_group_info()))) sg = '"%s"' % cns_space_group_symbol a,b,c,alpha,beta,gamma = ["%.6g" % p for p in crystal_symmetry.unit_cell().parameters()] parameter_names = ["sg", "a", "b", "c", "alpha", "beta", "gamma"] parameters_found = dict(zip(parameter_names, [0]*len(parameter_names))) parameters_changed = [] lines_out = [] detect_binary = detect_binary_file(monitor_initial=100) try: cns_inp = open(target).read().splitlines() except IOError, e: raise Sorry("Error reading file %s (%s)" % (show_string(target), str(e)))
def run (args) : cmdline = iotbx.phil.process_command_line_with_files( args=args, master_phil_string=master_phil_str, reflection_file_def="data", pdb_file_def="symmetry") params = cmdline.work.extract() if (params.data is None) : raise Sorry("Data file not defined") hkl_file = cmdline.get_file(params.data) crystal_symmetry = None if (params.symmetry is not None) : from iotbx import crystal_symmetry_from_any crystal_symmetry = crystal_symmetry_from_any.extract_from( file_name=params.symmetry) hkl_server = reflection_file_server( crystal_symmetry=crystal_symmetry, force_symmetry=True, reflection_files=[hkl_file.file_object], err=sys.stderr) data = hkl_server.get_xray_data( file_name=params.data, labels=params.labels, ignore_all_zeros=True, parameter_scope="", minimum_score=4, prefer_anomalous=True) if (not data.anomalous_flag()) : raise Sorry("Must provide anomalous data.") if data.is_xray_intensity_array() : data = data.f_sq_as_f() dano = abs(data.anomalous_differences()) dano.set_observation_type_xray_amplitude() dano.as_mtz_dataset(column_root_label="F").mtz_object().write(params.mtz_out) print "Wrote DANO to %s" % params.mtz_out
def read_cell_file(filename): query = crystal_symmetry_from_any.extract_from(filename) if query is not None: return query ifs = open(filename) fl = ifs.readline().strip() assert fl.startswith("CrystFEL unit cell file version ") filever = fl.split()[-1] cellkeys = ("a", "b", "c", "al", "be", "ga") cell = (0, 0, 0, 0, 0, 0) latt_type, centering = None, None if filever == "1.0": for l in ifs: sp = map(lambda x: x.strip(), l.split("=")) if len(sp) != 2: continue lhs, rhs = sp if lhs in cellkeys: cell[cellkeys.index(lhs)] = float(rhs.replace("A","").replace("deg","")) elif lhs == "lattice_type": latt_type = rhs elif lhs == "centering": centering = rhs return cell, latt_type, centering
def read_cell_file(filename): query = crystal_symmetry_from_any.extract_from(filename) if query is not None: return query ifs = open(filename) fl = ifs.readline().strip() assert fl.startswith("CrystFEL unit cell file version ") filever = fl.split()[-1] cellkeys = ("a", "b", "c", "al", "be", "ga") cell = (0, 0, 0, 0, 0, 0) latt_type, centering = None, None if filever == "1.0": for l in ifs: sp = map(lambda x: x.strip(), l.split("=")) if len(sp) != 2: continue lhs, rhs = sp if lhs in cellkeys: cell[cellkeys.index(lhs)] = float( rhs.replace("A", "").replace("deg", "")) elif lhs == "lattice_type": latt_type = rhs elif lhs == "centering": centering = rhs return cell, latt_type, centering
def exercise(): open("tmp_fmodel_fake_p1.pdb", "w").write("""\ ATOM 47 N TYR A 7 8.292 1.817 6.147 1.00 14.70 N ATOM 48 CA TYR A 7 9.159 2.144 7.299 1.00 15.18 C ATOM 49 C TYR A 7 10.603 2.331 6.885 1.00 15.91 C ATOM 50 O TYR A 7 11.041 1.811 5.855 1.00 15.76 O ATOM 51 CB TYR A 7 9.061 1.065 8.369 1.00 15.35 C ATOM 52 CG TYR A 7 7.665 0.929 8.902 1.00 14.45 C ATOM 53 CD1 TYR A 7 6.771 0.021 8.327 1.00 15.68 C ATOM 54 CD2 TYR A 7 7.210 1.756 9.920 1.00 14.80 C ATOM 55 CE1 TYR A 7 5.480 -0.094 8.796 1.00 13.46 C ATOM 56 CE2 TYR A 7 5.904 1.649 10.416 1.00 14.33 C ATOM 57 CZ TYR A 7 5.047 0.729 9.831 1.00 15.09 C ATOM 58 OH TYR A 7 3.766 0.589 10.291 1.00 14.39 O ATOM 59 OXT TYR A 7 11.358 2.999 7.612 1.00 17.49 O """) args = ["phenix.fmodel", "tmp_fmodel_fake_p1.pdb", "high_resolution=2", "output.file_name=tmp_fmodel_fake_p1.mtz"] result = easy_run.fully_buffered(args) assert (result.return_code != 0) and (len(result.stderr_lines) > 0) args.append("generate_fake_p1_symmetry=True") result = easy_run.fully_buffered(args).raise_if_errors() assert (result.return_code == 0) assert os.path.isfile("tmp_fmodel_fake_p1.mtz") from iotbx import crystal_symmetry_from_any symm = crystal_symmetry_from_any.extract_from("tmp_fmodel_fake_p1.mtz") assert (str(symm.space_group_info()) == "P 1") # FIXME this should fail but doesn't due to a bug in the program #args.append("reference_file=tmp_fmodel_fake_p1.mtz") #args.append("data_column_label=FMODEL,PHIFMODEL") #result = easy_run.fully_buffered(args).raise_if_errors() #print result.return_code print("OK")
def run(streamin, symm_source, params): symm = crystal_symmetry_from_any.extract_from(symm_source) ref, anoref = None, None if None not in (params.reference.anohkl,params.reference.anolabel): anoref = get_reference_data(params.reference.anohkl, params.reference.anolabel) if None not in (params.reference.hkl,params.reference.label): ref = get_reference_data(params.reference.hkl, params.reference.label, assert_anomalous=False) # no need to be anomalous.. if not params.anomalous and ref.anomalous_flag(): ref = ref.average_bijvoet_mates() # how many frames indexed? nindexed = 0 t = time.time() for l in bz2.BZ2File(streamin) if streamin.endswith(".bz2") else open(streamin): if l.startswith("indexed_by =") and l[l.index("=")+1:].strip() != "none": nindexed += 1 if params.stop_after is not None and params.stop_after <= (nindexed-params.start_at): break print >> sys.stderr, "# nframes checked (%d). time:" % nindexed, time.time() - t nindexed -= params.start_at if params.output_prefix is None: params.output_prefix = "stats_%s" % os.path.splitext(os.path.basename(streamin))[0] show_split_stats(streamin, nindexed, symm, params, anoref=anoref, ref=ref, out_prefix=params.output_prefix, start_at=params.start_at)
def run(args): if (len(args) != 2): raise Usage("""\ iotbx.cns.transfer_crystal_symmetry any_symmetry_source_file cns_input_file ********************************************* NOTE: the cns_input_file is changed in place. *********************************************""") # for file_name in args: if (not os.path.exists(file_name)): raise Sorry("No such file: %s" % show_string(file_name)) source, target = args crystal_symmetry = crystal_symmetry_from_any.extract_from(source) if (crystal_symmetry is None): raise Sorry("Unknown file format or unit cell and/or space group" " missing from file: " + show_string(source)) cns_space_group_symbol = cns.space_group_symbols.cns_format( space_group_info=crystal_symmetry.space_group_info()) if (cns_space_group_symbol is None): raise Sorry("Space group not available in CNS: %s" % show_string(str(crystal_symmetry.space_group_info()))) sg = '"%s"' % cns_space_group_symbol a, b, c, alpha, beta, gamma = [ "%.6g" % p for p in crystal_symmetry.unit_cell().parameters() ] parameter_names = ["sg", "a", "b", "c", "alpha", "beta", "gamma"] parameters_found = dict(zip(parameter_names, [0] * len(parameter_names))) parameters_changed = [] lines_out = [] detect_binary = detect_binary_file(monitor_initial=100) try: cns_inp = open(target).read().splitlines() except IOError, e: raise Sorry("Error reading file %s (%s)" % (show_string(target), str(e)))
def read_reference_data(filename, log_out): log_out.write("Reading reference file: %s\n" % filename) f = iotbx.file_reader.any_file(filename) if f.file_type == "hkl": array = f.file_server.get_xray_data(file_name=None, labels=None, ignore_all_zeros=True, parameter_scope="", prefer_anomalous=False, prefer_amplitudes=False) log_out.write(" Read data: %s\n\n" % array.info()) return array.as_intensity_array() elif f.file_type == "pdb": import mmtbx.utils xrs = f.file_content.xray_structure_simple() fmodel_params = mmtbx.command_line.fmodel.fmodel_from_xray_structure_master_params.extract( ) fmodel_params.fmodel.k_sol = 0.35 fmodel_params.fmodel.b_sol = 50 fmodel_params.high_resolution = 3.0 log_out.write(" Constructed reference from model:\n") xrs.show_summary(log_out, " ") log_out.write("\n") return mmtbx.utils.fmodel_from_xray_structure( xray_structure=xrs, params=fmodel_params).f_model.as_intensity_array() else: xs = crystal_symmetry_from_any.extract_from(filename) if xs is None: raise "Not useful file: %s" % filename log_out.write(" Read symmetry reference: \n") xs.show_summary(log_out, " ") log_out.write("\n") return miller.array(miller.set(xs, flex.miller_index()), flex.double()) # dummy array
def run(args, command_name="phenix.emma"): command_line = (option_parser( usage=command_name + " [options]" + " reference_coordinates other_coordinates", description="Example: %s model1.pdb model2.sdb" % command_name ).enable_symmetry_comprehensive().option( None, "--output_pdb", action="store", type="str", default="", help="Output pdb: second model transformed to best match first model", metavar="STR").option( None, "--tolerance", action="store", type="float", default=3., help="match tolerance", metavar="FLOAT").option( None, "--diffraction_index_equivalent", action="store_true", help="Use only if models are diffraction-index equivalent.") ).process(args=args, nargs=2) crystal_symmetry = command_line.symmetry if (crystal_symmetry.unit_cell() is None or crystal_symmetry.space_group_info() is None): for file_name in command_line.args: crystal_symmetry = crystal_symmetry.join_symmetry( other_symmetry=crystal_symmetry_from_any.extract_from( file_name=file_name), force=False) output_pdb = command_line.options.output_pdb if output_pdb: print "Output pdb:", output_pdb tolerance = command_line.options.tolerance print "Tolerance:", tolerance if (tolerance <= 0.): raise ValueError, "Tolerance must be greater than zero." print diffraction_index_equivalent = \ command_line.options.diffraction_index_equivalent if (diffraction_index_equivalent): print "Models are diffraction index equivalent." print second_model_as_pdb_inp = None emma_models = [] for file_name in command_line.args: emma_models.append( get_emma_model(file_name=file_name, crystal_symmetry=crystal_symmetry)) if len(emma_models) == 2 and os.path.isfile(file_name): try: second_model_as_pdb_inp = iotbx.pdb.input(file_name=file_name) except Exception, e: pass
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 = extract_xtal_data.data_and_flags_master_params().extract() if (params.data_labels is not None): parameters.labels = [processed_args.data_labels] determine_data_and_flags_result = extract_xtal_data.run( 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 exercise_crystal_symmetry(): cm = cif.reader(input_string=p1_sym_ops).model() cs_builder = cif.builders.crystal_symmetry_builder(cm["r1e5xsf"]) assert cs_builder.crystal_symmetry.space_group_info().symbol_and_number() \ == 'P 1 (No. 1)' file_object = open_tmp_file(suffix=".cif") file_object.write(p1_sym_ops) file_object.close() cs = crystal_symmetry_from_any.extract_from(file_name=file_object.name) assert cs.space_group_info().symbol_and_number() == 'P 1 (No. 1)'
def __call__(self, option, opt, value, parser): if (opt == "--unit_cell"): unit_cell = None try: unit_cell = uctbx.unit_cell(value) except Exception: pass if (unit_cell is not None): self.unit_cell = unit_cell else: crystal_symmetry = crystal_symmetry_from_any.extract_from( value) if (crystal_symmetry is None or crystal_symmetry.unit_cell() is None): raise OptionError("cannot read parameters: " + value, opt) self.unit_cell = crystal_symmetry.unit_cell() elif (opt == "--space_group"): space_group_info = None space_group_info = sgtbx.space_group_info(symbol=value) try: space_group_info = sgtbx.space_group_info(symbol=value) except Exception: pass if (space_group_info is not None): self.space_group_info = space_group_info else: crystal_symmetry = crystal_symmetry_from_any.extract_from( value) if (crystal_symmetry is None or crystal_symmetry.space_group_info() is None): raise OptionError("unknown space group: " + value, opt) self.space_group_info = crystal_symmetry.space_group_info() elif (opt == "--symmetry"): crystal_symmetry = crystal_symmetry_from_any.extract_from(value) if (crystal_symmetry is None or crystal_symmetry.space_group_info() is None): raise OptionError("cannot read symmetry: " + value, opt) if (crystal_symmetry.unit_cell() is not None): self.unit_cell = crystal_symmetry.unit_cell() if (crystal_symmetry.space_group_info() is not None): self.space_group_info = crystal_symmetry.space_group_info() else: raise RuntimeError("Programming error.")
def run (args=(), params=None, out=sys.stdout) : if (len(args) > 0) : cmdline = iotbx.phil.process_command_line_with_files( args=args, master_phil=master_phil, pdb_file_def="symmetry_search.file_name", reflection_file_def="symmetry_search.file_name") params = cmdline.work.extract().symmetry_search elif (params is None) : raise Usage("""mmtbx.search_pdb_symmetry [file] [space_group] [unit_cell] Utility for finding similar unit cells deposited in the PDB. """) else : params = params.symmetry_search from mmtbx import pdb_symmetry from iotbx import crystal_symmetry_from_any from cctbx import crystal db = pdb_symmetry.load_db() if (params.file_name is not None) : symm = crystal_symmetry_from_any.extract_from(file_name=params.file_name) if (symm is None) : raise Sorry("The file %s does not include symmetry information." % params.file_name) elif (symm.space_group() is None) or (symm.unit_cell() is None) : raise Sorry("Incomplete symmetry information in %s." % params.file_name) else : symm = crystal.symmetry( unit_cell=params.unit_cell, space_group_info=params.space_group) print >> out, "" print >> out, "Input symmetry:" symm.show_summary() scores = pdb_symmetry.symmetry_search(db, symm, max_rmsd=params.max_rmsd) niggli_cell = symm.niggli_cell().unit_cell().parameters() print >> out, "" print >> out, "Top %d matches (sorted by RMSD):" results = [] for scored in scores[:params.max_hits_to_display] : print >> out, "%s (rmsd = %.3f, volume ratio = %.2f)" % \ (scored.entry.pdb_id, scored.rmsd, scored.volume_ratio) print >> out, " Unit cell: %8.3f %8.3f %8.3f %8.3f %8.3f %8.3f" % \ scored.entry.crystal_symmetry.unit_cell().parameters() print >> out, " Niggli cell: %8.3f %8.3f %8.3f %8.3f %8.3f %8.3f" % \ scored.entry.niggli_cell.unit_cell().parameters() print >> out, " Target cell: %8.3f %8.3f %8.3f %8.3f %8.3f %8.3f" % \ niggli_cell print >> out, "" results.append(group_args( pdb_id=scored.entry.pdb_id, rmsd=scored.rmsd, volume_ratio=scored.volume_ratio, pdb_symmetry=scored.entry.crystal_symmetry)) return group_args( crystal_symmetry=symm, hits=results)
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 run(args, command_name="phenix.emma"): command_line = (option_parser( usage=command_name + " [options]" +" reference_coordinates other_coordinates", description="Example: %s model1.pdb model2.sdb" % command_name) .enable_symmetry_comprehensive() .option(None, "--output_pdb", action="store", type="str", default="", help="Output pdb: second model transformed to best match first model", metavar="STR") .option(None, "--tolerance", action="store", type="float", default=3., help="match tolerance", metavar="FLOAT") .option(None, "--diffraction_index_equivalent", action="store_true", help="Use only if models are diffraction-index equivalent.") ).process(args=args, nargs=2) crystal_symmetry = command_line.symmetry if ( crystal_symmetry.unit_cell() is None or crystal_symmetry.space_group_info() is None): for file_name in command_line.args: crystal_symmetry = crystal_symmetry.join_symmetry( other_symmetry=crystal_symmetry_from_any.extract_from( file_name=file_name), force=False) output_pdb = command_line.options.output_pdb if output_pdb: print "Output pdb:",output_pdb tolerance = command_line.options.tolerance print "Tolerance:", tolerance if (tolerance <= 0.): raise ValueError, "Tolerance must be greater than zero." print diffraction_index_equivalent = \ command_line.options.diffraction_index_equivalent if (diffraction_index_equivalent): print "Models are diffraction index equivalent." print second_model_as_pdb_inp=None emma_models = [] for file_name in command_line.args: emma_models.append(get_emma_model( file_name=file_name, crystal_symmetry=crystal_symmetry)) if len(emma_models)==2 and os.path.isfile(file_name): try: second_model_as_pdb_inp=iotbx.pdb.input( file_name=file_name) except Exception,e: pass
def __init__(self, symm_source=None, hklin=None): self.symm = None if symm_source is not None: self.symm = crystal_symmetry_from_any.extract_from(symm_source) #print self.symm.space_group().is_chiral() print "Symmetry from",symm_source print self.symm.show_summary(prefix=" ") if hklin is not None: self.read_file(hklin)
def __init__(self, symm_source=None, hklin=None): self.symm = None if symm_source is not None: self.symm = crystal_symmetry_from_any.extract_from(symm_source) #print self.symm.space_group().is_chiral() print "Symmetry from", symm_source print self.symm.show_summary(prefix=" ") if hklin is not None: self.read_file(hklin)
def run (args, out=sys.stdout) : cmdline = iotbx.phil.process_command_line_with_files( args=args, master_phil_string=master_phil_str, reflection_file_def="data", pdb_file_def="symmetry", space_group_def="space_group", unit_cell_def="unit_cell", usage_string="""\ iotbx.show_systematic_absences data.hkl [space_group] [unit_cell]""") params = cmdline.work.extract() if (params.data is None) : raise Sorry("Data file not specified.") hkl_file = cmdline.get_file(params.data) hkl_server = reflection_file_server( crystal_symmetry=None, force_symmetry=True, reflection_files=[hkl_file.file_object], err=sys.stderr) data = hkl_server.get_xray_data( file_name=params.data, labels=params.labels, ignore_all_zeros=False, parameter_scope="", minimum_score=4, prefer_amplitudes=False) symm = data.crystal_symmetry() space_group = unit_cell = None if (params.symmetry is not None) : from iotbx import crystal_symmetry_from_any symm = crystal_symmetry_from_any.extract_from(file_name=params.symmetry) if (symm is not None) : space_group = symm.space_group_info() unit_cell = symm.unit_cell() if (space_group is None) : if (params.space_group is not None) : space_group = params.space_group else : raise Sorry("No space group defined.") if (unit_cell is None) : if (params.unit_cell is not None) : unit_cell = params.unit_cell else : raise Sorry("No unit cell defined.") symm = crystal.symmetry( space_group_info=space_group, unit_cell=unit_cell) data = data.customized_copy(crystal_symmetry=symm) if (data.sigmas() is None) : raise Sorry("Input data are missing experimental sigmas.") data.show_all_possible_systematic_absences(out=out)
def __call__(self, option, opt, value, parser): if (opt == "--unit_cell"): unit_cell = None try: unit_cell = uctbx.unit_cell(value) except Exception: pass if (unit_cell is not None): self.unit_cell = unit_cell else: crystal_symmetry = crystal_symmetry_from_any.extract_from(value) if ( crystal_symmetry is None or crystal_symmetry.unit_cell() is None): raise OptionError("cannot read parameters: " + value, opt) self.unit_cell = crystal_symmetry.unit_cell() elif (opt == "--space_group"): space_group_info = None space_group_info = sgtbx.space_group_info(symbol=value) try: space_group_info = sgtbx.space_group_info(symbol=value) except Exception: pass if (space_group_info is not None): self.space_group_info = space_group_info else: crystal_symmetry = crystal_symmetry_from_any.extract_from(value) if ( crystal_symmetry is None or crystal_symmetry.space_group_info() is None): raise OptionError("unknown space group: " + value, opt) self.space_group_info = crystal_symmetry.space_group_info() elif (opt == "--symmetry"): crystal_symmetry = crystal_symmetry_from_any.extract_from(value) if ( crystal_symmetry is None or crystal_symmetry.space_group_info() is None): raise OptionError("cannot read symmetry: " + value, opt) if (crystal_symmetry.unit_cell() is not None): self.unit_cell = crystal_symmetry.unit_cell() if (crystal_symmetry.space_group_info() is not None): self.space_group_info = crystal_symmetry.space_group_info() else: raise RuntimeError, "Programming error."
def run(args, out=sys.stdout): cmdline = iotbx.phil.process_command_line_with_files( args=args, master_phil_string=master_phil_str, reflection_file_def="data", pdb_file_def="symmetry", space_group_def="space_group", unit_cell_def="unit_cell", usage_string="""\ iotbx.show_systematic_absences data.hkl [space_group] [unit_cell]""") params = cmdline.work.extract() if (params.data is None): raise Sorry("Data file not specified.") hkl_file = cmdline.get_file(params.data) hkl_server = reflection_file_server( crystal_symmetry=None, force_symmetry=True, reflection_files=[hkl_file.file_object], err=sys.stderr) data = hkl_server.get_xray_data(file_name=params.data, labels=params.labels, ignore_all_zeros=False, parameter_scope="", minimum_score=4, prefer_amplitudes=False) symm = data.crystal_symmetry() space_group = unit_cell = None if (params.symmetry is not None): from iotbx import crystal_symmetry_from_any symm = crystal_symmetry_from_any.extract_from( file_name=params.symmetry) if (symm is not None): space_group = symm.space_group_info() unit_cell = symm.unit_cell() if (space_group is None): if (params.space_group is not None): space_group = params.space_group else: raise Sorry("No space group defined.") if (unit_cell is None): if (params.unit_cell is not None): unit_cell = params.unit_cell else: raise Sorry("No unit cell defined.") symm = crystal.symmetry(space_group_info=space_group, unit_cell=unit_cell) data = data.customized_copy(crystal_symmetry=symm) if (data.sigmas() is None): raise Sorry("Input data are missing experimental sigmas.") data.show_all_possible_systematic_absences(out=out)
def run(sf_file_name,pdb_file_name): # check if files exist if not isfile(sf_file_name): raise Sorry('{} is not a file'.format(sf_file_name)) if not isfile(pdb_file_name): raise Sorry('{} is not a file'.format(pdb_file_name)) # start processing file cs = crystal_symmetry_from_any.extract_from(pdb_file_name) base_array_info = miller.array_info(crystal_symmetry_from_file=cs) all_miller_arrays = cif.reader(file_path=sf_file_name).build_miller_arrays(base_array_info=base_array_info) # for (data_name, miller_arrays) in all_miller_arrays.iteritems(): print data_name for ma in miller_arrays.values(): print get_label(ma),ma print 'wait here'
def obtain_cs_if_gui_input(model_file_name, reflection_file_name): crystal_symmetries = [] for f in [str(model_file_name), str(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] return crystal_symmetry
def OnLoadSymmetry(self, event): file_name = wx.FileSelector( message="Select a reflection or PDB file containing symmetry", flags=wx.OPEN) if (file_name != ""): from iotbx import crystal_symmetry_from_any symm = crystal_symmetry_from_any.extract_from(file_name) if (symm is not None): space_group = symm.space_group_info() if (space_group is not None): self.space_group_ctrl.SetSpaceGroup(space_group) unit_cell = symm.unit_cell() if (unit_cell is not None): self.unit_cell_ctrl.SetUnitCell(unit_cell) else : raise Sorry("This file does not contain valid symmetry information.")
def OnLoadSymmetry (self, event) : file_name = wx.FileSelector( message="Select a reflection or PDB file containing symmetry", flags=wx.OPEN) if (file_name != "") : from iotbx import crystal_symmetry_from_any symm = crystal_symmetry_from_any.extract_from(file_name) if (symm is not None) : space_group = symm.space_group_info() if (space_group is not None) : self.space_group_ctrl.SetSpaceGroup(space_group) unit_cell = symm.unit_cell() if (unit_cell is not None) : self.unit_cell_ctrl.SetUnitCell(unit_cell) else : raise Sorry("This file does not contain valid symmetry information.")
def get_crystal_symmetry(self): crystal_symmetries = [] files = [self.data_manager.get_default_model_name()] if self.data_manager.get_default_miller_array_name() is not None: files.append(self.data_manager.get_default_miller_array_name()) for f in files: 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] return crystal_symmetry
def run(streamin, symm_source, params): symm = crystal_symmetry_from_any.extract_from(symm_source) ref, anoref = None, None if None not in (params.reference.anohkl, params.reference.anolabel): anoref = get_reference_data(params.reference.anohkl, params.reference.anolabel) if None not in (params.reference.hkl, params.reference.label): ref = get_reference_data( params.reference.hkl, params.reference.label, assert_anomalous=False) # no need to be anomalous.. if not params.anomalous and ref.anomalous_flag(): ref = ref.average_bijvoet_mates() # how many frames indexed? nindexed = 0 t = time.time() for l in bz2.BZ2File(streamin) if streamin.endswith(".bz2") else open( streamin): if l.startswith("indexed_by =") and l[l.index("=") + 1:].strip() != "none": nindexed += 1 if params.stop_after is not None and params.stop_after <= ( nindexed - params.start_at): break print >> sys.stderr, "# nframes checked (%d). time:" % nindexed, time.time( ) - t nindexed -= params.start_at if params.output_prefix is None: params.output_prefix = "stats_%s" % os.path.splitext( os.path.basename(streamin))[0] show_split_stats(streamin, nindexed, symm, params, anoref=anoref, ref=ref, out_prefix=params.output_prefix, start_at=params.start_at)
def write(self,pdb_output_file_name='',crystal_symmetry=None): ''' (string) -> text file Writes the modified protein, with the added chains, obtained by the BIOMT/MTRIX reconstruction, to a text file in a pdb format. self.assembled_multimer is the modified pdb object with the added chains Argumets: pdb_output_file_name -- string. 'name.pdb' if no pdn_output_file_name is given pdb_output_file_name=file_name >>> v = multimer('name.pdb','ba') >>> v.write('new_name.pdb') Write a file 'new_name.pdb' to the current directory >>> v.write(v.pdb_input_file_name) Write a file 'copy_name.pdb' to the current directory ''' input_file_name = os.path.basename(self.pdb_input_file_name) if pdb_output_file_name == '': pdb_output_file_name = input_file_name # Avoid writing over the original file if pdb_output_file_name == input_file_name: # if file name of output is the same as the input, add 'copy_' in front of the name self.pdb_output_file_name = self.transform_type + '_' + input_file_name else: self.pdb_output_file_name = pdb_output_file_name # we need to add crystal symmetry to the new file since it is # sometimes needed when calculating the R-work factor (r_factor_calc.py) if not crystal_symmetry and os.path.isfile(self.pdb_input_file_name): crystal_symmetry = crystal_symmetry_from_any.extract_from( self.pdb_input_file_name) # using the function to write whole pdb file pdb.write_whole_pdb_file( file_name=self.pdb_output_file_name, pdb_hierarchy=self.assembled_multimer, crystal_symmetry=crystal_symmetry, ss_annotation=self.new_annotation)
def run (args, out=None, master_params=None, assume_shelx_observation_type_is="intensities") : if (out is None) : out = sys.stdout import iotbx.phil if (master_params is None) : master_params = iotbx.phil.parse(master_phil, process_includes=True) cmdline = cmdline_processor( args=args, master_phil=master_params, reflection_file_def="file_name", pdb_file_def="symmetry_file", space_group_def="space_group", unit_cell_def="unit_cell", usage_string="""\ phenix.merging_statistics [data_file] [options...] Calculate merging statistics for non-unique data, including R-merge, R-meas, R-pim, and redundancy. Any format supported by Phenix is allowed, including MTZ, unmerged Scalepack, or XDS/XSCALE (and possibly others). Data should already be on a common scale, but with individual observations unmerged. %s """ % citations_str) params = cmdline.work.extract() i_obs = iotbx.merging_statistics.select_data( file_name=params.file_name, data_labels=params.labels, log=out, assume_shelx_observation_type_is=assume_shelx_observation_type_is) params.labels = i_obs.info().label_string() validate_params(params) symm = sg = uc = None if (params.symmetry_file is not None) : from iotbx import crystal_symmetry_from_any symm = crystal_symmetry_from_any.extract_from( file_name=params.symmetry_file) if (symm is None) : raise Sorry("No symmetry records found in %s." % params.symmetry_file) else : sg = i_obs.space_group() if (params.space_group is not None) : sg = params.space_group.group() elif (sg is None) : raise Sorry("Missing space group information.") uc = i_obs.unit_cell() if (params.unit_cell is not None) : uc = params.unit_cell elif (uc is None) : raise Sorry("Missing unit cell information.") from cctbx import crystal symm = crystal.symmetry( space_group=sg, unit_cell=uc) if (i_obs.sigmas() is None) : raise Sorry("Sigma(I) values required for this application.") result = iotbx.merging_statistics.dataset_statistics( i_obs=i_obs, crystal_symmetry=symm, d_min=params.high_resolution, d_max=params.low_resolution, n_bins=params.n_bins, anomalous=params.anomalous, debug=params.debug, file_name=params.file_name, sigma_filtering=params.sigma_filtering, extend_d_max_min=params.extend_d_max_min, log=out) result.show(out=out) if (getattr(params, "loggraph", False)) : result.show_loggraph(out=out) if (params.estimate_cutoffs) : result.show_estimated_cutoffs(out=out) print >> out, "" print >> out, "References:" print >> out, citations_str print >> out, "" return result
def simul_utils(args): if len(args)==0: print_help() elif ( "--help" in args ): print_help() elif ( "--h" in args ): print_help() elif ("-h" in args ): print_help() 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) phil_objects = [] argument_interpreter = master_params.command_line_argument_interpreter( home_scope="map_coefs") print >> log, "#phil __OFF__" print >> log, "======================" print >> log, " SIMUL " print >> log, "A data simulation tool" print >> log, "======================" print >> log for arg in args: command_line_params = None arg_is_processed = False # is it a file? if (os.path.isfile(arg)): ## is this a file name? # check if it is a phil file try: command_line_params = iotbx.phil.parse(file_name=arg) if command_line_params is not None: phil_objects.append(command_line_params) arg_is_processed = True except KeyboardInterrupt: raise except Exception : pass 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 file or keyword:", arg print >> log, "##----------------------------------------------##" print >> log raise Sorry("Unknown file or keyword: %s" % arg) effective_params = master_params.fetch(sources=phil_objects) params = effective_params.extract() """ new_params = master_params.format(python_object=params) new_params.show(out=log) """ # now get the unit cell from the pdb file hkl_xs = crystal_symmetry_from_any.extract_from( file_name=params.simul_utils.input.xray_data.file_name) pdb_xs = crystal_symmetry_from_any.extract_from( file_name=params.simul_utils.input.model.file_name) phil_xs = crystal.symmetry( unit_cell=params.simul_utils.input.unit_cell, space_group_info=params.simul_utils.input.space_group ) combined_xs = select_crystal_symmetry( None,phil_xs, [pdb_xs],[hkl_xs]) # inject the unit cell and symmetry in the phil scope please params.simul_utils.input.unit_cell = combined_xs.unit_cell() params.simul_utils.input.space_group = \ sgtbx.space_group_info( group = combined_xs.space_group() ) print >> log, "#phil __ON__" new_params = master_params.format(python_object=params) new_params.show(out=log) print >> log, "#phil __END__" if params.simul_utils.input.unit_cell is None: raise Sorry("unit cell not specified") if params.simul_utils.input.space_group is None: raise Sorry("space group not specified") if params.simul_utils.input.xray_data.file_name is None: raise Sorry("Xray data not specified") if params.simul_utils.input.model.file_name is None: raise Sorry("pdb file with model not specified") #----------------------------------------------------------- # # step 1: read in the reflection file # phil_xs = crystal.symmetry( unit_cell=params.simul_utils.input.unit_cell, space_group_info=params.simul_utils.input.space_group ) xray_data_server = reflection_file_utils.reflection_file_server( crystal_symmetry = phil_xs, force_symmetry = True, reflection_files=[]) miller_array = None miller_array = xray_data_server.get_xray_data( file_name = params.simul_utils.input.xray_data.file_name, labels = params.simul_utils.input.xray_data.labels, ignore_all_zeros = True, parameter_scope = 'simul_utils.input.xray_data', parameter_name = 'labels' ) info = miller_array.info() miller_array = miller_array.map_to_asu() miller_array = miller_array.select( miller_array.indices() != (0,0,0)) miller_array = miller_array.select( miller_array.data() > 0 ) if miller_array.sigmas() is not None: miller_array = miller_array.select( miller_array.sigmas() > 0 ) if (miller_array.is_xray_intensity_array()): miller_array = miller_array.f_sq_as_f() elif (miller_array.is_complex_array()): miller_array = abs(miller_array) miller_array.set_info(info) print >> log print >> log, "Summary info of observed data" print >> log, "=============================" miller_array.show_summary(f=log) print >> log free_flags = miller_array.generate_r_free_flags() #-------------------------------------------------------------------- # Step 2: get an xray structure from the PDB file # model = pdb.input(file_name=params.simul_utils.input.model.file_name).xray_structure_simple( crystal_symmetry=phil_xs, ) print >> log, "Atomic model summary" print >> log, "====================" model.show_summary() print >> log #------------------------------------------------------------------- # Step 3: make an F_model object to get model phases and amplitudes # print >> log, "Performing bulk solvent scaling" print >> log, "===============================" print >> log print >> log f_model_object = f_model.manager( f_obs = miller_array, r_free_flags = free_flags, xray_structure = model ) f_model_object.update_solvent_and_scale(out=log) fmodel = abs( f_model_object.f_model() ).set_observation_type( miller_array ) mockfmodel = None if params.simul_utils.input.mock_model.file_name is not None: print >> log, "Reading in mock model" print >> log, "=====================" print >> log print >> log mock_model = pdb.input(file_name=params.simul_utils.input.mock_model.file_name).xray_structure_simple( crystal_symmetry=phil_xs) mock_f_model = f_model.manager( f_obs = miller_array, r_free_flags = free_flags, xray_structure = mock_model ) mock_f_model.update( k_sol = f_model_object.k_sol() , b_sol = f_model_object.b_sol() , b_cart = f_model_object.b_cart() ) mockfmodel = abs( mock_f_model.f_model() ).set_observation_type( miller_array ) else: mockfmodel = fmodel.deep_copy() print >> log, "Making new data" print >> log, "===============" print >> log print >> log new_data_builder = error_swap( miller_array, fmodel, mockfmodel ) new_data = new_data_builder.new_obs # we now have to write the data actually print >> log, "Writing new data set" print >> log, "====================" mtz_dataset = new_data.as_mtz_dataset( column_root_label="FOBS") mtz_dataset.mtz_object().write( file_name=params.simul_utils.output.hklout)
def run(args, command_name="emma_shelxd_lst.py"): command_line = (option_parser( usage=command_name + " [options]" +" reference_coordinates shelxd-lst-file", description="Example: %s model1.pdb sad_fa.lst" % command_name) .enable_symmetry_comprehensive() .option(None, "--tolerance", action="store", type="float", default=.5, help="match tolerance", metavar="FLOAT") .option(None, "--diffraction_index_equivalent", action="store_true", help="Use only if models are diffraction-index equivalent.") ).process(args=args, nargs=2) crystal_symmetry = command_line.symmetry if ( crystal_symmetry.unit_cell() is None or crystal_symmetry.space_group_info() is None): for file_name in command_line.args: crystal_symmetry = crystal_symmetry.join_symmetry( other_symmetry=crystal_symmetry_from_any.extract_from( file_name=file_name), force=False) tolerance = command_line.options.tolerance print "Tolerance:", tolerance if (tolerance <= 0.): raise ValueError, "Tolerance must be greater than zero." print diffraction_index_equivalent = \ command_line.options.diffraction_index_equivalent if (diffraction_index_equivalent): print "Models are diffraction index equivalent." print emma_ref = get_emma_model(file_name=command_line.args[0], crystal_symmetry=crystal_symmetry) emma_ref.show("Reference model") emma_others = get_emma_models_from_lst(command_line.args[1], crystal_symmetry) print "try CCall CCweak nmatch rms order.min order.max" for emma_other, itry, ccall, ccweak in emma_others: model_matches = emma.model_matches(model1=emma_ref, model2=emma_other, tolerance=tolerance, models_are_diffraction_index_equivalent=diffraction_index_equivalent) print itry, ccall, ccweak, if (model_matches.n_matches() == 0): print "0 nan nan nan" else: max_n_pairs = None first=True for match in model_matches.refined_matches: if (max_n_pairs is None or len(match.pairs) > max_n_pairs*0.2): orders = map(lambda x: int(x[1]), match.pairs) print "%3d %.5f %3d %3d" % (len(match.pairs), match.rms, min(orders), max(orders)) #match.show() #first=False break if (max_n_pairs is None): max_n_pairs = len(match.pairs)
def run2(args, log=sys.stdout, check_params=True, params=None): import mmtbx.command_line.fetch_pdb libtbx.call_back.set_warning_log(sys.stderr) parameter_interpreter = master_phil.command_line_argument_interpreter( home_scope="") pdb_file = None cif_file = None sources = [] for arg in args: if os.path.isfile(arg): if iotbx.pdb.is_pdb_file(arg): pdb_files = os.path.abspath(arg) elif arg.endswith(".cif") or arg.endswith(".cif.txt"): cif_file = os.path.abspath(arg) else: try: user_phil = iotbx.phil.parse(file_name=arg) except RuntimeError: print("Unrecognizable file format for %s" % arg) else: sources.append(user_phil) else: if arg.startswith("--"): arg = arg[2:] + "=True" try: user_phil = parameter_interpreter.process(arg=arg) sources.append(user_phil) except RuntimeError: print("Unrecognizable parameter %s" % arg) if (params is None): params = master_phil.fetch(sources=sources).extract() symm = None if (params.input.pdb_id is not None): params.input.pdb_file = mmtbx.command_line.fetch_pdb.run2( args=[params.input.pdb_id], log=log) params.input.cif_file = mmtbx.command_line.fetch_pdb.run2( args=["-x", params.input.pdb_id], log=log) symm = crystal_symmetry_from_any.extract_from(params.input.pdb_file) params.crystal_symmetry.space_group = symm.space_group_info() params.crystal_symmetry.unit_cell = symm.unit_cell() params.input.pdb_id = None if check_params: validate_params(params) if params.output_file_name is None: base, ext = os.path.splitext(params.input.cif_file) params.output_file_name = os.path.join(os.getcwd(), base + ".mtz") if symm is None: assert (type( params.crystal_symmetry.space_group).__name__ == "space_group_info" ) symm = crystal.symmetry( space_group_info=params.crystal_symmetry.space_group, unit_cell=params.crystal_symmetry.unit_cell) n_refl = process_files( file_name=params.input.cif_file, crystal_symmetry=symm, output_file_name=params.output_file_name, wavelength_id=params.input.wavelength_id, crystal_id=params.input.crystal_id, show_details_if_error=params.options.show_details_if_error, output_r_free_label="FreeR_flag", merge_non_unique_under_symmetry=params.options.merge, map_to_asu=params.options.map_to_asu, remove_systematic_absences=params.options.eliminate_sys_absent, incompatible_flags_to_work_set=\ params.options.incompatible_flags_to_work_set, ignore_bad_sigmas=params.options.ignore_bad_sigmas, extend_flags=params.options.extend_flags) return (params.output_file_name, n_refl)
def run(args, out=None, master_params=None, assume_shelx_observation_type_is="intensities"): if (out is None): out = sys.stdout import iotbx.phil if (master_params is None): master_params = iotbx.phil.parse(master_phil, process_includes=True) cmdline = cmdline_processor(args=args, master_phil=master_params, reflection_file_def="file_name", pdb_file_def="symmetry_file", space_group_def="space_group", unit_cell_def="unit_cell", usage_string="""\ phenix.merging_statistics [data_file] [options...] Calculate merging statistics for non-unique data, including R-merge, R-meas, R-pim, and redundancy. Any format supported by Phenix is allowed, including MTZ, unmerged Scalepack, or XDS/XSCALE (and possibly others). Data should already be on a common scale, but with individual observations unmerged. %s """ % citations_str) params = cmdline.work.extract() i_obs = iotbx.merging_statistics.select_data( file_name=params.file_name, data_labels=params.labels, log=out, assume_shelx_observation_type_is=assume_shelx_observation_type_is) params.labels = i_obs.info().label_string() validate_params(params) symm = sg = uc = None if (params.symmetry_file is not None): from iotbx import crystal_symmetry_from_any symm = crystal_symmetry_from_any.extract_from( file_name=params.symmetry_file) if (symm is None): raise Sorry("No symmetry records found in %s." % params.symmetry_file) else: sg = i_obs.space_group() if (params.space_group is not None): sg = params.space_group.group() elif (sg is None): raise Sorry("Missing space group information.") uc = i_obs.unit_cell() if (params.unit_cell is not None): uc = params.unit_cell elif (uc is None): raise Sorry("Missing unit cell information.") from cctbx import crystal symm = crystal.symmetry(space_group=sg, unit_cell=uc) if (i_obs.sigmas() is None): raise Sorry("Sigma(I) values required for this application.") result = iotbx.merging_statistics.dataset_statistics( i_obs=i_obs, crystal_symmetry=symm, d_min=params.high_resolution, d_max=params.low_resolution, n_bins=params.n_bins, binning_method=params.binning_method, anomalous=params.anomalous, debug=params.debug, file_name=params.file_name, sigma_filtering=params.sigma_filtering, use_internal_variance=params.use_internal_variance, eliminate_sys_absent=params.eliminate_sys_absent, extend_d_max_min=params.extend_d_max_min, cc_one_half_significance_level=params.cc_one_half_significance_level, cc_one_half_method=params.cc_one_half_method, log=out) result.show(out=out) if (getattr(params, "loggraph", False)): result.show_loggraph(out=out) if (params.estimate_cutoffs): result.show_estimated_cutoffs(out=out) print >> out, "" print >> out, "References:" print >> out, citations_str print >> out, "" return result
def run(args): if len(args)==0: master_params.show(expert_level=0) elif ( "--help" in args ): print "no help available" elif ( "--h" in args ): print "no help available" 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() ## 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.after_burn.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 after_burn 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 after_burn 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.after_burn.file_name, labels = params.scaling.input.xray_data.after_burn.labels, ignore_all_zeros = True, parameter_scope = 'scaling.input.SIR_scale.xray_data.after_burn' ) 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) ## Read in derivative data and make appropriate selections miller_array_derivative = None miller_array_derivative = xray_data_server.get_xray_data( file_name = params.scaling.input.xray_data.before_burn.file_name, labels = params.scaling.input.xray_data.before_burn.labels, ignore_all_zeros = True, parameter_scope = 'scaling.input.SIR_scale.xray_data.before_burn' ) info_derivative = miller_array_derivative.info() miller_array_derivative=miller_array_derivative.map_to_asu().select( miller_array_derivative.indices()!=(0,0,0) ) miller_array_derivative = miller_array_derivative.select( miller_array_derivative.data() > 0 ) ## Convert to amplitudes if (miller_array_derivative.is_xray_intensity_array()): miller_array_derivative = miller_array_derivative.f_sq_as_f() elif (miller_array_derivative.is_complex_array()): miller_array_derivative = abs(miller_array_derivative) if not miller_array_derivative.is_real_array(): raise Sorry("miller_array_derivative is not a real array") miller_array_derivative.set_info(info = info_derivative) ## As this is a SIR case, we will remove any anomalous pairs if miller_array_derivative.anomalous_flag(): miller_array_derivative = miller_array_derivative.average_bijvoet_mates()\ .set_observation_type( miller_array_derivative ) if miller_array_native.anomalous_flag(): miller_array_native = miller_array_native.average_bijvoet_mates()\ .set_observation_type( miller_array_native ) ## Print info print >> log print >> log, "Native 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 print >> log print >> log, "Derivative data" print >> log, "===============" miller_array_derivative.show_comprehensive_summary(f=log) print >> log derivative_pre_scale = pre_scale.pre_scaler( miller_array_derivative, params.scaling.input.scaling_strategy.pre_scaler_protocol, params.scaling.input.basic) miller_array_derivative = derivative_pre_scale.x1.deep_copy() del derivative_pre_scale scaler = fa_estimation.combined_scaling( miller_array_native, miller_array_derivative, params.scaling.input.scaling_strategy.iso_protocol) miller_array_native = scaler.x1.deep_copy() miller_array_derivative = scaler.x2.deep_copy() del scaler print >> log print >> log, "Making delta f's" print >> log, "----------------" print >> log delta_gen = pair_analyses.delta_generator( miller_array_native, miller_array_derivative, params.scaling.input.scaling_strategy.iso_protocol.nsr_bias ) print >> log print >> log, "writing mtz file" print >> log, "----------------" print >> log ## some assertions to make sure nothing went weerd assert miller_array_native.observation_type() is not None assert miller_array_derivative.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)
def cmd_run(args, validated=False, out=sys.stdout): if (len(args) == 0): print >> out, "-"*79 print >> out, " phenix.polder" print >> out, "-"*79 print >> out, legend print >> out, "-"*79 master_params.show(out=out) return log = multi_out() log.register("stdout", out) log_file_name = "polder.log" logfile = open(log_file_name, "w") log.register("logfile", logfile) print >> log, "phenix.polder is running..." print >> log, "input parameters:\n", args parsed = master_params inputs = mmtbx.utils.process_command_line_args(args = args, master_params = parsed) #inputs.params.show() #check params = inputs.params.extract() # check model file if len(inputs.pdb_file_names) == 0: if (params.model_file_name is None): raise Sorry("No model file found.") elif (len(inputs.pdb_file_names) == 1): params.model_file_name = inputs.pdb_file_names[0] else: raise Sorry("Only one model file should be given") # check reflection file reflection_files = inputs.reflection_files if (len(reflection_files) == 0): if (params.reflection_file_name is None): raise Sorry("No reflection file found.") else: hkl_in = file_reader.any_file(params.reflection_file_name, force_type="hkl") hkl_in.assert_file_type("hkl") reflection_files = [ hkl_in.file_object ] # crystal symmetry crystal_symmetry = None crystal_symmetry = inputs.crystal_symmetry if (crystal_symmetry is None): crystal_symmetries = [] for f in [str(params.model_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, r_free_flags = None, None rfs = reflection_file_utils.reflection_file_server( crystal_symmetry = crystal_symmetry, force_symmetry = True, reflection_files = reflection_files, err = StringIO()) parameters = mmtbx.utils.data_and_flags_master_params().extract() if (params.data_labels is not None): parameters.labels = params.data_labels if (params.r_free_flags_labels is not None): parameters.r_free_flags.label = params.r_free_flags_labels determined_data_and_flags = mmtbx.utils.determine_data_and_flags( reflection_file_server = rfs, parameters = parameters, keep_going = True, log = StringIO()) f_obs = determined_data_and_flags.f_obs if (params.data_labels is None): params.data_labels = f_obs.info().label_string() if (params.reflection_file_name is None): params.reflection_file_name = parameters.file_name r_free_flags = determined_data_and_flags.r_free_flags assert f_obs is not None print >> log, "Input data:" print >> log, " Iobs or Fobs:", f_obs.info().labels if (r_free_flags is not None): print >> log, " Free-R flags:", r_free_flags.info().labels params.r_free_flags_labels = r_free_flags.info().label_string() else: print >> log, " Free-R flags: Not present" model_basename = os.path.basename(params.model_file_name.split(".")[0]) if (len(model_basename) > 0 and params.output_file_name_prefix is None): params.output_file_name_prefix = model_basename print params.output_file_name_prefix new_params = master_params.format(python_object=params) new_params.show() if (not validated): validate_params(params) pdb_input = iotbx.pdb.input(file_name = params.model_file_name) pdb_hierarchy = pdb_input.construct_hierarchy() xray_structure = pdb_hierarchy.extract_xray_structure( crystal_symmetry = crystal_symmetry) # DON'T USE: # xray_structure = pdb_input.xray_structure_simple() # atom order might be wrong mmtbx.utils.setup_scattering_dictionaries( scattering_table = params.scattering_table, xray_structure = xray_structure, d_min = f_obs.d_min()) #if f_obs is not None: f_obs = f_obs.resolution_filter( d_min = params.high_resolution, d_max = params.low_resolution) if (r_free_flags is not None): r_free_flags = r_free_flags.resolution_filter( d_min = params.high_resolution, d_max = params.low_resolution) # Grab case that data are anomalous if (f_obs.anomalous_flag()): f_obs, r_free_flags = prepare_f_obs_and_flags( f_obs = f_obs, r_free_flags = r_free_flags) cpm_obj = compute_polder_map( f_obs = f_obs, r_free_flags = r_free_flags, xray_structure = xray_structure, pdb_hierarchy = pdb_hierarchy, params = params, log = log) # Significance check fmodel = mmtbx.f_model.manager( f_obs = f_obs, r_free_flags = r_free_flags, xray_structure = xray_structure) fmodel.update_all_scales(remove_outliers=False, fast=True) f_obs_1 = abs(fmodel.f_model()) fmodel.update_xray_structure(xray_structure=cpm_obj.xray_structure_noligand, update_f_calc=True, update_f_mask=True, force_update_f_mask=True) # PVA: do we need it? fmodel.update_all_scales(remove_outliers=False) f_obs_2 = abs(fmodel.f_model()) xrs_selected = cpm_obj.pdb_hierarchy_selected.extract_xray_structure( crystal_symmetry = f_obs.crystal_symmetry()) f_calc = f_obs.structure_factors_from_scatterers( xray_structure = cpm_obj.xray_structure_noligand).f_calc() f_mask = f_obs.structure_factors_from_map( map = cpm_obj.mask_polder, use_scale = True, anomalous_flag = False, use_sg = False) def get_poler_diff_map(f_obs): fmodel = mmtbx.f_model.manager( f_obs = f_obs, r_free_flags = r_free_flags, f_calc = f_calc, f_mask = f_mask) fmodel.update_all_scales(remove_outliers=False) mc_diff = map_tools.electron_density_map( fmodel = fmodel).map_coefficients( map_type = "mFo-DFc", isotropize = True, fill_missing = False) fft_map = miller.fft_map( crystal_gridding = cpm_obj.crystal_gridding, fourier_coefficients = mc_diff) fft_map.apply_sigma_scaling() map_data = fft_map.real_map_unpadded() return mmtbx.utils.extract_box_around_model_and_map( xray_structure = xrs_selected, map_data = map_data, box_cushion = 2.1) box_1=get_poler_diff_map(f_obs = f_obs_1) box_2=get_poler_diff_map(f_obs = f_obs_2) box_3=get_poler_diff_map(f_obs = f_obs) 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 >> log, "Map 1: calculated Fobs with ligand" print >> log, "Map 2: calculated Fobs without ligand" print >> log, "Map 3: real Fobs data" print >>log, "CC(1,2): %6.4f"%flex.linear_correlation(x=b1,y=b2).coefficient() print >>log, "CC(1,3): %6.4f"%flex.linear_correlation(x=b1,y=b3).coefficient() print >>log, "CC(2,3): %6.4f"%flex.linear_correlation(x=b2,y=b3).coefficient() ### 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 >> log, "Peak CC:" print >>log, "CC(1,2): %6.4f"%flex.linear_correlation(x=b1,y=b2).coefficient() print >>log, "CC(1,3): %6.4f"%flex.linear_correlation(x=b1,y=b3).coefficient() print >>log, "CC(2,3): %6.4f"%flex.linear_correlation(x=b2,y=b3).coefficient() cutoffs = flex.double( [i/10. for i in range(1,10)]+[i/100 for i in range(91,100)]) d12 = maptbx.discrepancy_function(map_1=b1, map_2=b2, cutoffs=cutoffs) d13 = maptbx.discrepancy_function(map_1=b1, map_2=b3, cutoffs=cutoffs) d23 = maptbx.discrepancy_function(map_1=b2, map_2=b3, cutoffs=cutoffs) print >> log, "q D(1,2) D(1,3) D(2,3)" for c,d12_,d13_,d23_ in zip(cutoffs,d12,d13,d23): print >> log, "%4.2f %6.4f %6.4f %6.4f"%(c,d12_,d13_,d23_) ### if(params.debug): box_1.write_ccp4_map(file_name="box_1_polder.ccp4") box_2.write_ccp4_map(file_name="box_2_polder.ccp4") box_3.write_ccp4_map(file_name="box_3_polder.ccp4") cpm_obj.pdb_hierarchy_selected.adopt_xray_structure( box_1.xray_structure_box) cpm_obj.pdb_hierarchy_selected.write_pdb_file(file_name="box_polder.pdb", crystal_symmetry=box_1.box_crystal_symmetry) # print >> log, "Finished." return True
def sfcalc(args): if len(args) == 0: print_help() elif ("--help" in args): print_help() elif ("--h" in args): print_help() elif ("-h" in args): print_help() 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) phil_objects = [] argument_interpreter = master_params.command_line_argument_interpreter( home_scope="sfcalc") print("#phil __OFF__", file=log) print("=================", file=log) print(" SFCALC ", file=log) print("=================", file=log) print(file=log) for arg in args: command_line_params = None arg_is_processed = False # is it a file? if (os.path.isfile(arg)): ## is this a file name? # check if it is a phil file try: command_line_params = iotbx.phil.parse(file_name=arg) if command_line_params is not None: phil_objects.append(command_line_params) arg_is_processed = True except KeyboardInterrupt: raise except Exception: pass 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("##----------------------------------------------##", file=log) print("## Unknown file or keyword:", arg, file=log) print("##----------------------------------------------##", file=log) print(file=log) raise Sorry("Unknown file or keyword: %s" % arg) effective_params = master_params.fetch(sources=phil_objects) params = effective_params.extract() # now get the unit cell from the files hkl_xs = None pdb_xs = None if params.sfcalc.input.model.file_name is not None: pdb_xs = crystal_symmetry_from_any.extract_from( file_name=params.sfcalc.input.model.file_name) phil_xs = crystal.symmetry( unit_cell=params.sfcalc.input.unit_cell, space_group_info=params.sfcalc.input.space_group) combined_xs = crystal.select_crystal_symmetry(None, phil_xs, [pdb_xs], [None]) combined_xs.show_summary() if combined_xs.unit_cell() is None: raise Sorry("Unit cell not defined") if combined_xs.space_group() is None: raise Sorry("Space group not defined") # inject the unit cell and symmetry in the phil scope please params.sfcalc.input.unit_cell = combined_xs.unit_cell() params.sfcalc.input.space_group = \ sgtbx.space_group_info( group = combined_xs.space_group() ) print("#phil __ON__", file=log) new_params = master_params.format(python_object=params) new_params.show(out=log) print("#phil __END__", file=log) pdb_model = None if params.sfcalc.input.model.file_name is not None: pdb_model = pdb.input( file_name=params.sfcalc.input.model.file_name) model = pdb_model.xray_structure_simple(crystal_symmetry=phil_xs) print("Atomic model summary", file=log) print("====================", file=log) model.show_summary() print(file=log) #make an f_model object please b_cart = params.sfcalc.parameters.overall.b_cart b_cart = [ b_cart.b_11, b_cart.b_22, b_cart.b_33, b_cart.b_12, b_cart.b_13, b_cart.b_23 ] dummy = abs( model.structure_factors(d_min=params.sfcalc.parameters.d_min, anomalous_flag=False).f_calc()) flags = dummy.generate_r_free_flags(fraction=0.1, max_free=99999999) fmodel = f_model.manager( xray_structure=model, r_free_flags=flags, target_name="ls_wunit_k1", f_obs=dummy, b_cart=b_cart, k_sol=params.sfcalc.parameters.solvent.k_sol, b_sol=params.sfcalc.parameters.solvent.b_sol) calc_data_with_solvent_contrib = fmodel.f_model() calc_data_with_solvent_contrib = calc_data_with_solvent_contrib.array( data=calc_data_with_solvent_contrib.data() * params.sfcalc.parameters.overall.k_overall) result = None label = None if params.sfcalc.parameters.output_type == "complex": result = calc_data_with_solvent_contrib label = "FMODEL" if params.sfcalc.parameters.output_type == "amplitudes": result = abs(calc_data_with_solvent_contrib) label = "FMODEL" if params.sfcalc.parameters.output_type == "intensities": result = abs(calc_data_with_solvent_contrib) result = result.f_as_f_sq() label = "IMODEL" #write an mtz file with the data mtz_dataset = result.as_mtz_dataset(column_root_label=label) mtz_dataset.mtz_object().write( file_name=params.sfcalc.output.hklout) #write the logfile logger = open(params.sfcalc.output.logfile, 'w') print("writing log file with name %s" % (params.sfcalc.output.logfile), file=log) print(file=log) print(string_buffer.getvalue(), file=logger)
def run(args, out=sys.stdout): cmdline = iotbx.phil.process_command_line_with_files( args=args, master_phil_string=master_phil_str, pdb_file_def="model", reflection_file_def="data", seq_file_def="sequence", space_group_def="space_group", unit_cell_def="unit_cell", integer_def="n_residues", usage_string="""\ phenix.matthews [data.hkl] [space_group] [unit_cel] [sequence] [n_residues] ... Calculate the expected Matthews coefficient given the crystal symmetry and crystallized molecule(s). """) params = cmdline.work.extract() if (params.space_group is None) or (params.unit_cell is None): if (params.data is None): raise Sorry( "You must supply both a space group and a unit cell (or " + "a data file containing this information).") else: symm = crystal_symmetry_from_any.extract_from( file_name=params.data) space_group_from_file = symm.space_group() if (params.space_group is None): if (space_group_from_file is not None): params.space_group = symm.space_group() elif (space_group_from_file is not None): if (space_group_from_file != params.space_group): print >> out, "WARNING: space group mismatch between command line "+\ "and file:" print >> out, " %s (cmdline), %s (file)" % ( params.space_group, space_group_from_file) if (params.unit_cell is None): params.unit_cell = symm.unit_cell() validate_params(params, check_symmetry=True) if (params.sequence is not None): assert (params.n_residues == params.n_bases == None) seq_comp = iotbx.bioinformatics.composition_from_sequence_file( file_name=params.sequence, log=out) if (seq_comp is not None): params.n_residues = seq_comp.n_residues params.n_bases = seq_comp.n_bases else: raise Sorry( "No composition information could be obtained from the " + "sequence file.") elif (params.model is not None): assert (params.n_residues == params.n_bases == None) from iotbx.file_reader import any_file params.n_residues = 0 params.n_bases = 0 pdb_in = any_file(params.model) hierarchy = pdb_in.file_object.hierarchy for chain in hierarchy.models()[0].chains(): if chain.is_protein(): params.n_residues += chain.residue_groups_size() elif chain.is_na(): params.n_bases += chain.residue_groups_size() print >> out, "Space group: %s" % params.space_group print >> out, "Unit cell: %s" % params.unit_cell if (params.n_residues > 0): print >> out, "Number of residues: %d" % params.n_residues if (params.n_bases > 0): print >> out, "Number of bases: %d" % params.n_bases symm = crystal.symmetry(space_group_info=params.space_group, unit_cell=params.unit_cell) from mmtbx.scaling import matthews result = matthews.matthews_rupp(crystal_symmetry=symm, n_residues=params.n_residues, n_bases=params.n_bases) result.show(out=out) return result
def run(args, out=sys.stdout): import iotbx.phil cmdline = iotbx.phil.process_command_line_with_files( args=args, master_phil_string=master_phil_str, pdb_file_def="crystal_symmetry.symm_file", reflection_file_def="input.data", space_group_def="crystal_symmetry.space_group", unit_cell_def="crystal_symmetry.unit_cell", usage_string="""\ mmtbx.massage_data data.mtz [labels=I,SIGI] [options] Modification of experimental data: remove anisotropy, apply B-factor, filter negative intensities, add or remove twinning. For expert use (and extreme cases) only. """) params = cmdline.work.extract() if (params.input.data is None): raise Sorry("No data file supplied.") from mmtbx.scaling import massage_twin_detwin_data from iotbx import crystal_symmetry_from_any from iotbx import reflection_file_utils from cctbx import crystal crystal_symmetry = space_group = unit_cell = None if (params.crystal_symmetry.space_group is not None): space_group = params.crystal_symmetry.space_group if (params.crystal_symmetry.unit_cell is not None): unit_cell = params.crystal_symmetry.unit_cell crystal_symmetry = None if (params.crystal_symmetry.symm_file is not None): crystal_symmetry = crystal_symmetry_from_any.extract_from( file_name=params.crystal_symmetry.symm_file) if (crystal_symmetry is None): raise Sorry("No crystal symmetry defined in %s" % params.crystal_symmetry.symm_file) if (crystal_symmetry is None) and (not None in [space_group, unit_cell]): crystal_symmetry = crystal.symmetry(space_group_info=space_group, unit_cell=unit_cell) hkl_in = cmdline.get_file(params.input.data) hkl_server = reflection_file_utils.reflection_file_server( crystal_symmetry=crystal_symmetry, force_symmetry=True, reflection_files=[hkl_in.file_object], err=sys.stderr) data = hkl_server.get_xray_data(file_name=params.input.data, labels=params.input.labels, ignore_all_zeros=True, parameter_scope="input", prefer_anomalous=True, prefer_amplitudes=False) result = massage_twin_detwin_data.massage_data(miller_array=data, parameters=params.options, out=out) if (params.output.hklout is None): file_base = op.splitext(op.basename(params.input.data))[0] if (params.output.hklout_type in ["Auto", "mtz"]): params.output.hklout = file_base + ".mtz" else: params.output.hklout = file_base + ".sca" result.write_data(file_name=params.output.hklout, output_type=params.output.hklout_type, label_extension=params.output.label_extension)
def run(args, command_name="phenix.emma"): command_line = (option_parser( usage=command_name + " [options]" +" reference_coordinates other_coordinates", description="Example: %s model1.pdb model2.sdb" % command_name) .enable_symmetry_comprehensive() .option(None, "--output_pdb", action="store", type="str", default="", help="Output pdb: second model transformed to best match first model", metavar="STR") .option(None, "--tolerance", action="store", type="float", default=3., help="match tolerance", metavar="FLOAT") .option(None, "--diffraction_index_equivalent", action="store_true", help="Use only if models are diffraction-index equivalent.") ).process(args=args, nargs=2) crystal_symmetry = command_line.symmetry if ( crystal_symmetry.unit_cell() is None or crystal_symmetry.space_group_info() is None): for file_name in command_line.args: crystal_symmetry = crystal_symmetry.join_symmetry( other_symmetry=crystal_symmetry_from_any.extract_from( file_name=file_name), force=False) output_pdb = command_line.options.output_pdb if output_pdb: print "Output pdb:",output_pdb tolerance = command_line.options.tolerance print "Tolerance:", tolerance if (tolerance <= 0.): raise ValueError, "Tolerance must be greater than zero." print diffraction_index_equivalent = \ command_line.options.diffraction_index_equivalent if (diffraction_index_equivalent): print "Models are diffraction index equivalent." print emma_models = [] for file_name in command_line.args: emma_models.append(get_emma_model( file_name=file_name, crystal_symmetry=crystal_symmetry)) emma_models[0].show("Reference model") emma_models[1].show("Other model") for model,label in zip(emma_models, ["reference", "other"]): if (model.unit_cell() is None): raise RuntimeError("Unit cell parameters unknown (%s model)." % label) if (model.space_group_info() is None): raise RuntimeError("Space group unknown (%s model)." % label) model_matches = emma.model_matches( model1=emma_models[0], model2=emma_models[1], tolerance=tolerance, models_are_diffraction_index_equivalent=diffraction_index_equivalent) if (model_matches.n_matches() == 0): print "No matches." print else: max_n_pairs = None first=True for match in model_matches.refined_matches: if (max_n_pairs is None or len(match.pairs) > max_n_pairs*0.2): print "." * 79 print match.show() if first and output_pdb: # 2013-01-25 tt match.get_transformed_model2(output_pdb=output_pdb, scattering_type="SE",f=sys.stdout) first=False if (max_n_pairs is None): max_n_pairs = len(match.pairs)
def __init__(self, args, master_phil, out=sys.stdout, process_pdb_file=True, require_data=True, create_fmodel=True, prefer_anomalous=None, force_non_anomalous=False, set_wavelength_from_model_header=False, set_inelastic_form_factors=None, usage_string=None, create_log_buffer=False, remove_unknown_scatterers=False, generate_input_phil=False): import mmtbx.monomer_library.pdb_interpretation import mmtbx.monomer_library.server import mmtbx.utils import mmtbx.model from iotbx import crystal_symmetry_from_any import iotbx.phil if generate_input_phil: from six import string_types assert isinstance(master_phil, string_types) master_phil = generate_master_phil_with_inputs( phil_string=master_phil) if isinstance(master_phil, str): master_phil = iotbx.phil.parse(master_phil) if (usage_string is not None): if (len(args) == 0) or ("--help" in args): raise Usage("""%s\n\nFull parameters:\n%s""" % (usage_string, master_phil.as_str(prefix=" "))) if (force_non_anomalous): assert (not prefer_anomalous) assert (set_inelastic_form_factors in [None, "sasaki", "henke"]) self.args = args self.master_phil = master_phil self.processed_pdb_file = self.pdb_inp = None self.pdb_hierarchy = self.xray_structure = None self.geometry = None self.sequence = None self.fmodel = None self.f_obs = None self.r_free_flags = None self.intensity_flag = None self.raw_data = None self.raw_flags = None self.test_flag_value = None self.miller_arrays = None self.hl_coeffs = None self.cif_objects = [] self.log = out if ("--quiet" in args) or ("quiet=True" in args): self.log = null_out() elif create_log_buffer: self.log = multi_out() self.log.register(label="stdout", file_object=out) self.log.register(label="log_buffer", file_object=StringIO()) make_header("Collecting inputs", out=self.log) cmdline = iotbx.phil.process_command_line_with_files( args=args, master_phil=master_phil, pdb_file_def="input.pdb.file_name", reflection_file_def="input.xray_data.file_name", cif_file_def="input.monomers.file_name", seq_file_def="input.sequence") self.working_phil = cmdline.work params = self.working_phil.extract() if len(params.input.pdb.file_name) == 0: raise Sorry("At least one PDB file is required as input.") self.cif_file_names = params.input.monomers.file_name self.pdb_file_names = params.input.pdb.file_name # SYMMETRY HANDLING - PDB FILES self.crystal_symmetry = pdb_symm = None for pdb_file_name in params.input.pdb.file_name: pdb_symm = crystal_symmetry_from_any.extract_from(pdb_file_name) if (pdb_symm is not None): break # DATA INPUT data_and_flags = hkl_symm = hkl_in = None if (params.input.xray_data.file_name is None): if (require_data): raise Sorry( "At least one reflections file is required as input.") else: # FIXME this may still require that the data file has full crystal # symmetry defined (although for MTZ input this will not be a problem) make_sub_header("Processing X-ray data", out=self.log) hkl_in = file_reader.any_file(params.input.xray_data.file_name) hkl_in.check_file_type("hkl") hkl_server = hkl_in.file_server symm = hkl_server.miller_arrays[0].crystal_symmetry() if ((symm is None) or (symm.space_group() is None) or (symm.unit_cell() is None)): if (pdb_symm is not None): from iotbx.reflection_file_utils import reflection_file_server print( "No symmetry in X-ray data file - using PDB symmetry:", file=self.log) pdb_symm.show_summary(f=out, prefix=" ") hkl_server = reflection_file_server( crystal_symmetry=pdb_symm, reflection_files=[hkl_in.file_object]) else: raise Sorry( "No crystal symmetry information found in input files." ) if (hkl_server is None): hkl_server = hkl_in.file_server data_and_flags = mmtbx.utils.determine_data_and_flags( reflection_file_server=hkl_server, parameters=params.input.xray_data, data_parameter_scope="input.xray_data", flags_parameter_scope="input.xray_data.r_free_flags", prefer_anomalous=prefer_anomalous, force_non_anomalous=force_non_anomalous, log=self.log) self.intensity_flag = data_and_flags.intensity_flag self.raw_data = data_and_flags.raw_data self.raw_flags = data_and_flags.raw_flags self.test_flag_value = data_and_flags.test_flag_value self.f_obs = data_and_flags.f_obs self.r_free_flags = data_and_flags.r_free_flags self.miller_arrays = hkl_in.file_server.miller_arrays hkl_symm = self.raw_data.crystal_symmetry() if len(self.cif_file_names) > 0: for file_name in self.cif_file_names: cif_obj = mmtbx.monomer_library.server.read_cif( file_name=file_name) self.cif_objects.append((file_name, cif_obj)) # SYMMETRY HANDLING - COMBINED if (hkl_symm is not None): use_symmetry = hkl_symm # check for weird crystal symmetry # modified from mmtbx.command_line.secondary_structure_restraints # plan to centralize functionality in another location # ------------------------------------------------------------------------- cs = pdb_symm corrupted_cs = False if cs is not None: if [cs.unit_cell(), cs.space_group()].count(None) > 0: corrupted_cs = True cs = None elif cs.unit_cell().volume() < 10: corrupted_cs = True cs = None if cs is None: if corrupted_cs: print("Symmetry information is corrupted,", end=' ', file=out) else: print("Symmetry information was not found,", end=' ', file=out) if (hkl_symm is not None): print("using symmetry from data.", file=out) cs = hkl_symm else: print("putting molecule in P1 box.", file=out) pdb_combined = iotbx.pdb.combine_unique_pdb_files( file_names=self.pdb_file_names) pdb_structure = iotbx.pdb.input(source_info=None, lines=flex.std_string( pdb_combined.raw_records)) atoms = pdb_structure.atoms() box = uctbx.non_crystallographic_unit_cell_with_the_sites_in_its_center( sites_cart=atoms.extract_xyz(), buffer_layer=3) atoms.set_xyz(new_xyz=box.sites_cart) cs = box.crystal_symmetry() pdb_symm = cs # ------------------------------------------------------------------------- from iotbx.symmetry import combine_model_and_data_symmetry self.crystal_symmetry = combine_model_and_data_symmetry( model_symmetry=pdb_symm, data_symmetry=hkl_symm) if (self.crystal_symmetry is not None) and (self.f_obs is not None): self.f_obs = self.f_obs.customized_copy( crystal_symmetry=self.crystal_symmetry).eliminate_sys_absent( ).set_info(self.f_obs.info()) self.r_free_flags = self.r_free_flags.customized_copy( crystal_symmetry=self.crystal_symmetry).eliminate_sys_absent( ).set_info(self.r_free_flags.info()) # EXPERIMENTAL PHASES target_name = "ml" if hasattr(params.input, "experimental_phases"): flag = params.input.use_experimental_phases if (flag in [True, Auto]): phases_file = params.input.experimental_phases.file_name if (phases_file is None): phases_file = params.input.xray_data.file_name phases_in = hkl_in else: phases_in = file_reader.any_file(phases_file) phases_in.check_file_type("hkl") phases_in.file_server.err = self.log # redirect error output space_group = self.crystal_symmetry.space_group() point_group = space_group.build_derived_point_group() hl_coeffs = mmtbx.utils.determine_experimental_phases( reflection_file_server=phases_in.file_server, parameters=params.input.experimental_phases, log=self.log, parameter_scope="input.experimental_phases", working_point_group=point_group, symmetry_safety_check=True) if (hl_coeffs is not None): hl_coeffs = hl_coeffs.map_to_asu() if hl_coeffs.anomalous_flag(): if (not self.f_obs.anomalous_flag()): hl_coeffs = hl_coeffs.average_bijvoet_mates() elif self.f_obs.anomalous_flag(): hl_coeffs = hl_coeffs.generate_bijvoet_mates() self.hl_coeffs = hl_coeffs.matching_set( other=self.f_obs, data_substitute=(0, 0, 0, 0)) target_name = "mlhl" # PDB INPUT self.unknown_residues_flag = False self.unknown_residues_error_message = False pdb_combined = mmtbx.utils.combine_unique_pdb_files( file_names=params.input.pdb.file_name, ) pdb_combined.report_non_unique(out=self.log) pdb_raw_records = pdb_combined.raw_records try: self.pdb_inp = iotbx.pdb.input( source_info=None, lines=flex.std_string(pdb_raw_records)) except ValueError as e: raise Sorry("Model format (PDB or mmCIF) error:\n%s" % str(e)) if (remove_unknown_scatterers): h = self.pdb_inp.construct_hierarchy() known_sel = h.atom_selection_cache().selection("not element X") if known_sel.count(False) > 0: self.pdb_inp = iotbx.pdb.input( source_info=None, lines=h.select(known_sel).as_pdb_string()) model_params = mmtbx.model.manager.get_default_pdb_interpretation_params( ) pdb_interp_params = getattr(params, "pdb_interpretation", None) if pdb_interp_params is None: pdb_interp_params = iotbx.phil.parse( input_string=mmtbx.monomer_library.pdb_interpretation. grand_master_phil_str, process_includes=True).extract() pdb_interp_params = pdb_interp_params.pdb_interpretation model_params.pdb_interpretation = pdb_interp_params stop_for_unknowns = getattr(pdb_interp_params, "stop_for_unknowns", False) or remove_unknown_scatterers if not process_pdb_file: stop_for_unknowns = True and not remove_unknown_scatterers self.model = mmtbx.model.manager( model_input=self.pdb_inp, crystal_symmetry=self.crystal_symmetry, restraint_objects=self.cif_objects, pdb_interpretation_params=model_params, process_input=False, stop_for_unknowns=stop_for_unknowns, log=self.log) if process_pdb_file: make_sub_header("Processing PDB file(s)", out=self.log) self.model.process_input_model(make_restraints=True) full_grm = self.model.get_restraints_manager() self.geometry = full_grm.geometry self.processed_pdb_file = self.model._processed_pdb_file # to remove later XXX self.xray_structure = self.model.get_xray_structure() self.pdb_hierarchy = self.model.get_hierarchy() self.pdb_hierarchy.atoms().reset_i_seq() # wavelength if (params.input.energy is not None): if (params.input.wavelength is not None): raise Sorry("Both wavelength and energy have been specified!") params.input.wavelength = 12398.424468024265 / params.input.energy if (set_wavelength_from_model_header and params.input.wavelength is None): wavelength = self.pdb_inp.extract_wavelength() if (wavelength is not None): print("", file=self.log) print("Using wavelength = %g from PDB header" % wavelength, file=self.log) params.input.wavelength = wavelength # set scattering table if (data_and_flags is not None): self.model.setup_scattering_dictionaries( scattering_table=params.input.scattering_table, d_min=self.f_obs.d_min(), log=self.log, set_inelastic_form_factors=set_inelastic_form_factors, iff_wavelength=params.input.wavelength) self.xray_structure.show_summary(f=self.log) # FMODEL SETUP if (create_fmodel) and (data_and_flags is not None): make_sub_header("F(model) initialization", out=self.log) skip_twin_detection = getattr(params.input, "skip_twin_detection", True) twin_law = getattr(params.input, "twin_law", None) if (twin_law is Auto): if (self.hl_coeffs is not None): raise Sorry( "Automatic twin law determination not supported when " + "experimental phases are used.") elif (not skip_twin_detection): twin_law = Auto if (twin_law is Auto): print("Twinning will be detected automatically.", file=self.log) self.fmodel = mmtbx.utils.fmodel_simple( xray_structures=[self.xray_structure], scattering_table=params.input.scattering_table, f_obs=self.f_obs, r_free_flags=self.r_free_flags, skip_twin_detection=skip_twin_detection, target_name=target_name, log=self.log) else: if ((twin_law is not None) and (self.hl_coeffs is not None)): raise Sorry( "Automatic twin law determination not supported when " + "experimental phases are used.") self.fmodel = mmtbx.utils.fmodel_manager( f_obs=self.f_obs, xray_structure=self.xray_structure, r_free_flags=self.r_free_flags, twin_law=params.input.twin_law, hl_coeff=self.hl_coeffs, target_name=target_name) self.fmodel.update_all_scales(params=None, log=self.log, optimize_mask=True, show=True) self.fmodel.info().show_rfactors_targets_scales_overall( out=self.log) # SEQUENCE if (params.input.sequence is not None): seq_file = file_reader.any_file(params.input.sequence, force_type="seq", raise_sorry_if_errors=True) self.sequence = seq_file.file_object # UNMERGED DATA self.unmerged_i_obs = None if hasattr(params.input, "unmerged_data"): if (params.input.unmerged_data.file_name is not None): self.unmerged_i_obs = load_and_validate_unmerged_data( f_obs=self.f_obs, file_name=params.input.unmerged_data.file_name, data_labels=params.input.unmerged_data.labels, log=self.log) self.params = params print("", file=self.log) print("End of input processing", file=self.log)
def reindex_utils(args): if len(args)==0: print_help() elif ( "--help" in args ): print_help() elif ( "--h" in args ): print_help() elif ("-h" in args ): print_help() 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) phil_objects = [] argument_interpreter = master_params.command_line_argument_interpreter( home_scope="map_coefs") print >> log, "#phil __OFF__" print >> log, "=================" print >> log, " REINDEX " print >> log, "A reindexing tool" print >> log, "=================" print >> log for arg in args: command_line_params = None arg_is_processed = False # is it a file? if (os.path.isfile(arg)): ## is this a file name? # check if it is a phil file try: command_line_params = iotbx.phil.parse(file_name=arg) if command_line_params is not None: phil_objects.append(command_line_params) arg_is_processed = True except KeyboardInterrupt: raise except Exception : pass 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 file or keyword:", arg print >> log, "##----------------------------------------------##" print >> log raise Sorry("Unknown file or keyword: %s" % arg) effective_params = master_params.fetch(sources=phil_objects) params_root = effective_params.extract() params = params_root.reindex_utils # now get the unit cell from the files hkl_xs = None pdb_xs = None if params.input.xray_data.file_name is not None: hkl_xs = crystal_symmetry_from_any.extract_from( file_name=params.input.xray_data.file_name) if params.input.model.file_name is not None: pdb_xs = crystal_symmetry_from_any.extract_from( file_name=params.input.model.file_name) phil_xs = crystal.symmetry( unit_cell=params.input.unit_cell, space_group_info=params.input.space_group ) combined_xs = crystal.select_crystal_symmetry( None,phil_xs, [pdb_xs],[hkl_xs]) # inject the unit cell and symmetry in the phil scope please params.input.unit_cell = combined_xs.unit_cell() params.input.space_group = combined_xs.space_group_info() print >> log, "#phil __ON__" new_params = master_params.format(python_object=params_root) new_params.show(out=log) print >> log, "#phil __END__" if params.input.unit_cell is None: raise Sorry("unit cell not specified") if params.input.space_group is None: raise Sorry("space group not specified") #----------------------------------------------------------- # # step 1: read in the reflection file # miller_array = None if params.input.xray_data.file_name is not None: phil_xs = crystal.symmetry( unit_cell=params.input.unit_cell, space_group_info=params.input.space_group ) xray_data_server = reflection_file_utils.reflection_file_server( crystal_symmetry = phil_xs, force_symmetry = True, reflection_files=[]) miller_array = xray_data_server.get_xray_data( file_name = params.input.xray_data.file_name, labels = params.input.xray_data.labels, ignore_all_zeros = True, parameter_scope = 'reindex_utils.input.xray_data', parameter_name = 'labels' ) info = miller_array.info() miller_array = miller_array.map_to_asu() miller_array = miller_array.select( miller_array.indices() != (0,0,0)) miller_array = miller_array.select( miller_array.data() > 0 ) if miller_array.sigmas() is not None: miller_array = miller_array.select( miller_array.sigmas() > 0 ) if (miller_array.is_xray_intensity_array()): miller_array = miller_array.f_sq_as_f() elif (miller_array.is_complex_array()): miller_array = abs(miller_array) miller_array.set_info(info) print >> log print >> log, "Summary info of observed data" print >> log, "=============================" miller_array.show_summary(f=log) print >> log #---------------------------------------------------------------- # Step 2: get an xray structure from the PDB file # pdb_model = None if params.input.model.file_name is not None: pdb_model = iotbx.pdb.input( file_name=params.input.model.file_name) model = pdb_model.xray_structure_simple(crystal_symmetry=phil_xs) print >> log, "Atomic model summary" print >> log, "====================" model.show_summary() print >> log if params.parameters.action=="reindex": #---------------------------------------------------------------- # step 3: get the reindex laws to_niggli = phil_xs.change_of_basis_op_to_niggli_cell() to_reference = phil_xs.change_of_basis_op_to_reference_setting() to_inverse = phil_xs.change_of_basis_op_to_inverse_hand() cb_op = None pr = params.parameters.reindex if (pr.standard_laws == "niggli"): cb_op = to_niggli elif (pr.standard_laws == "reference_setting"): cb_op = to_reference elif (pr.standard_laws == "invert"): cb_op = to_inverse else: cb_op = sgtbx.change_of_basis_op(pr.user_supplied_law) if cb_op is None: raise Sorry("No change of basis operation is supplied.") if params.parameters.inverse: cb_op = cb_op.inverse() print >> log, "Supplied reindexing law:" print >> log, "========================" print >> log, "hkl notation: ", cb_op.as_hkl() print >> log, "xyz notation: ", cb_op.as_xyz() print >> log, "abc notation: ", cb_op.as_abc() #---------------------------------------------------------------- # step 4: do the reindexing # # step 4a: first do the miller array object new_miller_array = None if miller_array is not None: new_miller_array = miller_array.change_basis( cb_op ) # # step 4b: the xray structure new_model = None if pdb_model is not None: new_model = model.change_basis( cb_op ) #---------------------------------------------------------------- # step 5a: write the new mtz file print >> log print >> log, "The data and model have been reindexed" print >> log, "--------------------------------------" print >> log print >> log, "Writing output files...." if miller_array is not None: print >> log, "writing mtz file with name %s" % (params.output.hklout) mtz_dataset = new_miller_array.as_mtz_dataset( column_root_label="FOBS") mtz_dataset.mtz_object().write(file_name=params.output.hklout) #step 5b: write the new pdb file if new_model is not None: pdb_file = open(params.output.xyzout, 'w') print >> log, "Wring pdb file to: %s" % params.output.xyzout write_as_pdb_file( input_pdb = pdb_model, input_xray_structure = new_model, out = pdb_file, chain_id_increment = params.parameters.chain_id_increment, additional_remark = "Generated by mmtbx reindex") print >> pdb_file, "END" pdb_file.close() if ( [miller_array,new_model]).count(None)==2: print >>log, "No input reflection of coordinate files have been given" if params.parameters.action=="operator": rt_mx = sgtbx.rt_mx( params.parameters.apply_operator.user_supplied_operator,t_den=12*8 ) if params.parameters.inverse: rt_mx = rt_mx.inverse() print >> log print >> log, "Applied operator : ", rt_mx.as_xyz() print >> log sites = model.sites_frac() new_sites = flex.vec3_double() for site in sites: new_site = rt_mx.r()*matrix.col(site) new_site = flex.double(new_site)+flex.double( rt_mx.t().as_double() ) new_sites.append( tuple(new_site) ) new_model = model.deep_copy_scatterers() new_model.set_sites_frac( new_sites ) # write the new [pdb file please pdb_file = open(params.output.xyzout, 'w') print >> log, "Wring pdb file to: %s" % params.output.xyzout if params.parameters.apply_operator.concatenate_model: write_as_pdb_file( input_pdb = pdb_model, input_xray_structure = model, out = pdb_file, chain_id_increment = 0, additional_remark = None, print_cryst_and_scale=True) write_as_pdb_file( input_pdb = pdb_model, input_xray_structure = new_model, out = pdb_file, chain_id_increment = params.parameters.chain_id_increment, additional_remark = None, print_cryst_and_scale=False) print >> pdb_file, "END" pdb_file.close() if params.parameters.action=="manipulate_pdb": #rest all the b values if params.parameters.manipulate_pdb.set_b: b_iso = params.reindex_utils.parameters.manipulate_pdb.b_iso new_model = model.set_b_iso( value = b_iso ) print >> log print >> log, "All B-values have been set to %5.3f"%(b_iso) print >> log, "Writing PDB file %s"%(params.output.xyzout) print >> log pdb_file = open(params.output.xyzout, 'w') write_as_pdb_file( input_pdb = pdb_model, input_xray_structure = new_model, out = pdb_file, chain_id_increment = 0, additional_remark = None, print_cryst_and_scale=True) print >> pdb_file, "END" pdb_file.close() #write the logfile logger = open(params.output.logfile, 'w') print >> log, "Writing log file with name %s" % params.output.logfile print >> log print >> logger, string_buffer.getvalue()
def __init__ (self, args, master_phil, out=sys.stdout, process_pdb_file=True, require_data=True, create_fmodel=True, prefer_anomalous=None, force_non_anomalous=False, set_wavelength_from_model_header=False, set_inelastic_form_factors=None, usage_string=None, create_log_buffer=False, remove_unknown_scatterers=False, generate_input_phil=False) : import mmtbx.monomer_library.pdb_interpretation import mmtbx.monomer_library.server import mmtbx.utils from iotbx import crystal_symmetry_from_any from iotbx import file_reader import iotbx.phil if generate_input_phil : assert isinstance(master_phil, basestring) master_phil = generate_master_phil_with_inputs(phil_string=master_phil) if isinstance(master_phil, str) : master_phil = iotbx.phil.parse(master_phil) if (usage_string is not None) : if (len(args) == 0) or ("--help" in args) : raise Usage("""%s\n\nFull parameters:\n%s""" % (usage_string, master_phil.as_str(prefix=" "))) if (force_non_anomalous) : assert (not prefer_anomalous) assert (set_inelastic_form_factors in [None, "sasaki", "henke"]) self.args = args self.master_phil = master_phil self.processed_pdb_file = self.pdb_inp = None self.pdb_hierarchy = self.xray_structure = None self.geometry = None self.sequence = None self.fmodel = None self.f_obs = None self.r_free_flags = None self.intensity_flag = None self.raw_data = None self.raw_flags = None self.test_flag_value = None self.miller_arrays = None self.hl_coeffs = None self.cif_objects = [] self.log = out if ("--quiet" in args) or ("quiet=True" in args) : self.log = null_out() elif create_log_buffer : self.log = multi_out() self.log.register(label="stdout", file_object=out) self.log.register(label="log_buffer", file_object=StringIO()) make_header("Collecting inputs", out=self.log) cmdline = iotbx.phil.process_command_line_with_files( args=args, master_phil=master_phil, pdb_file_def="input.pdb.file_name", reflection_file_def="input.xray_data.file_name", cif_file_def="input.monomers.file_name", seq_file_def="input.sequence") self.working_phil = cmdline.work params = self.working_phil.extract() if len(params.input.pdb.file_name) == 0 : raise Sorry("At least one PDB file is required as input.") self.cif_file_names = params.input.monomers.file_name self.pdb_file_names = params.input.pdb.file_name # SYMMETRY HANDLING - PDB FILES self.crystal_symmetry = pdb_symm = None for pdb_file_name in params.input.pdb.file_name : pdb_symm = crystal_symmetry_from_any.extract_from(pdb_file_name) if (pdb_symm is not None) : break # DATA INPUT data_and_flags = hkl_symm = hkl_in = None if (params.input.xray_data.file_name is None) : if (require_data) : raise Sorry("At least one reflections file is required as input.") else : # FIXME this may still require that the data file has full crystal # symmetry defined (although for MTZ input this will not be a problem) make_sub_header("Processing X-ray data", out=self.log) hkl_in = file_reader.any_file(params.input.xray_data.file_name) hkl_in.check_file_type("hkl") hkl_server = hkl_in.file_server symm = hkl_server.miller_arrays[0].crystal_symmetry() if ((symm is None) or (symm.space_group() is None) or (symm.unit_cell() is None)) : if (pdb_symm is not None) : from iotbx.reflection_file_utils import reflection_file_server print >> self.log, \ "No symmetry in X-ray data file - using PDB symmetry:" pdb_symm.show_summary(f=out, prefix=" ") hkl_server = reflection_file_server( crystal_symmetry=pdb_symm, reflection_files=[hkl_in.file_object]) else : raise Sorry("No crystal symmetry information found in input files.") if (hkl_server is None) : hkl_server = hkl_in.file_server data_and_flags = mmtbx.utils.determine_data_and_flags( reflection_file_server=hkl_server, parameters=params.input.xray_data, data_parameter_scope="input.xray_data", flags_parameter_scope="input.xray_data.r_free_flags", prefer_anomalous=prefer_anomalous, force_non_anomalous=force_non_anomalous, log=self.log) self.intensity_flag = data_and_flags.intensity_flag self.raw_data = data_and_flags.raw_data self.raw_flags = data_and_flags.raw_flags self.test_flag_value = data_and_flags.test_flag_value self.f_obs = data_and_flags.f_obs self.r_free_flags = data_and_flags.r_free_flags self.miller_arrays = hkl_in.file_server.miller_arrays hkl_symm = self.raw_data.crystal_symmetry() if len(self.cif_file_names) > 0 : for file_name in self.cif_file_names : cif_obj = mmtbx.monomer_library.server.read_cif(file_name=file_name) self.cif_objects.append((file_name, cif_obj)) # SYMMETRY HANDLING - COMBINED if (hkl_symm is not None) : use_symmetry = hkl_symm from iotbx.symmetry import combine_model_and_data_symmetry self.crystal_symmetry = combine_model_and_data_symmetry( model_symmetry=pdb_symm, data_symmetry=hkl_symm) if (self.crystal_symmetry is not None) and (self.f_obs is not None) : self.f_obs = self.f_obs.customized_copy( crystal_symmetry=self.crystal_symmetry).eliminate_sys_absent().set_info( self.f_obs.info()) self.r_free_flags = self.r_free_flags.customized_copy( crystal_symmetry=self.crystal_symmetry).eliminate_sys_absent().set_info( self.r_free_flags.info()) # EXPERIMENTAL PHASES target_name = "ml" if hasattr(params.input, "experimental_phases") : flag = params.input.use_experimental_phases if (flag in [True, Auto]) : phases_file = params.input.experimental_phases.file_name if (phases_file is None) : phases_file = params.input.xray_data.file_name phases_in = hkl_in else : phases_in = file_reader.any_file(phases_file) phases_in.check_file_type("hkl") phases_in.file_server.err = self.log # redirect error output space_group = self.crystal_symmetry.space_group() point_group = space_group.build_derived_point_group() hl_coeffs = mmtbx.utils.determine_experimental_phases( reflection_file_server = phases_in.file_server, parameters = params.input.experimental_phases, log = self.log, parameter_scope = "input.experimental_phases", working_point_group = point_group, symmetry_safety_check = True) if (hl_coeffs is not None) : hl_coeffs = hl_coeffs.map_to_asu() if hl_coeffs.anomalous_flag() : if (not self.f_obs.anomalous_flag()) : hl_coeffs = hl_coeffs.average_bijvoet_mates() elif self.f_obs.anomalous_flag() : hl_coeffs = hl_coeffs.generate_bijvoet_mates() self.hl_coeffs = hl_coeffs.matching_set(other=self.f_obs, data_substitute=(0,0,0,0)) target_name = "mlhl" # PDB INPUT self.unknown_residues_flag = False self.unknown_residues_error_message = False if process_pdb_file : pdb_interp_params = getattr(params, "pdb_interpretation", None) if (pdb_interp_params is None) : pdb_interp_params = \ mmtbx.monomer_library.pdb_interpretation.master_params.extract() make_sub_header("Processing PDB file(s)", out=self.log) pdb_combined = mmtbx.utils.combine_unique_pdb_files( file_names=params.input.pdb.file_name,) pdb_combined.report_non_unique(out=self.log) pdb_raw_records = pdb_combined.raw_records processed_pdb_files_srv = mmtbx.utils.process_pdb_file_srv( cif_objects=self.cif_objects, pdb_interpretation_params=pdb_interp_params, crystal_symmetry=self.crystal_symmetry, use_neutron_distances=params.input.scattering_table=="neutron", stop_for_unknowns=getattr(pdb_interp_params, "stop_for_unknowns",False), log=self.log) self.processed_pdb_file, self.pdb_inp = \ processed_pdb_files_srv.process_pdb_files( raw_records = pdb_raw_records, stop_if_duplicate_labels = False, allow_missing_symmetry=\ (self.crystal_symmetry is None) and (not require_data)) error_msg = self.processed_pdb_file.all_chain_proxies.\ fatal_problems_message( ignore_unknown_scattering_types=False, ignore_unknown_nonbonded_energy_types=False) if (error_msg is not None) : self.unknown_residues_flag = True self.unknown_residues_error_message = error_msg self.geometry = self.processed_pdb_file.geometry_restraints_manager( show_energies=False) assert (self.geometry is not None) self.xray_structure = self.processed_pdb_file.xray_structure() chain_proxies = self.processed_pdb_file.all_chain_proxies self.pdb_hierarchy = chain_proxies.pdb_hierarchy else : pdb_file_object = mmtbx.utils.pdb_file( pdb_file_names=params.input.pdb.file_name, cif_objects=self.cif_objects, crystal_symmetry=self.crystal_symmetry, log=self.log) self.pdb_inp = pdb_file_object.pdb_inp self.pdb_hierarchy = self.pdb_inp.construct_hierarchy() if (remove_unknown_scatterers) : known_sel = self.pdb_hierarchy.atom_selection_cache().selection( "not element X") if (known_sel.count(True) != len(known_sel)) : self.pdb_hierarchy = self.pdb_hierarchy.select(known_sel) self.xray_structure = self.pdb_hierarchy.extract_xray_structure( crystal_symmetry=self.crystal_symmetry) self.pdb_hierarchy.atoms().reset_i_seq() if (self.xray_structure is None) : self.xray_structure = self.pdb_inp.xray_structure_simple( crystal_symmetry=self.crystal_symmetry) # wavelength if (params.input.energy is not None) : if (params.input.wavelength is not None) : raise Sorry("Both wavelength and energy have been specified!") params.input.wavelength = 12398.424468024265 / params.input.energy if (set_wavelength_from_model_header and params.input.wavelength is None) : wavelength = self.pdb_inp.extract_wavelength() if (wavelength is not None) : print >> self.log, "" print >> self.log, "Using wavelength = %g from PDB header" % wavelength params.input.wavelength = wavelength # set scattering table if (data_and_flags is not None) : self.xray_structure.scattering_type_registry( d_min=self.f_obs.d_min(), table=params.input.scattering_table) if ((params.input.wavelength is not None) and (set_inelastic_form_factors is not None)) : self.xray_structure.set_inelastic_form_factors( photon=params.input.wavelength, table=set_inelastic_form_factors) make_sub_header("xray_structure summary", out=self.log) self.xray_structure.scattering_type_registry().show(out = self.log) self.xray_structure.show_summary(f=self.log) # FMODEL SETUP if (create_fmodel) and (data_and_flags is not None) : make_sub_header("F(model) initialization", out=self.log) skip_twin_detection = getattr(params.input, "skip_twin_detection", None) twin_law = getattr(params.input, "twin_law", None) if (twin_law is Auto) : if (self.hl_coeffs is not None) : raise Sorry("Automatic twin law determination not supported when "+ "experimental phases are used.") elif (skip_twin_detection is not None) : twin_law = Auto if (twin_law is Auto) : print >> self.log, "Twinning will be detected automatically." self.fmodel = mmtbx.utils.fmodel_simple( xray_structures=[self.xray_structure], scattering_table=params.input.scattering_table, f_obs=self.f_obs, r_free_flags=self.r_free_flags, skip_twin_detection=skip_twin_detection, target_name=target_name, log=self.log) else : if ((twin_law is not None) and (self.hl_coeffs is not None)) : raise Sorry("Automatic twin law determination not supported when "+ "experimental phases are used.") self.fmodel = mmtbx.utils.fmodel_manager( f_obs=self.f_obs, xray_structure=self.xray_structure, r_free_flags=self.r_free_flags, twin_law=params.input.twin_law, hl_coeff=self.hl_coeffs, target_name=target_name) self.fmodel.update_all_scales( params=None, log=self.log, optimize_mask=True, show=True) self.fmodel.info().show_rfactors_targets_scales_overall(out=self.log) # SEQUENCE if (params.input.sequence is not None) : seq_file = file_reader.any_file(params.input.sequence, force_type="seq", raise_sorry_if_errors=True) self.sequence = seq_file.file_object # UNMERGED DATA self.unmerged_i_obs = None if hasattr(params.input, "unmerged_data") : if (params.input.unmerged_data.file_name is not None) : self.unmerged_i_obs = load_and_validate_unmerged_data( f_obs=self.f_obs, file_name=params.input.unmerged_data.file_name, data_labels=params.input.unmerged_data.labels, log=self.log) self.params = params print >> self.log, "" print >> self.log, "End of input processing"
def run(args): if len(args)==0: master_params.show(expert_level=100) elif ( "--help" in args ): print "no help available" elif ( "--h" in args ): print "no help available" 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() ## 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 print params.scaling.input.xray_data.wavelength1.file_name crystal_symmetry_nat = crystal_symmetry_from_any.extract_from( file_name=params.scaling.input.xray_data.wavelength1.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 appropriate selections miller_array_w1 = None miller_array_w1 = xray_data_server.get_xray_data( file_name = params.scaling.input.xray_data.wavelength1.file_name, labels = params.scaling.input.xray_data.wavelength1.labels, ignore_all_zeros = True, parameter_scope = 'scaling.input.SIR_scale.xray_data.native' ) info_native = miller_array_w1.info() miller_array_w1=miller_array_w1.map_to_asu().select( miller_array_w1.indices()!=(0,0,0) ) miller_array_w1 = miller_array_w1.select( miller_array_w1.data() > 0 ) ## Convert to amplitudes if (miller_array_w1.is_xray_intensity_array()): miller_array_w1 = miller_array_w1.f_sq_as_f() elif (miller_array_w1.is_complex_array()): miller_array_w1 = abs(miller_array_w1) if not miller_array_w1.is_real_array(): raise Sorry("miller_array_native is not a real array") miller_array_w1.set_info(info = info_native) ## Read in derivative data and make appropriate selections miller_array_w2 = None miller_array_w2 = xray_data_server.get_xray_data( file_name = params.scaling.input.xray_data.wavelength2.file_name, labels = params.scaling.input.xray_data.wavelength2.labels, ignore_all_zeros = True, parameter_scope = 'scaling.input.SIR_scale.xray_data.derivative' ) info_w2 = miller_array_w2.info() miller_array_w2=miller_array_w2.map_to_asu().select( miller_array_w2.indices()!=(0,0,0) ) miller_array_w2 = miller_array_w2.select( miller_array_w2.data() > 0 ) ## Convert to amplitudes if (miller_array_w2.is_xray_intensity_array()): miller_array_w2 = miller_array_w2.f_sq_as_f() elif (miller_array_w2.is_complex_array()): miller_array_w2 = abs(miller_array_w2) if not miller_array_w2.is_real_array(): raise Sorry("miller_array_derivative is not a real array") miller_array_w2.set_info(info = info_w2) ## Make sure we have anomalous diffs in both files assert miller_array_w1.anomalous_flag() assert miller_array_w2.anomalous_flag() ## Print info print >> log print >> log, "Wavelength 1" print >> log, "============" miller_array_w1.show_comprehensive_summary(f=log) print >> log w1_pre_scale = pre_scale.pre_scaler( miller_array_w1, params.scaling.input.scaling_strategy.pre_scaler_protocol, params.scaling.input.basic) miller_array_w1 = w1_pre_scale.x1.deep_copy() del w1_pre_scale print >> log print >> log, "Wavelength 2" print >> log, "============" miller_array_w2.show_comprehensive_summary(f=log) print >> log w2_pre_scale = pre_scale.pre_scaler( miller_array_w2, params.scaling.input.scaling_strategy.pre_scaler_protocol, params.scaling.input.basic) miller_array_w2 = w2_pre_scale.x1.deep_copy() del w2_pre_scale print >> log print >> log, "Checking for possible reindexing schemes" print >> log, "----------------------------------------" print >> log print >> log, "Reindexing operator derived as described in:" print >> log, "Grosse-Kunstleve, Afonine, Sauter & Adams. (2005)." print >> log, " IUCr Computing Commission Newsletter 5." print >> log reindex_object = pair_analyses.reindexing( set_a=miller_array_w1, set_b=miller_array_w2, out=log) miller_array_w2 = reindex_object.select_and_transform() miller_array_w2.map_to_asu() print >> log print >> log, "Relative scaling of 2-wavelength mad data" print >> log, "-----------------------------------------" print >> log scaler = fa_estimation.combined_scaling( miller_array_w1, miller_array_w2, params.scaling.input.scaling_strategy.iso_protocol) miller_array_w1 = scaler.x1.deep_copy() miller_array_w2 = scaler.x2.deep_copy() del scaler print >> log print >> log, "Estimating f\" and f' ratios" print >> log, "----------------------------" print >> log # now things are scaled see if we can guestimate the ratio fdpratio = pair_analyses.f_double_prime_ratio( miller_array_w1, miller_array_w2) fpfdpratio = pair_analyses.delta_f_prime_f_double_prime_ratio( miller_array_w1, miller_array_w2) k1 = fdpratio.ratio k2 = fpfdpratio.ratio if k1 is not None: print >> log print >> log, " The estimate of f\"(w1)/f\"(w2) is %3.2f"\ %(fdpratio.ratio) if k2 is not None: print >> log, " The estimate of (f'(w1)-f'(w2))/f\"(w2) is %3.2f"\ %(fpfdpratio.ratio) print >> log print >> log, " The quality of these estimates depends to a large extend" print >> log, " on the quality of the data. If user supplied values" print >> log, " of f\" and f' are given, they will be used instead " print >> log, " of the estimates." print >> log if params.scaling.input.xray_data.wavelength1.f_double_prime is not None: if params.scaling.input.xray_data.wavelength2.f_double_prime is not None: k1 = (params.scaling.input.xray_data.wavelength1.f_double_prime/ params.scaling.input.xray_data.wavelength2.f_double_prime) print >> log, " Using user specified f\" values" print >> log, " user specified f\"(w1)/f\"(w2) is %3.2f"\ %(k1) print >> log if params.scaling.input.xray_data.wavelength1.f_prime is not None: if params.scaling.input.xray_data.wavelength2.f_prime is not None: if params.scaling.input.xray_data.wavelength2.f_double_prime is not None: k2 = (params.scaling.input.xray_data.wavelength1.f_prime- params.scaling.input.xray_data.wavelength2.f_prime)\ /params.scaling.input.xray_data.wavelength2.f_double_prime print >> log, " Using user specified f\" and f' values" print >> log, " user specified f\"(w1)/f\"(w2) is %3.2f"\ %(k2) print >> log fa_gen = fa_estimation.twmad_fa_driver(miller_array_w1, miller_array_w2, k1, k2, params.scaling.input.fa_estimation) print >> log print >> log, "writing mtz file" print >> log, "----------------" print >> log ## Please write out the abs_delta_f array fa = fa_gen.fa_values mtz_dataset = fa.as_mtz_dataset( column_root_label='F'+params.scaling.input.output.outlabel) mtz_dataset.mtz_object().write( file_name=params.scaling.input.output.hklout)
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_input = iotbx.pdb.input(file_name = 'tst_polder_3.pdb') pdb_hierarchy = pdb_input.construct_hierarchy() crystal_symmetry = crystal_symmetry_from_any.extract_from('tst_polder_3.pdb') xray_structure = pdb_hierarchy.extract_xray_structure( crystal_symmetry = crystal_symmetry) 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_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() 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_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() 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 run2 (args, log=sys.stdout, check_params=True, params=None) : import mmtbx.command_line.fetch_pdb libtbx.call_back.set_warning_log(sys.stderr) parameter_interpreter = master_phil.command_line_argument_interpreter( home_scope="") pdb_file = None cif_file = None sources = [] for arg in args : if os.path.isfile(arg) : if iotbx.pdb.is_pdb_file(arg) : pdb_files = os.path.abspath(arg) elif arg.endswith(".cif") or arg.endswith(".cif.txt") : cif_file = os.path.abspath(arg) else : try : user_phil = iotbx.phil.parse(file_name=arg) except RuntimeError : print "Unrecognizable file format for %s" % arg else : sources.append(user_phil) else : if arg.startswith("--") : arg = arg[2:] + "=True" try : user_phil = parameter_interpreter.process(arg=arg) sources.append(user_phil) except RuntimeError : print "Unrecognizable parameter %s" % arg if (params is None) : params = master_phil.fetch(sources=sources).extract() symm = None if (params.input.pdb_id is not None) : params.input.pdb_file = mmtbx.command_line.fetch_pdb.run2( args=[params.input.pdb_id], log=log) params.input.cif_file = mmtbx.command_line.fetch_pdb.run2( args=["-x", params.input.pdb_id], log=log) symm = crystal_symmetry_from_any.extract_from(params.input.pdb_file) params.crystal_symmetry.space_group = symm.space_group_info() params.crystal_symmetry.unit_cell = symm.unit_cell() params.input.pdb_id = None if check_params : validate_params(params) if params.output_file_name is None : base, ext = os.path.splitext(params.input.cif_file) params.output_file_name = os.path.join(os.getcwd(), base + ".mtz") if symm is None : assert (type(params.crystal_symmetry.space_group).__name__ == "space_group_info") symm = crystal.symmetry( space_group_info=params.crystal_symmetry.space_group, unit_cell=params.crystal_symmetry.unit_cell) n_refl = process_files( file_name=params.input.cif_file, crystal_symmetry=symm, output_file_name=params.output_file_name, wavelength_id=params.input.wavelength_id, crystal_id=params.input.crystal_id, show_details_if_error=params.options.show_details_if_error, output_r_free_label="FreeR_flag", merge_non_unique_under_symmetry=params.options.merge, map_to_asu=params.options.map_to_asu, remove_systematic_absences=params.options.eliminate_sys_absent, incompatible_flags_to_work_set=\ params.options.incompatible_flags_to_work_set, ignore_bad_sigmas=params.options.ignore_bad_sigmas, extend_flags=params.options.extend_flags) return (params.output_file_name, n_refl)
def run(args, command_name="phenix.remove_outliers"): if (len(args) == 0 or "--help" in args or "--h" in args or "-h" in args): print_help(command_name=command_name) else: log = multi_out() plot_out = None 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) phil_objects = [] argument_interpreter = master_params.command_line_argument_interpreter( home_scope="outlier_detection") for arg in args: command_line_params = None arg_is_processed = False # is it a file? if arg == "--quiet": arg_is_processed = True if (os.path.isfile(arg)): ## is this a file name? # check if it is a phil file try: command_line_params = iotbx.phil.parse(file_name=arg) if command_line_params is not None: phil_objects.append(command_line_params) arg_is_processed = True except KeyboardInterrupt: raise except Exception: pass 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 file or keyword:", arg print >> log, "##----------------------------------------------##" print >> log raise Sorry("Unknown file or keyword: %s" % arg) effective_params = master_params.fetch(sources=phil_objects) params = effective_params.extract() if not os.path.exists(params.outlier_utils.input.xray_data.file_name): raise Sorry("File %s can not be found" % (params.outlier_utils.input.xray_data.file_name)) if params.outlier_utils.input.model.file_name is not None: if not os.path.exists(params.outlier_utils.input.model.file_name): raise Sorry("File %s can not be found" % (params.outlier_utils.input.model.file_name)) # now get the unit cell from the pdb file hkl_xs = None if params.outlier_utils.input.xray_data.file_name is not None: hkl_xs = crystal_symmetry_from_any.extract_from( file_name=params.outlier_utils.input.xray_data.file_name) pdb_xs = None if params.outlier_utils.input.model.file_name is not None: pdb_xs = crystal_symmetry_from_any.extract_from( file_name=params.outlier_utils.input.model.file_name) phil_xs = crystal.symmetry( unit_cell=params.outlier_utils.input.unit_cell, space_group_info=params.outlier_utils.input.space_group) phil_xs.show_summary() hkl_xs.show_summary() combined_xs = crystal.select_crystal_symmetry(None, phil_xs, [pdb_xs], [hkl_xs]) # inject the unit cell and symmetry in the phil scope please params.outlier_utils.input.unit_cell = combined_xs.unit_cell() params.outlier_utils.input.space_group = \ sgtbx.space_group_info( group = combined_xs.space_group() ) new_params = master_params.format(python_object=params) new_params.show(out=log) if params.outlier_utils.input.unit_cell is None: raise Sorry("unit cell not specified") if params.outlier_utils.input.space_group is None: raise Sorry("space group not specified") if params.outlier_utils.input.xray_data.file_name is None: raise Sorry("Xray data not specified") if params.outlier_utils.input.model.file_name is None: print "PDB file not specified. Basic wilson outlier rejections only." #----------------------------------------------------------- # # step 1: read in the reflection file # phil_xs = crystal.symmetry( unit_cell=params.outlier_utils.input.unit_cell, space_group_info=params.outlier_utils.input.space_group) xray_data_server = reflection_file_utils.reflection_file_server( crystal_symmetry=phil_xs, force_symmetry=True, reflection_files=[]) miller_array = None miller_array = xray_data_server.get_xray_data( file_name=params.outlier_utils.input.xray_data.file_name, labels=params.outlier_utils.input.xray_data.obs_labels, ignore_all_zeros=True, parameter_scope='outlier_utils.input.xray_data', parameter_name='obs_labels') info = miller_array.info() miller_array = miller_array.map_to_asu() miller_array = miller_array.select(miller_array.indices() != (0, 0, 0)) #we have to check if the sigma's make any sense at all if not miller_array.sigmas_are_sensible(): miller_array = miller_array.customized_copy( data=miller_array.data(), sigmas=None).set_observation_type(miller_array) miller_array = miller_array.select(miller_array.data() > 0) if miller_array.sigmas() is not None: miller_array = miller_array.select(miller_array.sigmas() > 0) if (miller_array.is_xray_intensity_array()): miller_array = miller_array.f_sq_as_f() elif (miller_array.is_complex_array()): miller_array = abs(miller_array) miller_array.set_info(info) merged_anomalous = False if miller_array.anomalous_flag(): miller_array = miller_array.average_bijvoet_mates( ).set_observation_type(miller_array) merged_anomalous = True miller_array = miller_array.map_to_asu() # get the free reflections please free_flags = None if params.outlier_utils.input.xray_data.free_flags is None: free_flags = miller_array.generate_r_free_flags( fraction=params.outlier_utils.\ additional_parameters.free_flag_generation.fraction, max_free=params.outlier_utils.\ additional_parameters.free_flag_generation.max_number, lattice_symmetry_max_delta=params.outlier_utils.\ additional_parameters.free_flag_generation.lattice_symmetry_max_delta, use_lattice_symmetry=params.outlier_utils.\ additional_parameters.free_flag_generation.use_lattice_symmetry ) else: free_flags = xray_data_server.get_xray_data( file_name=params.outlier_utils.input.xray_data.file_name, labels=params.outlier_utils.input.xray_data.free_flags, ignore_all_zeros=True, parameter_scope='outlier_utils.input.xray_data', parameter_name='free_flags') if free_flags.anomalous_flag(): free_flags = free_flags.average_bijvoet_mates() merged_anomalous = True free_flags = free_flags.customized_copy(data=flex.bool( free_flags.data() == 1)) free_flags = free_flags.map_to_asu() free_flags = free_flags.common_set(miller_array) print >> log print >> log, "Summary info of observed data" print >> log, "=============================" miller_array.show_summary(f=log) if merged_anomalous: print >> log, "For outlier detection purposes, the Bijvoet pairs have been merged." print >> log print >> log, "Constructing an outlier manager" print >> log, "===============================" print >> log outlier_manager = outlier_rejection.outlier_manager(miller_array, free_flags, out=log) basic_array = None extreme_array = None model_based_array = None basic_array = outlier_manager.basic_wilson_outliers( p_basic_wilson = params.outlier_utils.outlier_detection.\ parameters.basic_wilson.level, return_data = True) extreme_array = outlier_manager.extreme_wilson_outliers( p_extreme_wilson = params.outlier_utils.outlier_detection.parameters.\ extreme_wilson.level, return_data = True) beamstop_array = outlier_manager.beamstop_shadow_outliers( level = params.outlier_utils.outlier_detection.parameters.\ beamstop.level, d_min = params.outlier_utils.outlier_detection.parameters.\ beamstop.d_min, return_data=True) #---------------------------------------------------------------- # Step 2: get an xray structure from the PDB file # if params.outlier_utils.input.model.file_name is not None: model = pdb.input(file_name=params.outlier_utils.input.model. file_name).xray_structure_simple( crystal_symmetry=phil_xs) print >> log, "Atomic model summary" print >> log, "====================" model.show_summary(f=log) print >> log # please make an f_model object for bulk solvent scaling etc etc f_model_object = f_model.manager(f_obs=miller_array, r_free_flags=free_flags, xray_structure=model) print >> log, "Bulk solvent scaling of the data" print >> log, "================================" print >> log, "Maximum likelihood bulk solvent scaling." print >> log f_model_object.update_all_scales(log=log, remove_outliers=False) plot_out = StringIO() model_based_array = outlier_manager.model_based_outliers( f_model_object.f_model(), level=params.outlier_utils.outlier_detection.parameters. model_based.level, return_data=True, plot_out=plot_out) #check what needs to be put out please if params.outlier_utils.output.hklout is not None: if params.outlier_utils.outlier_detection.protocol == "model": if params.outlier_utils.input.model.file_name == None: print >> log, "Model based rejections requested. No model was supplied." print >> log, "Switching to writing out rejections based on extreme value Wilson statistics." params.outlier_utils.outlier_detection.protocol = "extreme" output_array = None print >> log if params.outlier_utils.outlier_detection.protocol == "basic": print >> log, "Non-outliers found by the basic wilson statistics" print >> log, "protocol will be written out." output_array = basic_array new_set_of_free_flags = free_flags.common_set(basic_array) if params.outlier_utils.outlier_detection.protocol == "extreme": print >> log, "Non-outliers found by the extreme value wilson statistics" print >> log, "protocol will be written out." output_array = extreme_array new_set_of_free_flags = free_flags.common_set(extreme_array) if params.outlier_utils.outlier_detection.protocol == "model": print >> log, "Non-outliers found by the model based" print >> log, "protocol will be written out to the file:" print >> log, params.outlier_utils.output.hklout print >> log output_array = model_based_array new_set_of_free_flags = free_flags.common_set( model_based_array) if params.outlier_utils.outlier_detection.protocol == "beamstop": print >> log, "Outliers found for the beamstop shadow" print >> log, "problems detection protocol will be written to the file:" print >> log, params.outlier_utils.output.hklout print >> log output_array = model_based_array new_set_of_free_flags = free_flags.common_set( model_based_array) mtz_dataset = output_array.as_mtz_dataset(column_root_label="FOBS") mtz_dataset = mtz_dataset.add_miller_array( miller_array=new_set_of_free_flags, column_root_label="Free_R_Flag") mtz_dataset.mtz_object().write( file_name=params.outlier_utils.output.hklout) if (params.outlier_utils.output.logfile is not None): final_log = StringIO() print >> final_log, string_buffer.getvalue() print >> final_log if plot_out is not None: print >> final_log, plot_out.getvalue() outfile = open(params.outlier_utils.output.logfile, 'w') outfile.write(final_log.getvalue()) print >> log print >> log, "A logfile named %s was created." % ( params.outlier_utils.output.logfile) print >> log, "This logfile contains the screen output and" print >> log, "(possibly) some ccp4 style loggraph plots"
def sfcalc(args): if len(args)==0: print_help() elif ( "--help" in args ): print_help() elif ( "--h" in args ): print_help() elif ("-h" in args ): print_help() 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) phil_objects = [] argument_interpreter = master_params.command_line_argument_interpreter( home_scope="sfcalc") print >> log, "#phil __OFF__" print >> log, "=================" print >> log, " SFCALC " print >> log, "=================" print >> log for arg in args: command_line_params = None arg_is_processed = False # is it a file? if (os.path.isfile(arg)): ## is this a file name? # check if it is a phil file try: command_line_params = iotbx.phil.parse(file_name=arg) if command_line_params is not None: phil_objects.append(command_line_params) arg_is_processed = True except KeyboardInterrupt: raise except Exception : pass 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 file or keyword:", arg print >> log, "##----------------------------------------------##" print >> log raise Sorry("Unknown file or keyword: %s" % arg) effective_params = master_params.fetch(sources=phil_objects) params = effective_params.extract() # now get the unit cell from the files hkl_xs = None pdb_xs = None if params.sfcalc.input.model.file_name is not None: pdb_xs = crystal_symmetry_from_any.extract_from( file_name=params.sfcalc.input.model.file_name) phil_xs = crystal.symmetry( unit_cell=params.sfcalc.input.unit_cell, space_group_info=params.sfcalc.input.space_group ) combined_xs = crystal.select_crystal_symmetry( None,phil_xs, [pdb_xs],[None]) combined_xs.show_summary() if combined_xs.unit_cell() is None: raise Sorry("Unit cell not defined") if combined_xs.space_group() is None: raise Sorry("Space group not defined") # inject the unit cell and symmetry in the phil scope please params.sfcalc.input.unit_cell = combined_xs.unit_cell() params.sfcalc.input.space_group = \ sgtbx.space_group_info( group = combined_xs.space_group() ) print >> log, "#phil __ON__" new_params = master_params.format(python_object=params) new_params.show(out=log) print >> log, "#phil __END__" pdb_model = None if params.sfcalc.input.model.file_name is not None: pdb_model = pdb.input(file_name=params.sfcalc.input.model.file_name) model = pdb_model.xray_structure_simple(crystal_symmetry=phil_xs) print >> log, "Atomic model summary" print >> log, "====================" model.show_summary() print >> log #make an f_model object please b_cart = params.sfcalc.parameters.overall.b_cart b_cart = [b_cart.b_11, b_cart.b_22, b_cart.b_33, b_cart.b_12, b_cart.b_13, b_cart.b_23] dummy = abs(model.structure_factors( d_min = params.sfcalc.parameters.d_min, anomalous_flag = False).f_calc()) flags = dummy.generate_r_free_flags(fraction = 0.1, max_free = 99999999) fmodel = f_model.manager( xray_structure = model, r_free_flags = flags, target_name = "ls_wunit_k1", f_obs = dummy, b_cart = b_cart, k_sol = params.sfcalc.parameters.solvent.k_sol, b_sol = params.sfcalc.parameters.solvent.b_sol ) calc_data_with_solvent_contrib = fmodel.f_model() calc_data_with_solvent_contrib = calc_data_with_solvent_contrib.array( data=calc_data_with_solvent_contrib.data()*params.sfcalc.parameters.overall.k_overall) result = None label = None if params.sfcalc.parameters.output_type == "complex": result = calc_data_with_solvent_contrib label="FMODEL" if params.sfcalc.parameters.output_type == "amplitudes": result = abs(calc_data_with_solvent_contrib) label="FMODEL" if params.sfcalc.parameters.output_type == "intensities": result = abs(calc_data_with_solvent_contrib) result = result.f_as_f_sq() label="IMODEL" #write an mtz file with the data mtz_dataset = result.as_mtz_dataset( column_root_label=label) mtz_dataset.mtz_object().write( file_name=params.sfcalc.output.hklout) #write the logfile logger = open( params.sfcalc.output.logfile, 'w') print >> log, "writing log file with name %s"%(params.sfcalc.output.logfile) print >> log print >> logger, string_buffer.getvalue()
def simul_utils(args): if len(args) == 0: print_help() elif ("--help" in args): print_help() elif ("--h" in args): print_help() elif ("-h" in args): print_help() 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) phil_objects = [] argument_interpreter = master_params.command_line_argument_interpreter( home_scope="map_coefs") print("#phil __OFF__", file=log) print("======================", file=log) print(" SIMUL ", file=log) print("A data simulation tool", file=log) print("======================", file=log) print(file=log) for arg in args: command_line_params = None arg_is_processed = False # is it a file? if (os.path.isfile(arg)): ## is this a file name? # check if it is a phil file try: command_line_params = iotbx.phil.parse(file_name=arg) if command_line_params is not None: phil_objects.append(command_line_params) arg_is_processed = True except KeyboardInterrupt: raise except Exception: pass 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("##----------------------------------------------##", file=log) print("## Unknown file or keyword:", arg, file=log) print("##----------------------------------------------##", file=log) print(file=log) raise Sorry("Unknown file or keyword: %s" % arg) effective_params = master_params.fetch(sources=phil_objects) params = effective_params.extract() """ new_params = master_params.format(python_object=params) new_params.show(out=log) """ # now get the unit cell from the pdb file hkl_xs = crystal_symmetry_from_any.extract_from( file_name=params.simul_utils.input.xray_data.file_name) pdb_xs = crystal_symmetry_from_any.extract_from( file_name=params.simul_utils.input.model.file_name) phil_xs = crystal.symmetry( unit_cell=params.simul_utils.input.unit_cell, space_group_info=params.simul_utils.input.space_group) combined_xs = select_crystal_symmetry(None, phil_xs, [pdb_xs], [hkl_xs]) # inject the unit cell and symmetry in the phil scope please params.simul_utils.input.unit_cell = combined_xs.unit_cell() params.simul_utils.input.space_group = \ sgtbx.space_group_info( group = combined_xs.space_group() ) print("#phil __ON__", file=log) new_params = master_params.format(python_object=params) new_params.show(out=log) print("#phil __END__", file=log) if params.simul_utils.input.unit_cell is None: raise Sorry("unit cell not specified") if params.simul_utils.input.space_group is None: raise Sorry("space group not specified") if params.simul_utils.input.xray_data.file_name is None: raise Sorry("Xray data not specified") if params.simul_utils.input.model.file_name is None: raise Sorry("pdb file with model not specified") #----------------------------------------------------------- # # step 1: read in the reflection file # phil_xs = crystal.symmetry( unit_cell=params.simul_utils.input.unit_cell, space_group_info=params.simul_utils.input.space_group) xray_data_server = reflection_file_utils.reflection_file_server( crystal_symmetry=phil_xs, force_symmetry=True, reflection_files=[]) miller_array = None miller_array = xray_data_server.get_xray_data( file_name=params.simul_utils.input.xray_data.file_name, labels=params.simul_utils.input.xray_data.labels, ignore_all_zeros=True, parameter_scope='simul_utils.input.xray_data', parameter_name='labels') info = miller_array.info() miller_array = miller_array.map_to_asu() miller_array = miller_array.select(miller_array.indices() != (0, 0, 0)) miller_array = miller_array.select(miller_array.data() > 0) if miller_array.sigmas() is not None: miller_array = miller_array.select(miller_array.sigmas() > 0) if (miller_array.is_xray_intensity_array()): miller_array = miller_array.f_sq_as_f() elif (miller_array.is_complex_array()): miller_array = abs(miller_array) miller_array.set_info(info) print(file=log) print("Summary info of observed data", file=log) print("=============================", file=log) miller_array.show_summary(f=log) print(file=log) free_flags = miller_array.generate_r_free_flags() #-------------------------------------------------------------------- # Step 2: get an xray structure from the PDB file # model = pdb.input(file_name=params.simul_utils.input.model.file_name ).xray_structure_simple(crystal_symmetry=phil_xs, ) print("Atomic model summary", file=log) print("====================", file=log) model.show_summary() print(file=log) #------------------------------------------------------------------- # Step 3: make an F_model object to get model phases and amplitudes # print("Performing bulk solvent scaling", file=log) print("===============================", file=log) print(file=log) print(file=log) f_model_object = f_model.manager(f_obs=miller_array, r_free_flags=free_flags, xray_structure=model) f_model_object.update_all_scales(log=log) fmodel = abs( f_model_object.f_model()).set_observation_type(miller_array) mockfmodel = None if params.simul_utils.input.mock_model.file_name is not None: print("Reading in mock model", file=log) print("=====================", file=log) print(file=log) print(file=log) mock_model = pdb.input(file_name=params.simul_utils.input. mock_model.file_name).xray_structure_simple( crystal_symmetry=phil_xs) mock_f_model = f_model.manager(f_obs=miller_array, r_free_flags=free_flags, xray_structure=mock_model) mock_f_model.update(k_sol=f_model_object.k_sol(), b_sol=f_model_object.b_sol(), b_cart=f_model_object.b_cart()) mockfmodel = abs( mock_f_model.f_model()).set_observation_type(miller_array) else: mockfmodel = fmodel.deep_copy() print("Making new data", file=log) print("===============", file=log) print(file=log) print(file=log) new_data_builder = error_swap(miller_array, fmodel, mockfmodel) new_data = new_data_builder.new_obs # we now have to write the data actually print("Writing new data set", file=log) print("====================", file=log) mtz_dataset = new_data.as_mtz_dataset(column_root_label="FOBS") mtz_dataset.mtz_object().write( file_name=params.simul_utils.output.hklout)
def run(args, out=sys.stdout): cmdline = iotbx.phil.process_command_line_with_files( args=args, master_phil_string=master_phil_str, pdb_file_def="model", reflection_file_def="data", seq_file_def="sequence", space_group_def="space_group", unit_cell_def="unit_cell", integer_def="n_residues", usage_string="""\ phenix.matthews [data.hkl] [space_group] [unit_cel] [sequence] [n_residues] ... Calculate the expected Matthews coefficient given the crystal symmetry and crystallized molecule(s). """, ) params = cmdline.work.extract() if (params.space_group is None) or (params.unit_cell is None): if params.data is None: raise Sorry( "You must supply both a space group and a unit cell (or " + "a data file containing this information)." ) else: symm = crystal_symmetry_from_any.extract_from(file_name=params.data) space_group_from_file = symm.space_group() if params.space_group is None: if space_group_from_file is not None: params.space_group = symm.space_group() elif space_group_from_file is not None: if space_group_from_file != params.space_group: print >> out, "WARNING: space group mismatch between command line " + "and file:" print >> out, " %s (cmdline), %s (file)" % (params.space_group, space_group_from_file) if params.unit_cell is None: params.unit_cell = symm.unit_cell() validate_params(params, check_symmetry=True) if params.sequence is not None: assert params.n_residues == params.n_bases == None seq_comp = iotbx.bioinformatics.composition_from_sequence_file(file_name=params.sequence, log=out) if seq_comp is not None: params.n_residues = seq_comp.n_residues params.n_bases = seq_comp.n_bases else: raise Sorry("No composition information could be obtained from the " + "sequence file.") elif params.model is not None: assert params.n_residues == params.n_bases == None from iotbx.file_reader import any_file params.n_residues = 0 params.n_bases = 0 pdb_in = any_file(params.model) hierarchy = pdb_in.file_object.hierarchy for chain in hierarchy.models()[0].chains(): if chain.is_protein(): params.n_residues += chain.residue_groups_size() elif chain.is_na(): params.n_bases += chain.residue_groups_size() print >> out, "Space group: %s" % params.space_group print >> out, "Unit cell: %s" % params.unit_cell if params.n_residues > 0: print >> out, "Number of residues: %d" % params.n_residues if params.n_bases > 0: print >> out, "Number of bases: %d" % params.n_bases symm = crystal.symmetry(space_group_info=params.space_group, unit_cell=params.unit_cell) from mmtbx.scaling import matthews result = matthews.matthews_rupp(crystal_symmetry=symm, n_residues=params.n_residues, n_bases=params.n_bases) result.show(out=out) return result
def run(args): if len(args) == 0: master_params.show(expert_level=0) elif ("--help" in args): print("no help available") elif ("--h" in args): print("no help available") 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("#phil __OFF__", file=log) print(file=log) print(date_and_time(), file=log) print(file=log) print(file=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("##----------------------------------------------##", file=log) print("## Unknown phil-file or phil-command:", arg, file=log) print("##----------------------------------------------##", file=log) print(file=log) raise Sorry("Unknown file format or phil command: %s" % arg) effective_params = master_params.fetch(sources=phil_objects) params = effective_params.extract() ## 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.native.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("Using symmetry of native data", file=log) if params.scaling.input.xray_data.unit_cell is None: params.scaling.input.xray_data.unit_cell =\ crystal_symmetry_nat.unit_cell() print("Using cell of native data", file=log) ## 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("Effective parameters", file=log) print("#phil __ON__", file=log) new_params.show(out=log, expert_level=params.scaling.input.expert_level) print("#phil __END__", file=log) print(file=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.native.file_name, labels=params.scaling.input.xray_data.native.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) ## Read in derivative data and make appropriate selections miller_array_derivative = None miller_array_derivative = xray_data_server.get_xray_data( file_name=params.scaling.input.xray_data.derivative.file_name, labels=params.scaling.input.xray_data.derivative.labels, ignore_all_zeros=True, parameter_scope='scaling.input.SIR_scale.xray_data.derivative') info_derivative = miller_array_derivative.info() miller_array_derivative = miller_array_derivative.map_to_asu().select( miller_array_derivative.indices() != (0, 0, 0)) miller_array_derivative = miller_array_derivative.select( miller_array_derivative.data() > 0) ## Convert to amplitudes if (miller_array_derivative.is_xray_intensity_array()): miller_array_derivative = miller_array_derivative.f_sq_as_f() elif (miller_array_derivative.is_complex_array()): miller_array_derivative = abs(miller_array_derivative) if not miller_array_derivative.is_real_array(): raise Sorry("miller_array_derivative is not a real array") miller_array_derivative.set_info(info=info_derivative) ## As this is a SIR case, we will remove any anomalous pairs if miller_array_derivative.anomalous_flag(): miller_array_derivative = miller_array_derivative.average_bijvoet_mates()\ .set_observation_type( miller_array_derivative ) if miller_array_native.anomalous_flag(): miller_array_native = miller_array_native.average_bijvoet_mates()\ .set_observation_type( miller_array_native ) ## Print info print(file=log) print("Native data", file=log) print("===========", file=log) miller_array_native.show_comprehensive_summary(f=log) print(file=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 print(file=log) print("Derivative data", file=log) print("===============", file=log) miller_array_derivative.show_comprehensive_summary(f=log) print(file=log) derivative_pre_scale = pre_scale.pre_scaler( miller_array_derivative, params.scaling.input.scaling_strategy.pre_scaler_protocol, params.scaling.input.basic) miller_array_derivative = derivative_pre_scale.x1.deep_copy() del derivative_pre_scale scaler = fa_estimation.combined_scaling( miller_array_native, miller_array_derivative, params.scaling.input.scaling_strategy.iso_protocol) miller_array_native = scaler.x1.deep_copy() miller_array_derivative = scaler.x2.deep_copy() del scaler print(file=log) print("Making delta f's", file=log) print("----------------", file=log) print(file=log) delta_gen = pair_analyses.delta_generator(miller_array_native, miller_array_derivative) print(file=log) print("writing mtz file", file=log) print("----------------", file=log) print(file=log) ## some assertions to make sure nothing went weerd assert miller_array_native.observation_type() is not None assert miller_array_derivative.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)
def run(args, command_name="phenix.remove_outliers"): if (len(args)==0 or "--help" in args or "--h" in args or "-h" in args): print_help(command_name=command_name) else: log = multi_out() plot_out = None 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) phil_objects = [] argument_interpreter = master_params.command_line_argument_interpreter( home_scope="outlier_detection") for arg in args: command_line_params = None arg_is_processed = False # is it a file? if arg=="--quiet": arg_is_processed = True if (os.path.isfile(arg)): ## is this a file name? # check if it is a phil file try: command_line_params = iotbx.phil.parse(file_name=arg) if command_line_params is not None: phil_objects.append(command_line_params) arg_is_processed = True except KeyboardInterrupt: raise except Exception : pass 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 file or keyword:", arg print >> log, "##----------------------------------------------##" print >> log raise Sorry("Unknown file or keyword: %s" % arg) effective_params = master_params.fetch(sources=phil_objects) params = effective_params.extract() if not os.path.exists( params.outlier_utils.input.xray_data.file_name ) : raise Sorry("File %s can not be found"%(params.outlier_utils.input.xray_data.file_name) ) if params.outlier_utils.input.model.file_name is not None: if not os.path.exists( params.outlier_utils.input.model.file_name ): raise Sorry("File %s can not be found"%(params.outlier_utils.input.model.file_name) ) # now get the unit cell from the pdb file hkl_xs = None if params.outlier_utils.input.xray_data.file_name is not None: hkl_xs = crystal_symmetry_from_any.extract_from( file_name=params.outlier_utils.input.xray_data.file_name) pdb_xs = None if params.outlier_utils.input.model.file_name is not None: pdb_xs = crystal_symmetry_from_any.extract_from( file_name=params.outlier_utils.input.model.file_name) phil_xs = crystal.symmetry( unit_cell=params.outlier_utils.input.unit_cell, space_group_info=params.outlier_utils.input.space_group ) phil_xs.show_summary() hkl_xs.show_summary() combined_xs = crystal.select_crystal_symmetry( None,phil_xs, [pdb_xs],[hkl_xs]) # inject the unit cell and symmetry in the phil scope please params.outlier_utils.input.unit_cell = combined_xs.unit_cell() params.outlier_utils.input.space_group = \ sgtbx.space_group_info( group = combined_xs.space_group() ) new_params = master_params.format(python_object=params) new_params.show(out=log) if params.outlier_utils.input.unit_cell is None: raise Sorry("unit cell not specified") if params.outlier_utils.input.space_group is None: raise Sorry("space group not specified") if params.outlier_utils.input.xray_data.file_name is None: raise Sorry("Xray data not specified") if params.outlier_utils.input.model.file_name is None: print "PDB file not specified. Basic wilson outlier rejections only." #----------------------------------------------------------- # # step 1: read in the reflection file # phil_xs = crystal.symmetry( unit_cell=params.outlier_utils.input.unit_cell, space_group_info=params.outlier_utils.input.space_group ) xray_data_server = reflection_file_utils.reflection_file_server( crystal_symmetry = phil_xs, force_symmetry = True, reflection_files=[]) miller_array = None miller_array = xray_data_server.get_xray_data( file_name = params.outlier_utils.input.xray_data.file_name, labels = params.outlier_utils.input.xray_data.obs_labels, ignore_all_zeros = True, parameter_scope = 'outlier_utils.input.xray_data', parameter_name = 'obs_labels' ) info = miller_array.info() miller_array = miller_array.map_to_asu() miller_array = miller_array.select( miller_array.indices() != (0,0,0)) #we have to check if the sigma's make any sense at all if not miller_array.sigmas_are_sensible(): miller_array = miller_array.customized_copy( data = miller_array.data(), sigmas=None).set_observation_type(miller_array) miller_array = miller_array.select( miller_array.data() > 0 ) if miller_array.sigmas() is not None: miller_array = miller_array.select( miller_array.sigmas() > 0 ) if (miller_array.is_xray_intensity_array()): miller_array = miller_array.f_sq_as_f() elif (miller_array.is_complex_array()): miller_array = abs(miller_array) miller_array.set_info(info) merged_anomalous=False if miller_array.anomalous_flag(): miller_array = miller_array.average_bijvoet_mates().set_observation_type( miller_array ) merged_anomalous=True miller_array = miller_array.map_to_asu() # get the free reflections please free_flags = None if params.outlier_utils.input.xray_data.free_flags is None: free_flags = miller_array.generate_r_free_flags( fraction=params.outlier_utils.\ additional_parameters.free_flag_generation.fraction, max_free=params.outlier_utils.\ additional_parameters.free_flag_generation.max_number, lattice_symmetry_max_delta=params.outlier_utils.\ additional_parameters.free_flag_generation.lattice_symmetry_max_delta, use_lattice_symmetry=params.outlier_utils.\ additional_parameters.free_flag_generation.use_lattice_symmetry ) else: free_flags = xray_data_server.get_xray_data( file_name = params.outlier_utils.input.xray_data.file_name, labels = params.outlier_utils.input.xray_data.free_flags, ignore_all_zeros = True, parameter_scope = 'outlier_utils.input.xray_data', parameter_name = 'free_flags' ) if free_flags.anomalous_flag(): free_flags = free_flags.average_bijvoet_mates() merged_anomalous=True free_flags = free_flags.customized_copy( data = flex.bool( free_flags.data() == 1 )) free_flags = free_flags.map_to_asu() free_flags = free_flags.common_set( miller_array ) print >> log print >> log, "Summary info of observed data" print >> log, "=============================" miller_array.show_summary(f=log) if merged_anomalous: print >> log, "For outlier detection purposes, the Bijvoet pairs have been merged." print >> log print >> log, "Constructing an outlier manager" print >> log, "===============================" print >> log outlier_manager = outlier_rejection.outlier_manager( miller_array, free_flags, out=log) basic_array = None extreme_array = None model_based_array = None basic_array = outlier_manager.basic_wilson_outliers( p_basic_wilson = params.outlier_utils.outlier_detection.\ parameters.basic_wilson.level, return_data = True) extreme_array = outlier_manager.extreme_wilson_outliers( p_extreme_wilson = params.outlier_utils.outlier_detection.parameters.\ extreme_wilson.level, return_data = True) beamstop_array = outlier_manager.beamstop_shadow_outliers( level = params.outlier_utils.outlier_detection.parameters.\ beamstop.level, d_min = params.outlier_utils.outlier_detection.parameters.\ beamstop.d_min, return_data=True) #---------------------------------------------------------------- # Step 2: get an xray structure from the PDB file # if params.outlier_utils.input.model.file_name is not None: model = pdb.input(file_name=params.outlier_utils.input.model.file_name).xray_structure_simple( crystal_symmetry=phil_xs) print >> log, "Atomic model summary" print >> log, "====================" model.show_summary(f=log) print >> log # please make an f_model object for bulk solvent scaling etc etc f_model_object = f_model.manager( f_obs = miller_array, r_free_flags = free_flags, xray_structure = model ) print >> log, "Bulk solvent scaling of the data" print >> log, "================================" print >> log, "Maximum likelihood bulk solvent scaling." print >> log f_model_object.update_solvent_and_scale(out=log) plot_out = StringIO() model_based_array = outlier_manager.model_based_outliers( f_model_object.f_model(), level=params.outlier_utils.outlier_detection.parameters.model_based.level, return_data=True, plot_out=plot_out) #check what needs to be put out please if params.outlier_utils.output.hklout is not None: if params.outlier_utils.outlier_detection.protocol == "model": if params.outlier_utils.input.model.file_name == None: print >> log, "Model based rejections requested. No model was supplied." print >> log, "Switching to writing out rejections based on extreme value Wilson statistics." params.outlier_utils.outlier_detection.protocol="extreme" output_array = None print >> log if params.outlier_utils.outlier_detection.protocol == "basic": print >> log, "Non-outliers found by the basic wilson statistics" print >> log, "protocol will be written out." output_array = basic_array new_set_of_free_flags = free_flags.common_set( basic_array ) if params.outlier_utils.outlier_detection.protocol == "extreme": print >> log, "Non-outliers found by the extreme value wilson statistics" print >> log, "protocol will be written out." output_array = extreme_array new_set_of_free_flags = free_flags.common_set( extreme_array ) if params.outlier_utils.outlier_detection.protocol == "model": print >> log, "Non-outliers found by the model based" print >> log, "protocol will be written out to the file:" print >> log, params.outlier_utils.output.hklout print >> log output_array = model_based_array new_set_of_free_flags = free_flags.common_set( model_based_array ) if params.outlier_utils.outlier_detection.protocol == "beamstop": print >> log, "Outliers found for the beamstop shadow" print >> log, "problems detection protocol will be written to the file:" print >> log, params.outlier_utils.output.hklout print >> log output_array = model_based_array new_set_of_free_flags = free_flags.common_set( model_based_array ) mtz_dataset = output_array.as_mtz_dataset( column_root_label="FOBS") mtz_dataset = mtz_dataset.add_miller_array( miller_array = new_set_of_free_flags, column_root_label = "Free_R_Flag" ) mtz_dataset.mtz_object().write( file_name=params.outlier_utils.output.hklout) if (params.outlier_utils.output.logfile is not None): final_log = StringIO() print >> final_log, string_buffer.getvalue() print >> final_log if plot_out is not None: print >> final_log, plot_out.getvalue() outfile = open( params.outlier_utils.output.logfile, 'w' ) outfile.write( final_log.getvalue() ) print >> log print >> log, "A logfile named %s was created."%( params.outlier_utils.output.logfile) print >> log, "This logfile contains the screen output and" print >> log, "(possibly) some ccp4 style loggraph plots"