# generic-objects.py # # Copyright 2006 by Paul Emsley, The University of York # Copyright 2006 by Bernhard Lohkamp # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . import os import coot import coot_utils global probe_command global reduce_command global reduce_molecule_updates_current global interactive_probe_is_OK_qm # gets set the first time we run interactive_probe. Takes values # 'unset' (initial value) 'yes' and 'no') # interactive_probe_is_OK_qm = 'unset' # set reduce and probe command full path here if you wish # (or have a look in group_settings!! These overwrite whatever is here), e.g. # reduce_command = "/home/bernhard/bin/reduce" # BL says:: just to be consistent with Paul's names # map to scheme names: # deftexi generic_object_is_displayed_qm generic_object_is_displayed_qm = coot.generic_object_is_displayed_p # map to scheme names: # deftexi is_closed_generic_object_qm is_closed_generic_object_qm = coot.is_closed_generic_object_p # return a new generic object number for the given object obj-name. # If there is no such object with name obj-name, then create a new # one. (Maybe you want the generic object to be cleaned if it exists # before returning, this function does not do that). # def generic_object_with_name(obj_name): t = coot.generic_object_index(obj_name) if (t == -1): t = coot.new_generic_object_number(obj_name) return t # display a GUI for generic objects # def generic_objects_gui(): print(":::::::::::::::::: generic_objects_gui() needs a redo") # this is old. just call the build-in one. return pygtk_flag = False try: import pygtk pygtk.require("2.0") import gtk, pango pygtk_flag = True except: print("Fail") if (pygtk_flag and coot_utils.using_gui()): # Now we run the gui def delete_event(*args): # BL says: first we shall close the generic objects # or not #for generic_object_number in range(n_objects): # coot.set_display_generic_object(generic_object_number, 0) gen_window.destroy() return False def check_button_callback(widget, generic_object_number): button_state = widget.get_active() object_state = generic_object_is_displayed_qm(generic_object_number) if ((button_state == True) and (object_state == 0)): coot.set_display_generic_object(generic_object_number,1) if ((button_state == False) and (object_state == 1)): coot.set_display_generic_object(generic_object_number,0) def all_check_button_callback(widget): show_all = widget.get_active() for check_button in open_generic_objects: if (show_all): check_button.set_active(True) else: check_button.set_active(False) n_objects = coot.number_of_generic_objects() if (n_objects > 0): gen_window = gtk.Window(gtk.WINDOW_TOPLEVEL) gen_window.set_title("Generic objects") vbox = gtk.VBox(False, 0) open_generic_objects = [] no_active_generic_objects = 0 for generic_object_number in range(n_objects): print("INFO:: generic object attributes: ", \ generic_object_number, \ generic_object_name(generic_object_number), \ is_closed_generic_object_qm(generic_object_number)) if (is_closed_generic_object_qm(generic_object_number) == 0): name = generic_object_name(generic_object_number) if (name): label = str(generic_object_number) + " " + name frame = gtk.Frame(label=None) check_button = gtk.CheckButton(label) # this callback gets called by the # gtk-toggle-button-set-active just below, # which is why we need the state and active # test. check_button.connect("toggled", check_button_callback, generic_object_number) current_state = generic_object_is_displayed_qm(generic_object_number) if (current_state == 1): check_button.set_active(True) no_active_generic_objects += 1 vbox.add(frame) frame.add(check_button) frame.show() check_button.show() open_generic_objects.append(check_button) if (len(open_generic_objects) > 1): hsep = gtk.HSeparator() label = "Show/hide all" frame = gtk.Frame(label=None) check_button = gtk.CheckButton(label) check_button.connect("toggled", all_check_button_callback) if (len(open_generic_objects) == no_active_generic_objects): check_button.set_active(True) vbox.add(hsep) hsep.show() vbox.add(frame) frame.add(check_button) frame.show() check_button.show() gen_window.connect("delete_event", delete_event) vbox.show() gen_window.add(vbox) gen_window.set_border_width(10) gen_window.show() # return status # def reduce_on_pdb_file(imol, pdb_in, pdb_out): return reduce_on_pdb_file_generic(imol, "build", pdb_in, pdb_out) # return status # def reduce_on_pdb_file_no_flip(imol, pdb_in, pdb_out): r = reduce_on_pdb_file_generic(imol, "no-flip", pdb_in, pdb_out) return r # return status # def reduce_on_pdb_file_generic(imol, no_flip_or_build, pdb_in, pdb_out): global reduce_command print("running reduce on", pdb_in) # could try coot_utils.find_exe too! if not coot_utils.command_in_path_qm(reduce_command): print("command for reduce %s is not found in path" %reduce_command) else: # need full path to find het dict full_reduce_command = coot_utils.find_exe(reduce_command, "PATH") nshl = coot.non_standard_residue_names_py(imol) print("DEBUG:: in reduce_on_pdb_file_generic(), nshl is ", nshl) ext = "-".join(nshl) reduce_het_dict_file_name = "coot-molprobity/reduce-het-dict-" + ext + ".txt" write_reduce_het_dict(imol, reduce_het_dict_file_name) dict_args = [] if not set_reduce_het_dict(): # now should use the and build the het dic!? dict_args = ["-DB", reduce_het_dict_file_name] mode = "-build" if no_flip_or_build == "no-flip": mode = "-NOFLIP" print("======= reduce_on_pdb_file: command %s args %s with pdb_out: %s" \ %(reduce_command, [mode, pdb_in] + dict_args, pdb_out)) status = coot_utils.popen_command(reduce_command, [mode, pdb_in] + dict_args, [], pdb_out) print("======== status", status) # 20130107 returning (status == 0) is problematic because sometimes/often reduce exits # with status 1 but it has worked OK! # # return status == 0 return True global old_pdb_style old_pdb_style = False reduce_molecule_updates_current = False reduce_command = "molprobity.reduce" probe_command = "molprobity.probe" # run molprobity (well reduce and probe) to make generic objects (and # display the generic objects gui) # def probe(imol): import os import coot_utils global reduce_command, probe_command global old_pdb_style if coot.is_valid_model_molecule(imol): if not (os.path.isfile(reduce_command)): reduce_command = coot_utils.find_exe("reduce", "PATH", "CBIN", "CCP4_BIN") # we need to check if probe_command is defined too if not(os.path.isfile(probe_command)): probe_command = coot_utils.find_exe("probe", "PATH", "CBIN", "CCP4_BIN") coot.make_directory_maybe("coot-molprobity") mol_pdb_file = "coot-molprobity/for-reduce.pdb" reduce_out_pdb_file = "coot-molprobity/reduced.pdb" reduce_het_dict_file_name = "coot-molprobity/reduce-het-dict.txt" coot.write_pdb_file(imol, mol_pdb_file) write_reduce_het_dict(imol, reduce_het_dict_file_name) if not reduce_command: # couldnt find reduce print("BL WARNING:: Could not locate the program reduce!! Please check if installed!") else: dict_args = [] if not set_reduce_het_dict(): dict_args = ["-DB", reduce_het_dict_file_name] if old_pdb_style: # old arg_list = ["-build", "-oldpdb", mol_pdb_file] else: # modern arg_list = ["-build", mol_pdb_file] arg_list += dict_args print("BL INFO:: running reduce: %s %s and ouptut to: %s" \ %(reduce_command , arg_list, reduce_out_pdb_file)) print("BL INFO:: running reduce: REDUCE_HET_DICT env var:", os.getenv('REDUCE_HET_DICT')) reduce_status = coot_utils.popen_command(reduce_command, arg_list, [], reduce_out_pdb_file) # dont check for status as meaningless... if not probe_command: # couldnt find probe print("BL WARNING:: Could not locate the program probe!! Please check if installed!") else: probe_name_stub = coot_utils.strip_extension(coot_utils.strip_path(coot.molecule_name(imol))) probe_pdb_in = "coot-molprobity/" + probe_name_stub + "-with-H.pdb" probe_out = "coot-molprobity/probe-dots.out" prepare_file_for_probe(reduce_out_pdb_file, probe_pdb_in) probe_status = coot_utils.popen_command(probe_command, ["-u", "-mc", "ALL", probe_pdb_in], [], probe_out) if (probe_status): print("BL WARNING:: probe failed, cannot continue!") else: # by default, we don't want to click on the # imol-probe molecule (I think :-) recentre_status = coot.recentre_on_read_pdb() novalue = coot.set_recentre_on_read_pdb(0) if (reduce_molecule_updates_current): print("======= update molecule =======") imol_probe = coot.clear_and_update_model_molecule_from_file(imol, probe_pdb_in) else: print("======= read new pdb file =======") imol_probe = coot.read_pdb(probe_pdb_in) if recentre_status == 1: coot.set_recentre_on_read_pdb(1) # show the GUI for USER MODS if coot_utils.using_gui(): coot_gui.user_mods_gui(imol_probe, reduce_out_pdb_file) # coot_utils.toggle_active_mol(imol_probe) let's not do # that actually. I no longer think that the # new probe molecule should not be clickable # when it is initally displayed (that plus # there is some active/displayed logic problem # for the molecules, which means that after # several probes, the wrong molecule is # getting refined). coot.handle_read_draw_probe_dots_unformatted(probe_out, imol_probe, 2) # generic_objects_gui() old coot.graphics_draw() # Write the connectivity for the non-standard (non-water) residues in # the given molecule for which we have the dictionary. # # Don't return anything interesting. # def write_reduce_het_dict(imol, reduce_het_dict_file_name): print("debug:: reduce_het_dict_file_name", reduce_het_dict_file_name) con_file_names = [] for res_name in coot.non_standard_residue_names_py(imol): f_name = "coot-molprobity/conn-" + res_name + ".txt" status = coot.write_connectivity(res_name, f_name) if (status == 1): con_file_names.append(f_name) if con_file_names: # fin = open(reduce_het_dict_file_name, 'w') #for file_name in con_file_names: # shutil.copyfileobj(open(file_name, 'rb'), fin) # fin.close() with open(reduce_het_dict_file_name, 'w') as out_file: for file_name in con_file_names: print("debug:: file_name", file_name) with open(file_name) as in_file: out_file.write(in_file.read()) # Prepare file for probe, i.e. remove 'USER' from file def prepare_file_for_probe(file_in, file_out): try: fin = open(file_in,'r') except IOError: print("BL WARNING:: Cannot read ", file_in) try: fout = open(file_out,'w') except IOError: print("BL WARNING:: Cannot write ", file_out) if (fin and fout): lines = fin.readlines() for line in lines: if (not "USER" in line): fout.write(line) fin.close() fout.close() # run "probe" interactively, # which in the current implementation, means that this function # can run during a edit-chi angles manipulation, or after # a real space refine zone. # # Thus function presumes that there are 2 pdb files in the current # directory, one of which is the reference pdb file and the other # is a pdb file containing the tmp/moving atom set. # # The function takes arguments for the centre of the probe dots # and the radius of the probe dots sphere. The chain id and # residue number are also needed to pass as arguments to probe. # def interactive_probe(x_cen, y_cen, z_cen, radius, chain_id, res_no): import os, string global probe_command global interactive_probe_is_OK_qm probe_pdb_in_1 = "molprobity-tmp-reference-file.pdb" probe_pdb_in_2 = "molprobity-tmp-moving-file.pdb" probe_out = "coot-molprobity/molprobity-tmp-probe-dots.out" chain_str = "" if (not chain_id == ""): chain_str = "chain" atom_sel = "(file1 within " + str(radius) + " of " \ + str(x_cen) + ", " \ + str(y_cen) + ", " \ + str(z_cen) + ", " \ + "not water not (" + chain_str + string.lower(chain_id) + " " \ + str(res_no) + ")),file2" # no longer use std-bonds print("probe command", probe_command, \ ["-mc", "-u", "-quiet", "-drop", "-both", atom_sel, "file2", probe_pdb_in_1, probe_pdb_in_2]) # if unset, then set it. if (interactive_probe_is_OK_qm == 'unset'): if (coot_utils.command_in_path_qm(probe_command)): interactive_probe_is_OK_qm = 'yes' else: interactive_probe_is_OK_qm = 'no' if (interactive_probe_is_OK_qm == 'yes'): status = coot_utils.popen_command(probe_command, ["-mc", "-u", "-quiet", "-drop", "-both", atom_sel, "file2", probe_pdb_in_1, probe_pdb_in_2], [], probe_out) # don't show the gui, so the imol is not needed/dummy. coot.handle_read_draw_probe_dots_unformatted(probe_out, 0, 0) coot.graphics_draw() # # def get_probe_dots_from(pdb_file_name, point, radius): global probe_command global interactive_probe_is_OK_qm import os # if unset, then set it, try to make dir too if (interactive_probe_is_OK_qm == 'unset'): if (not coot_utils.command_in_path_qm(probe_command)): interactive_probe_is_OK_qm = 'no' else: dir_name = coot_utils.get_directory("coot-molprobity") if (dir_name): # OK, we had it or made it interactive_probe_is_OK_qm = 'yes' else: interactive_probe_is_OK_qm = 'no' if (interactive_probe_is_OK_qm == 'yes'): probe_out = os.path.join("coot-molprobity", "molprobity-tmp-probe-dots.out") within_str = "(within " + \ str(radius) + \ " of " + \ str(point[0]) + \ ", " + \ str(point[1]) + \ ", " + \ str(point[2]) + \ ")" args = ["-mc", "-u", "-quiet", "-drop", "-stdbonds", "ALL", # whole residues from sphere selection # was needed to make this work # within_str # problems with atom selection pdb_file_name] print("popen_comand on", probe_command, args) coot_utils.popen_command(probe_command, args, [], probe_out, False) coot.handle_read_draw_probe_dots_unformatted(probe_out, 0, 0) coot.graphics_draw() # Update the generic objects probe dots from residues within radius # of the screen centre. # # Return nothing interesting. # def probe_local_sphere(imol, radius): # We need to select more atoms than we probe because if the atom # selection radius and the probe radius are the same, then # sometimes the middle atom of a bonded angle set is missing # (outside the sphere) and that leads to bad clashes. # There are also bad clashed at the edge when alt-confed atoms # are not selected but non-alt-confs are which leads to missing atoms # in a bond angle and therefore clashes. pt = coot_utils.rotation_centre() imol_new = coot.new_molecule_by_sphere_selection(imol, pt[0], pt[1], pt[2], radius, 0) coot.set_mol_displayed(imol_new, 0) set_mol_active (imol_new, 0) pdb_name = "molprobity-tmp-reference-file.pdb" coot.make_directory_maybe("coot-molprobity") write_pdb_file_for_molprobity(imol_new, pdb_name) get_probe_dots_from(pdb_name, pt, radius) coot.close_molecule(imol_new) def probe_local_sphere_active_atom(radius=5.0): with coot_utils.UsingActiveAtom() as [aa_imol, aa_chain_id, aa_res_no, aa_ins_code, aa_atom_name, aa_alt_conf]: probe_local_sphere(aa_imol, radius) # add in the conn files by concatting. # def write_pdb_file_for_molprobity(imol, pdb_name): tmp_pdb_name = coot_utils.file_name_sans_extension(pdb_name) + "-tmp.pdb" coot.write_pdb_file(imol, tmp_pdb_name) # Let's add on the connectivity cards of the residues that # molprobity doesn't know about (which I presume are all # non-standard residues). Cut out (filter) files that didn't # write properly. # conn_file_names = [] for res_name in non_standard_residue_names(imol): f_name = os.path.join("coot-molprobity", "conn-" + res_name + ".txt") status = coot.write_connectivity(res_name, f_name) if (status == 1): conn_file_names.append(f_name) # now, add (append) each of the con-file-names to the end of # pdb-name if (not os.path.isfile(tmp_pdb_name)): print("ERROR:: tmp file name not found", tmp_pdb_name) else: conn_file_names.insert(0, tmp_pdb_name) fn_all = open(pdb_name, 'w') for conn_file in conn_file_names: if (os.path.isfile(conn_file)): cf = open(conn_file, 'r') data = cf.read() cf.close() fn_all.write(data) fn_all.close() # not sure if the following ones should reside here?! Maybe rather in coot_gui.coot_gui? # a toggle function for the main toolbar to switch on probe dots post refine # and for chis/rotamers # def toggle_interactive_probe_dots(widget=None): """a toggle function for the main toolbar to switch on probe dots post refine and for chis/rotamers Keyword arguments: widget -- can be passed from the toolbutton """ if widget: if widget.get_active(): # the button is toggled on coot.set_do_probe_dots_on_rotamers_and_chis(1) coot.set_do_probe_dots_post_refine(1) else: coot.set_do_probe_dots_on_rotamers_and_chis(0) coot.set_do_probe_dots_post_refine(0) else: # no alternative for now (could just go by state and change back and forth) print("BL WARNING:: no widget") def set_reduce_het_dict(): """helper function to set env variable REDUCE_HET_DICT returns True if could be set (or already set), False if it couldnt be set. """ global reduce_command # BL says: I think we should set REDUCE_HET_DICT # so let's set REDUCE_HET_DICT if not set already! # not sure if needed any more since we write a connectivity # file - let's see FIXME!! # if we have probe/reduce from ccp4 we should pick it up there!? # should be in $CCP4/share/reduce/ red_het_dict = os.getenv('REDUCE_HET_DICT') red_het_file = "reduce_wwPDB_het_dict.txt" #negative path # if (not red_het_dict or # (red_het_dict and not os.path.isfile(red_het_dict))): # positive path (maybe should check that red_het_dict is a string?!) if (red_het_dict and (os.path.isfile(red_het_dict))): return True else: # not set and/or not found # first check if from ccp4 then it is in $CCP4/share/reduce/ ccp4_dir = os.getenv('CCP4') if (ccp4_dir and (os.path.normpath(ccp4_dir) in os.path.normpath(reduce_command))): # have ccp4 reduce red_het_dict = os.path.join(ccp4_dir, "share", "reduce", red_het_file) if os.path.isfile(red_het_dict): os.environ['REDUCE_HET_DICT'] = red_het_dict return True else: print("BL WARNING:: could neither find nor set REDUCE_HET_DICT !") return False else: # not from ccp4 # we assume the dic is in same dir as reduce command full_reduce_command = coot_utils.find_exe(reduce_command, "PATH") dir, tmp = os.path.split(full_reduce_command) red_het_dict = os.path.join(dir, red_het_file) if (os.path.isfile(red_het_dict)): os.environ['REDUCE_HET_DICT'] = red_het_dict return True else: # before we give up check in share/coot # this is where the windows installer shall put it prefix_dir = os.getenv("COOT_PREFIX") if not prefix_dir: pkg_data_dir = coot.get_pkgdatadir_py() else: pkg_data_dir = os.path.join(prefix_dir, "share", "coot") red_het_file = os.path.join(pkg_data_dir, red_het_file) if (os.path.isfile(red_het_dict)): os.environ['REDUCE_HET_DICT'] = red_het_dict return True else: # finally give up print("BL WARNING:: could neither find nor set REDUCE_HET_DICT !") return False