def testIgnoreCase(self): # check defaults self.assertEqual(cmd.get_setting_int('ignore_case'), 1) self.assertEqual(cmd.get_setting_int('ignore_case_chain'), 0) # data natoms = 10 cmd.fragment('ala', 'm1') cmd.copy('m2', 'm1') cmd.alter('m1', 'chain, segi = "C", "S"') cmd.alter('m2', 'chain, segi = "c", "s"') cmd.alter('m2', 'resn, name = resn.lower(), name.lower()') self.assertEqual(cmd.count_atoms('chain C'), natoms) self.assertEqual(cmd.count_atoms('segi S'), natoms) self.assertEqual(cmd.count_atoms('chain c'), natoms) self.assertEqual(cmd.count_atoms('segi s'), natoms) self.assertEqual(cmd.count_atoms('resn ALA'), natoms * 2) self.assertEqual(cmd.count_atoms('resn ala'), natoms * 2) self.assertEqual(cmd.count_atoms('name CA'), 2) self.assertEqual(cmd.count_atoms('name ca'), 2) cmd.set('ignore_case_chain') self.assertEqual(cmd.count_atoms('chain C'), natoms * 2) self.assertEqual(cmd.count_atoms('segi S'), natoms * 2) self.assertEqual(cmd.count_atoms('chain c'), natoms * 2) self.assertEqual(cmd.count_atoms('segi s'), natoms * 2) cmd.set('ignore_case', 0) self.assertEqual(cmd.count_atoms('resn ALA'), natoms) self.assertEqual(cmd.count_atoms('resn ala'), natoms) self.assertEqual(cmd.count_atoms('name CA'), 1) self.assertEqual(cmd.count_atoms('name ca'), 1)
def testRock(self): cmd.rock(1) self.assertTrue(cmd.get_setting_int('rock')) cmd.rock(0) self.assertFalse(cmd.get_setting_int('rock')) cmd.rock(-1) self.assertTrue(cmd.get_setting_int('rock')) cmd.rock(-1) self.assertFalse(cmd.get_setting_int('rock'))
def testGetSettingInt(self): cmd.set('light_count', 4) v = cmd.get_setting_int('light_count') self.assertTrue(isinstance(v, int)) self.assertEqual(v, 4) # float as int gets floored cmd.set('sphere_scale', 3.7) v = cmd.get_setting_int('sphere_scale') self.assertTrue(isinstance(v, int)) self.assertEqual(v, 3)
def testStereo(self): for (k, v) in cmd.stereo_dict.items(): if v < 1: continue cmd.stereo(k) self.assertTrue(cmd.get_setting_int('stereo')) self.assertEqual(cmd.get_setting_int('stereo_mode'), v) cmd.stereo('off') self.assertFalse(cmd.get_setting_int('stereo')) cmd.stereo('on') self.assertTrue(cmd.get_setting_int('stereo')) shift = cmd.get_setting_float('stereo_shift') cmd.stereo('swap') self.assertAlmostEqual(cmd.get_setting_float('stereo_shift'), -shift)
def testStereo(self): for (k,v) in cmd.stereo_dict.items(): if v < 1: continue cmd.stereo(k) self.assertTrue(cmd.get_setting_int('stereo')) self.assertEqual(cmd.get_setting_int('stereo_mode'), v) cmd.stereo('off') self.assertFalse(cmd.get_setting_int('stereo')) cmd.stereo('on') self.assertTrue(cmd.get_setting_int('stereo')) shift = cmd.get_setting_float('stereo_shift') cmd.stereo('swap') self.assertAlmostEqual(cmd.get_setting_float('stereo_shift'), -shift)
def __init__(self, _self=cmd): cmd.unpick() Wizard.__init__(self, _self) self.status = 0 # 0 no atoms selections, 1 atom selected self.error = None self.object_name = None # mode selection subsystem self.mode = default_mode self.modes = [ 'polar', 'heavy', 'neigh', 'pairs', ] self.mode_name = { 'polar': 'Polar Neighbors', 'heavy': 'Heavy Neighbors', 'neigh': 'Neighbors', 'pairs': 'Pairwise Distances', } smm = [] smm.append([2, 'Measurement Mode', '']) for a in self.modes: smm.append([ 1, self.mode_name[a], 'cmd.get_wizard().set_mode("' + a + '")' ]) self.menu['mode'] = smm # overwrite mode selection subsystem self.object_mode = default_object_mode self.object_modes = [ 'overwr', 'append', ] self.object_mode_name = { 'overwr': 'Replace Previous', 'append': 'Create New', } smm = [] smm.append([2, 'New Distances?', '']) for a in self.object_modes: smm.append([ 1, self.object_mode_name[a], 'cmd.get_wizard().set_object_mode("' + a + '")' ]) self.menu['object_mode'] = smm self.selection_mode = cmd.get_setting_int("mouse_selection_mode") cmd.set("mouse_selection_mode", 0) # set selection mode to atomic cmd.deselect() # disable the active selection (if any)
def cubes(selection='all', name='', state=0, scale=0.5, atomcolors=1, _func=cgo_cube): ''' DESCRIPTION Create a cube representation CGO for all atoms in selection. ARGUMENTS selection = string: atom selection {default: all} name = string: name of CGO object to create state = int: object state {default: 0 = all states} scale = float: scaling factor. If scale=1.0, the corners of the cube will be on the VDW surface of the atom {default: 0.5} atomcolors = 0/1: use atom colors (cannot be changed), otherwise apply one color to the object (can be changed with color command) {default: 1} SEE ALSO tetrahedra ''' if not name: name = cmd.get_unused_name('cubes') state, scale, atomcolors = int(state), float(scale), int(atomcolors) if state < 0: state = cmd.get_setting_int('state') states = [state] if state else list( range(1, cmd.count_states(selection) + 1)) def callback(x, y, z, vdw, color): if atomcolors: obj.append(cgo.COLOR) obj.extend(cmd.get_color_tuple(color)) obj.extend(_func(x, y, z, vdw * scale)) space = {'xcb': callback} for state in states: obj = [] cmd.iterate_state(state, selection, 'xcb(x, y, z, vdw, color)', space=space) cmd.load_cgo(obj, name, state) if not atomcolors: cmd.color('auto', name)
def test_performance(self): pymol.util.performance(0) self.assertEqual(1, cmd.get_setting_int('surface_quality')) self.assertEqual(1, cmd.get_setting_int('depth_cue')) pymol.util.performance(33) self.assertEqual(0, cmd.get_setting_int('surface_quality')) self.assertEqual(1, cmd.get_setting_int('depth_cue')) pymol.util.performance(66) self.assertEqual(0, cmd.get_setting_int('surface_quality')) self.assertEqual(0, cmd.get_setting_int('depth_cue')) pymol.util.performance(100) self.assertEqual(-1, cmd.get_setting_int('surface_quality')) self.assertEqual(0, cmd.get_setting_int('depth_cue'))
def test(self): if cmd.get_setting_int('suspend_undo'): self.skipTest("need suspend_undo=0") cmd.fragment('gly', 'm1') cmd.create('m2', 'm1') cmd.edit('m1 & name N') cmd.replace('I', 1, 1) self.assertEqual(cmd.count_atoms('m1 in m2'), 5) cmd.undo() self.assertEqual(cmd.count_atoms('m1 in m2'), 7)
def __init__(self,_self=cmd): Wizard.__init__(self,_self) self.memory = 0 self.n_pair = 0 self.status = 0 # 0 no atoms selections, 1 atom selected self.message = None self.selection_mode = cmd.get_setting_int("mouse_selection_mode") cmd.set("mouse_selection_mode",0) # set selection mode to atomic cmd.deselect() # disable the active selection (if any)
def __init__(self, _self=cmd): Wizard.__init__(self, _self) self.memory = 0 self.n_pair = 0 self.status = 0 # 0 no atoms selections, 1 atom selected self.message = None self.selection_mode = cmd.get_setting_int("mouse_selection_mode") cmd.set("mouse_selection_mode", 0) # set selection mode to atomic cmd.deselect() # disable the active selection (if any)
def __init__(self, selection='?pk1', _self=cmd): Wizard.__init__(self, _self) self.selection_mode = cmd.get_setting_int("mouse_selection_mode") _self.set("mouse_selection_mode", 0) self.identifiers = None self.cursor = 0 self.label = "" self.selename = _self.get_unused_name('_labeledit') self.sele = '?' + self.selename self.do_select(selection) for (a, text) in [ ('color', 'Label Color'), ('bg_color', 'Background Color'), ]: m = self.menu[a] = [[2, text, '']] for color in [ 'default', 'front', 'back', ]: m.append([ 1, color, 'cmd.get_wizard().set_' + a + '("' + color + '")' ]) m += [ [0, '', ''], [ 1, 'all colors', lambda s='label_' + a: menu.by_rep_sub( self.cmd, 'labels', s, self.sele) ], ] self.menu['size'] = [[2, 'Label Size', '']] + [[ 1, str(size), 'cmd.get_wizard().set_size(%d)' % size ] for size in (10, 14, 18, 24, 36)] self.menu['bg_transparency'] = [ [2, 'Background Transparency', ''], ] + [[ 1, '%d%%' % (i), 'cmd.get_wizard().set_bg_transparency(%f)' % (i / 100.) ] for i in (0, 20, 40, 60, 80)] self.menu['connector'] = [ [2, 'Connector', ''], [1, 'Show', 'cmd.get_wizard().set_connector(1)'], [1, 'Hide', 'cmd.get_wizard().set_connector(0)'], ]
def __init__(self,_self=cmd): cmd.unpick(); Wizard.__init__(self,_self) self.status = 0 # 0 no atoms selections, 1 atom selected self.error = None self.object_name = None # mode selection subsystem self.mode = default_mode self.modes = [ 'polar', 'heavy', 'neigh', 'pairs', ] self.mode_name = { 'polar':'Polar Neighbors', 'heavy':'Heavy Neighbors', 'neigh':'Neighbors', 'pairs':'Pairwise Distances', } smm = [] smm.append([ 2, 'Measurement Mode', '' ]) for a in self.modes: smm.append([ 1, self.mode_name[a], 'cmd.get_wizard().set_mode("'+a+'")']) self.menu['mode']=smm # overwrite mode selection subsystem self.object_mode=default_object_mode self.object_modes = [ 'overwr', 'append', ] self.object_mode_name = { 'overwr':'Replace Previous', 'append':'Create New', } smm = [] smm.append([ 2, 'New Distances?', '' ]) for a in self.object_modes: smm.append([ 1, self.object_mode_name[a], 'cmd.get_wizard().set_object_mode("'+a+'")']) self.menu['object_mode']=smm self.selection_mode = cmd.get_setting_int("mouse_selection_mode") cmd.set("mouse_selection_mode",0) # set selection mode to atomic cmd.deselect() # disable the active selection (if any)
def get_object_state(name): ''' DESCRIPTION Returns the effective object state. ''' states = cmd.count_states(name) if states < 2 and cmd.get_setting_boolean('static_singletons'): return 1 state = cmd.get_setting_int('state', name) if state > states: print(' Error: Invalid state %d for object %s' % (state, name)) raise CmdException return state
def testAtomLevelSettingsOnRemove2(self): if cmd.get_setting_int('suspend_undo'): self.skipTest("need suspend_undo=0") cmd.load(self.datafile("1molecule.mae")) cmd.load(self.datafile("1molecule.mae")) cmd.label("index 10", "'Test Label'") plv = [ 5., 0., 0.] cmd.alter("index 10", "s.label_placement_offset = %s" % plv) cmd.remove("index 10") cmd.undo() stored.offset = None cmd.iterate("index 10", "stored.offset = list(s.label_placement_offset)") self.assertEqual(stored.offset, plv)
def cubes(selection='all', name='', state=0, scale=0.5, atomcolors=1, _func=cgo_cube): ''' DESCRIPTION Create a cube representation CGO for all atoms in selection. ARGUMENTS selection = string: atom selection {default: all} name = string: name of CGO object to create state = int: object state {default: 0 = all states} scale = float: scaling factor. If scale=1.0, the corners of the cube will be on the VDW surface of the atom {default: 0.5} atomcolors = 0/1: use atom colors (cannot be changed), otherwise apply one color to the object (can be changed with color command) {default: 1} SEE ALSO tetrahedra ''' if not name: name = cmd.get_unused_name('cubes') state, scale, atomcolors = int(state), float(scale), int(atomcolors) if state < 0: state = cmd.get_setting_int('state') states = [state] if state else range(1, cmd.count_states(selection) + 1) def callback(x, y, z, vdw, color): if atomcolors: obj.append(cgo.COLOR) obj.extend(cmd.get_color_tuple(color)) obj.extend(_func(x, y, z, vdw * scale)) space = {'xcb': callback} for state in states: obj = [] cmd.iterate_state(state, selection, 'xcb(x, y, z, vdw, color)', space=space) cmd.load_cgo(obj, name, state) if not atomcolors: cmd.color('auto', name)
def test(self): if not (pymol.invocation.options.no_gui or cmd.get_setting_int('use_shaders')): self.skipTest('no ray or shaders') self.ambientOnly() cmd.set('valence', 0) cmd.viewport(350, 200) cmd.fragment('ile') cmd.remove('hydro') cmd.show_as('sticks') cmd.orient() cmd.set('stick_ball', 0) img1 = self.get_imagearray() cmd.set('stick_ball', 1) img2 = self.get_imagearray() self.assertImageEqual(img1, img2, count=10)
def get_panel(self): ''' Updates right-side panel to set/modify wizard-related actions Overrides method from Wizard class :return: List of widgets available for the wizard :rtype: List of [(widget-type), (widget text), (menu/command)] to be displayed on panel ''' cmd = self.cmd if int(cmd.get_setting_int("mouse_selection_mode") != 1): cmd.set("mouse_selection_mode", 1) label = 'Mutate to ' + self.mode return [ [1, 'Mutagenesis', ''], [3, label, 'mode'], [3, 'Auto Center: %s' % self._auto_center, 'auto_center'], [3, self._rep_name[self.rep], 'rep'], [2, 'Apply', 'cmd.get_wizard().apply()'], [2, 'Clear', 'cmd.get_wizard().clear()'], [2, 'Done', 'cmd.set_wizard()'], ]
def __init__(self, _self=cmd): cmd.unpick(); Wizard.__init__(self, _self) self.mouse_selection_mode = cmd.get_setting_int('mouse_selection_mode') cmd.set('mouse_selection_mode',0) # set selection mode to atomic cmd.deselect() # disable the active selection (if any) self.error = None self.selection_mode = 1 if self.mouse_selection_mode == 6 else 0 self.selection_modes = [ 'Residues', 'C-alphas', ] smm = [] smm.append([ 2, 'Selection Mode', '' ]) for i, label in enumerate(self.selection_modes): smm.append([1, label, 'cmd.get_wizard().set_mode(%d)' % i]) self.menu['selection_mode'] = smm self.name = None
def __init__(self, _self=cmd): cmd.unpick() Wizard.__init__(self, _self) self.mouse_selection_mode = cmd.get_setting_int('mouse_selection_mode') cmd.set('mouse_selection_mode', 0) # set selection mode to atomic cmd.deselect() # disable the active selection (if any) self.error = None self.selection_mode = 1 if self.mouse_selection_mode == 6 else 0 self.selection_modes = [ 'Residues', 'C-alphas', ] smm = [] smm.append([2, 'Selection Mode', '']) for i, label in enumerate(self.selection_modes): smm.append([1, label, 'cmd.get_wizard().set_mode(%d)' % i]) self.menu['selection_mode'] = smm self.name = None
def __init__(self,_self=cmd): Wizard.__init__(self,_self) cmd=self.cmd if self.cmd.get_movie_length() > 0: raise pymol.wizarding.WizardError('Mutagenesis Wizard cannot be used with Movie') cmd.unpick() self.stored = pymol.Scratch_Storage() self.space = {'stored': self.stored} self.bump_scores = [] self.dep = default_dep self.ind_library = io.pkl.fromFile(os.environ['PYMOL_DATA']+ "/chempy/sidechains/sc_bb_ind.pkl") self.load_library() self.status = 0 # 0 no selection, 1 mutagenizing self.bump_check = 1 self.auto_center = 1 self.error = None self.object_name = None self.modes = [ 'current' ] self.mode = default_mode self.rep = default_rep self.hyd = default_hyd self.n_cap = default_n_cap self.c_cap = default_c_cap residues = list(self.ind_library.keys()) # could extent with additional fragments manually as below residues.extend(['GLY','ALA']) residues.extend(['HID','HIE','HIP']) residues.extend(['ARGN','LYSN','ASPH','GLUH']) residues.sort() res_copy = deepcopy(residues) for a in res_copy: residues.append('NT_'+a) residues.append('CT_'+a) self.modes.extend(residues) self.mode_label={} for a in self.modes: self.mode_label[a] = ""+a self.mode_label['current']="No Mutant" self.selection_mode = cmd.get_setting_int("mouse_selection_mode") cmd.set("mouse_selection_mode",1) smm = [] smm.append([ 2, 'Mutant', '' ]) smm.append([ 1, 'No change', 'cmd.get_wizard().set_mode("current")' ]) # smm.append([ 1, 'N-Term', [] ]) # smm.append([ 1, 'C-Term', [] ]) smm.append([ 0, '', '' ]) for a in self.modes: if a == 'current': pass elif a[0:3]=='NT_': pass # smm[2][2].append([ 1, self.mode_label[a[3:]], 'cmd.get_wizard().set_mode("'+a+'")']) elif a[0:3]=='CT_': pass # smm[3][2].append([ 1, self.mode_label[a[3:]], 'cmd.get_wizard().set_mode("'+a+'")']) else: smm.append([ 1, self.mode_label[a], 'cmd.get_wizard().set_mode("'+a+'")']) # group arg, lys, his, glu, asp for lst in [ smm ]: # [ smm, smm[2][2], smm[3][2] ]: for a in 'ARG','LYS','HID','GLU','ASP': ix = 0 start = 0 stop = 0 for b in lst: if start==0: if b[1][0:]==a: start = ix stop = ix + 1 elif b[1][0:3]==a[0:3] or ( b[1][0:2]==a[0:2] and a[0:2]=='HI' ): stop = ix + 1 ix = ix + 1 if start!=0 and stop!=0: slice = lst[start:stop] if a != 'HID': slice2 = [slice[0] ] + [ [0,'',''] ] + slice[1:] lst[start:stop] = [ [1, self.mode_label[a] + "... " , slice2 ] ] else: slice2 = [ slice[3] ] + [ [0,'',''] ] + slice[0:3] lst[start:stop] = [ [1, self.mode_label['HIS']+ "... ", slice2 ] ] self.menu['mode']=smm self.reps = [ 'lines', 'sticks', 'spheres', 'dots' ] self.rep_name = { 'lines' : "Show Lines", 'sticks' : "Show Sticks", 'spheres' : "Show Spheres", 'dots' : "Show Dots", } self.dep_name = { 'dep' : "Backbone Depen. Rotamers", 'ind' : "Backbone Indep. Rotamers" } self.hyd_name = { 'auto' : "Hydrogens: Current", 'keep' : "Hydrogens: Add & Retain", # 'polar' : "Polar Hydrogens", 'none' : "Hydrogens: Remove", } self.hyds = [ 'auto', 'keep', 'none' ] self.n_cap_name = { 'none' : 'Open', 'posi' : 'NH3+', 'acet' : 'Acetyl', } self.n_caps = [ 'none', 'posi', 'acet' ] self.c_cap_name = { 'none' : 'Open', 'nega' : 'COO-', 'amin' : 'Amine', 'nmet' : 'N-methyl', } self.c_caps = [ 'none', 'nega', 'amin', 'nmet' ] smm = [] smm.append([ 2, 'N-Cap', '' ]) for a in self.n_caps: smm.append([ 1, self.n_cap_name[a], 'cmd.get_wizard().set_n_cap("'+a+'")']) self.menu['n_cap']=smm smm = [] smm.append([ 2, 'C-Cap', '' ]) for a in self.c_caps: smm.append([ 1, self.c_cap_name[a], 'cmd.get_wizard().set_c_cap("'+a+'")']) self.menu['c_cap']=smm smm = [] smm.append([ 2, 'Hydrogens', '' ]) for a in self.hyds: smm.append([ 1, self.hyd_name[a], 'cmd.get_wizard().set_hyd("'+a+'")']) self.menu['hyd']=smm smm = [] smm.append([ 2, 'Representation', '' ]) for a in self.reps: smm.append([ 1, self.rep_name[a], 'cmd.get_wizard().set_rep("'+a+'")']) self.menu['rep']=smm self.deps = [ 'dep', 'ind' ] smm = [] smm.append([ 2, 'Rotamers', '' ]) for a in self.deps: smm.append([ 1, self.dep_name[a], 'cmd.get_wizard().set_dep("'+a+'")']) self.menu['dep']=smm if 'pk1' in cmd.get_names('selections'): cmd.select(src_sele,"(byres pk1)") cmd.unpick() cmd.enable(src_sele) self.status = 1 self.error = None self.do_library() cmd.refresh_wizard()
def testSelect(self): cmd.fragment("gly", "m1") NC = 2 # auto_number_selections=0 cmd.select("elem C") self.assertEquals(NC, cmd.count_atoms("sele")) self.assertEquals(0, cmd.get_setting_int("sel_counter")) # auto_number_selections=1 cmd.set('auto_number_selections', 1) cmd.set('sel_counter', 3) cmd.select("elem C") self.assertEquals(NC, cmd.count_atoms("sel04")) self.assertEquals(4, cmd.get_setting_int("sel_counter")) cmd.set('auto_number_selections', 1) cmd.select(None, "elem C") self.assertEquals(NC, cmd.count_atoms("sel05")) self.assertEquals(5, cmd.get_setting_int("sel_counter")) # name=None always numbers the selection cmd.set('auto_number_selections', 0) cmd.select(None, "elem C") self.assertEquals(NC, cmd.count_atoms("sel06")) self.assertEquals(6, cmd.get_setting_int("sel_counter")) # default cmd.select("foo", "elem C") self.assertEquals(NC, cmd.count_atoms("foo")) self.assertEquals(["foo"], cmd.get_names("selections", enabled_only=1)) # merge with non-existing, enable=0 cmd.delete('foo') cmd.select("foo", "elem C", 0, merge=1) self.assertEquals(NC, cmd.count_atoms("foo")) self.assertEquals([], cmd.get_names("selections", enabled_only=1)) # merge, enable=1 cmd.select("foo", "elem N", 1) self.assertEquals(1, cmd.count_atoms("foo")) self.assertEquals(["foo"], cmd.get_names("selections", enabled_only=1)) cmd.select("foo", "elem C", -1, merge=1) self.assertEquals(NC + 1, cmd.count_atoms("foo")) self.assertEquals(["foo"], cmd.get_names("selections", enabled_only=1)) cmd.select("foo", "elem O", -1, merge=2) self.assertEquals(NC + 2, cmd.count_atoms("foo")) self.assertEquals(["foo"], cmd.get_names("selections", enabled_only=1)) # merge, enable=0 cmd.select("foo", "elem N", 0) self.assertEquals(1, cmd.count_atoms("foo")) self.assertEquals([], cmd.get_names("selections", enabled_only=1)) cmd.select("foo", "elem C", -1, merge=1) self.assertEquals(NC + 1, cmd.count_atoms("foo")) self.assertEquals([], cmd.get_names("selections", enabled_only=1)) cmd.select("foo", "elem O", -1, merge=2) self.assertEquals(1, cmd.count_atoms("foo")) self.assertEquals([], cmd.get_names("selections", enabled_only=1)) # state cmd.create('m1', 'm1 & elem C', 1, 2) self.assertEquals(7, cmd.select('present')) self.assertEquals(7, cmd.select('present', state=1)) self.assertEquals(2, cmd.select('present', state=2)) self.assertEquals(0, cmd.select('present', state=3)) # domain cmd.select("foo", "elem C") cmd.select("bar", "name CA+N+O", domain="foo") self.assertEquals(1, cmd.count_atoms("bar"))
def read_moestr(contents, object, state=0, finish=1, discrete=1, quiet=1, zoom=-1, _self=cmd): moestr = contents name = object import sys if sys.version_info[0] > 2 and isinstance(moestr, bytes): moestr = moestr.decode() cmd = _self mr = MOEReader() mr.appendFromStr(moestr) split_chains = cmd.get_setting_int("moe_separate_chains") cmd.group(name) if hasattr(mr, 'system'): have_valences = 0 chain_count = 0 cmd.set_color("_aseg0", [1.0, 1.0, 1.0]) aseg_color = cmd.get_color_index("_aseg0") aseg_flag = 0 aseg_rep = {} model = Indexed() molecule = mr.system['molecule'] if 'atoms' in molecule: n_atom = molecule['atoms'] model.atom = [Atom() for x in range(n_atom)] residues = {} chains = {} for columns, data in molecule['attr']: for row in data: cur_atom = None for key, value in zip(columns, row): key = key[0] if key == 'ID': ID = value else: aProp = _atom_prop_map.get(key, None) if aProp != None: setattr(model.atom[ID - 1], aProp, value) else: xyz = _atom_coord_map.get(key, None) if xyz != None: coord = list(model.atom[ID - 1].coord) coord[xyz] = value model.atom[ID - 1].coord = coord elif key in _atom_vis_map: atom = model.atom[ID - 1] if hasattr(atom, 'visible'): visible = atom.visible else: visible = _default_visible if key == 'aBondLook': if value == 'cylinder': atom.visible = 0x00000001 | visible elif value == 'line': atom.visible = 0x00000080 | visible elif value == 'none': atom.visible = -129 & Visible # 0xFFFFFF7F elif key == 'aNucleusLook': if value == 'sphere': atom.visible = 0x00000002 | visible elif value == 'small-sphere': # need to set sphere_scale=0.2 for these atoms atom.visible = 0x00000002 | visible atom.sphere_scale = 0.2 elif value == 'point': # nonbonded atom.visible = 0x00000800 | visible elif value == 'none': atom.visible = -2067 & visible # 0xFFFFF7ED elif key == 'aHidden': atom.visible = 0 atom.hidden = 1 if hasattr( atom, 'hidden' ): # be sure that hidden atoms aren't shown atom.visible = 0 elif key in _atom_color_map: if key == 'aRGB': model.atom[ID - 1].trgb = value elif key == 'aColorBy': model.atom[ID - 1].aColorBy = value elif key in _atom_label_map: atom = model.atom[ID - 1] if hasattr(atom, 'label_dict'): atom.label_dict[key] = None else: atom.label_dict = {key: None} elif key in _residue_prop_map: resi_dict = residues.get(ID, {}) resi_dict[key] = value residues[ID] = resi_dict elif key in _chain_prop_map: chain_dict = chains.get(ID, {}) if ID not in chains: chain_count = chain_count + 1 chain_dict['count'] = chain_count chain_dict[key] = value chains[ID] = chain_dict chn_keys = list(chains.keys()) chn_keys.sort() res_keys = list(residues.keys()) res_keys.sort() # map chain properties onto residues chn_resi = 0 ch_colors = copy.deepcopy(_ch_colors) unique_chain_names = {} for chn_idx in chn_keys: chain_dict = chains[chn_idx] cName = make_valid_name(chain_dict.get('cName', '')) segi = cName[0:4] chain = cName[-1:] if not len(cName): if 'count' in chain_dict: cName = "chain_" + str(chain_dict['count']) else: cName = str(chn_idx) if cName not in unique_chain_names: unique_chain_names[cName] = cName else: cnt = 2 while (cName + "_" + str(cnt)) in unique_chain_names: cnt = cnt + 1 newCName = cName + "_" + str(cnt) unique_chain_names[newCName] = cName cName = newCName chain_dict['chain_color'] = ch_colors[0] ch_colors = ch_colors[1:] + [ch_colors[0]] cResCount = chain_dict.get('cResidueCount', 0) for res_idx in range(chn_resi, chn_resi + cResCount): resi_dict = residues[res_keys[res_idx]] resi_dict['chain'] = chain resi_dict['segi'] = segi resi_dict['cName'] = cName resi_dict['chain_dict'] = chain_dict chn_resi = chn_resi + cResCount # map residue properties onto atoms res_atom = 0 for res_idx in res_keys: resi_dict = residues[res_idx] rRibbonMode = resi_dict.get('rRibbonMode', 'none') rAtomCount = resi_dict['rAtomCount'] rType = resi_dict.get('rType', '') if rAtomCount > 0: for at_idx in range(res_atom, res_atom + rAtomCount): atom = model.atom[at_idx] setattr( atom, 'resi', string.strip( str(resi_dict.get('rUID', '')) + resi_dict.get('rINS', ''))) setattr(atom, 'resn', resi_dict.get('rName', '')) setattr(atom, 'chain', resi_dict.get('chain', '')) setattr(atom, 'segi', resi_dict.get('segi', '')) setattr(atom, 'custom', resi_dict.get('cName', '')) # add labels if hasattr(atom, 'label_dict'): label = '' label_dict = atom.label_dict if 'aLabelElement' in label_dict: label = atom.symbol if 'aLabelRes' in label_dict: if len(label): label = label + "," label = label + atom.resn + "_" + atom.resi if 'aLabelName' in label_dict: if len(label): label = label + "." label = label + atom.name atom.label = label if rType not in ['none', 'heme']: atom.hetatm = 0 # all normal atoms else: atom.flags = 0x02000000 # hetatom or ligand -- ignore when surfacing if rRibbonMode != 'none': if hasattr(atom, 'visible'): visible = atom.visible else: visible = _default_visible rRibbonColorBy = resi_dict['rRibbonColorBy'] repeat = 1 while repeat: repeat = 0 if rRibbonColorBy in ['rgb', 'r:rgb' ]: # handled automatically pass elif rRibbonColorBy == 'chain': chain_dict = resi_dict['chain_dict'] cColorBy = chain_dict['cColorBy'] if cColorBy == 'rgb': cColorBy = 'c:rgb' rRibbonColorBy = cColorBy repeat = 1 rRibbon_color = 0 rRibbon_trgb = 0xFFFFFF # default -- white # now color ribbon if rRibbonColorBy == 'r:rgb': rRibbon_trgb = resi_dict.get('rRGB', 0xFFFFFF) elif rRibbonColorBy == 'rgb': rRibbon_trgb = resi_dict.get( 'rRibbonRGB', 0xFFFFFF) elif rRibbonColorBy == 'c:rgb': chain_dict = resi_dict['chain_dict'] rRibbon_trgb = chain_dict.get('cRGB', 0xFFFFFF) elif rRibbonColorBy == 'r:aseg': rRibbon_trgb = None rRibbon_color = aseg_color aseg_flag = 1 elif rRibbonColorBy == 'tempfactor': pass # TO DO elif rRibbonColorBy == 'c:number': # per chain colors rRibbon_trgb = chain_dict['chain_color'] if rRibbonMode in ['line', 'trace']: atom.visible = 0x00000040 | visible # PyMOL ribbon if rRibbon_trgb != None: atom.ribbon_trgb = rRibbon_trgb else: atom.ribbon_color = rRibbon_color aseg_rep['ribbon'] = 1 else: atom.visible = 0x00000020 | visible # PyMOL cartoon if rRibbon_trgb != None: atom.cartoon_trgb = rRibbon_trgb else: atom.cartoon_color = rRibbon_color aseg_rep['cartoon'] = 1 if hasattr(atom, 'label'): if hasattr(atom, 'visible'): visible = atom.visible else: visible = _default_visible atom.visible = 0x00000028 | visible # labels if not hasattr(atom, 'aColorBy'): atom.aColorBy = 'element' if hasattr(atom, 'aColorBy'): aColorBy = atom.aColorBy repeat = 1 while repeat: repeat = 0 if aColorBy == 'ribbon': aColorBy = resi_dict.get('rRibbonColorBy') if aColorBy == 'rgb': aColorBy = 'rib:rgb' else: repeat = 1 # TO DO still need to handle "cartoon_color", "ribbon_color" elif aColorBy == 'element': if hasattr(atom, 'trgb'): del atom.trgb elif aColorBy in ['rgb', 'a:rgb' ]: # handled automatically pass elif aColorBy == 'residue': rColorBy = resi_dict.get('rColorBy') if rColorBy == 'rgb': rColorBy = 'r:rgb' aColorBy = rColorBy repeat = 1 elif aColorBy == 'chain': chain_dict = resi_dict['chain_dict'] cColorBy = chain_dict['cColorBy'] if cColorBy == 'rgb': cColorBy = 'c:rgb' aColorBy = cColorBy repeat = 1 # now color atom... if aColorBy == 'r:rgb': atom.trgb = resi_dict.get('rRGB', 0xFFFFFF) elif aColorBy == 'rib:rgb': atom.trgb = resi_dict.get('rRibbonRGB', 0xFFFFFF) elif aColorBy == 'c:rgb': chain_dict = resi_dict['chain_dict'] atom.trgb = chain_dict.get('cRGB', 0xFFFFFF) elif aColorBy == 'r:aseg': pass # TO DO elif aColorBy == 'tempfactor': pass # TO DO elif aColorBy == 'c:number': # per chain colors atom.trgb = chain_dict['chain_color'] res_atom = res_atom + rAtomCount bond_list = molecule.get('bond', []) for bond in bond_list: new_bond = Bond() new_bond.index = [bond[0] - 1, bond[1] - 1] if len(bond) > 2: new_bond.order = bond[2] if bond[2] == 2: # work around .MOE bug with triple bonds if model.atom[new_bond.index[0]].hybridization == 'sp': if model.atom[new_bond.index[1]].hybridization == 'sp': new_bond.order = 3 have_valences = 1 model.bond.append(new_bond) if 'ViewOrientationY' in mr.system: vy = mr.system['ViewOrientationY'] vz = mr.system['ViewOrientationZ'] pos = mr.system['ViewLookAt'] scale = mr.system['ViewScale'] vx = cpv.cross_product(vy, vz) m = [cpv.normalize(vx), cpv.normalize(vy), cpv.normalize(vz)] m = cpv.transpose(m) asp_rat = 0.8 # MOE default (versus 0.75 for PyMOL) cmd.set("field_of_view", 25.0) fov = float(cmd.get("field_of_view")) window_height = scale * asp_rat dist = (0.5 * window_height) / math.atan(3.1415 * (0.5 * fov) / 180.0) new_view = tuple(m[0] + m[1] + m[2] + [0.0, 0.0, -dist] + pos + [dist * 0.5, dist * 1.5, 0.0]) cmd.set_view(new_view) zoom = 0 cmd.set("auto_color", 0) cmd.set_color("carbon", [0.5, 0.5, 0.5]) # default MOE grey obj_name = name + ".system" if split_chains < 0: # by default, don't split chains if over 50 objects would be created if len(unique_chain_names) > 50: split_chains = 0 if not split_chains: cmd.load_model(model, obj_name, state=state, finish=finish, discrete=discrete, quiet=quiet, zoom=zoom) obj_name_list = [obj_name] else: cmd.load_model(model, obj_name, state=state, finish=finish, discrete=discrete, quiet=1, zoom=zoom) obj_name_list = [] system_name = obj_name for chain in unique_chain_names.keys(): obj_name = name + "." + chain obj_name_list.append(obj_name) cmd.select("_moe_ext_tmp", "custom %s" % chain, domain=system_name) cmd.extract(obj_name, "_moe_ext_tmp", quiet=quiet, zoom=0) # cmd.extract(obj_name,system_name+" and text_type %s"%chain,quiet=quiet) cmd.delete("_moe_ext_tmp") if not cmd.count_atoms(system_name): cmd.delete(system_name) else: obj_name_list.append(system_name) cmd.order(name + ".*", sort=1) for obj_name in obj_name_list: cmd.set("stick_radius", 0.1, obj_name) cmd.set("line_width", 2.0, obj_name) cmd.set("label_color", "white", obj_name) cmd.set("nonbonded_size", 0.05, obj_name) # temporary workaround... if have_valences: # if this MOE file has valences, then show em! cmd.set("valence", 1, obj_name) cmd.set("stick_valence_scale", 1.25, obj_name) if aseg_flag: cmd.dss(obj_name) if 'cartoon' in aseg_rep: cmd.set("cartoon_color", "red", obj_name + " and cartoon_color _aseg0 and ss h") cmd.set("cartoon_color", "yellow", obj_name + " and cartoon_color _aseg0 and ss s") cmd.set( "cartoon_color", "cyan", obj_name + " and cartoon_color _aseg0 and not ss h+s") if 'ribbon' in aseg_rep: cmd.set("ribbon_color", "red", obj_name + " and ribbon_color _aseg0 and ss h" ) # need selection op ribbon_color cmd.set("ribbon_color", "yellow", obj_name + " and ribbon_color _aseg0 and ss s") cmd.set( "ribbon_color", "cyan", obj_name + " and ribbon_color _aseg0 and not ss h+s") if 'ViewZFront' in mr.system: moe_front = mr.system['ViewZFront'] moe_width = mr.system['ViewZWidth'] extent = cmd.get_extent( name) # will this work with groups? TO DO: check! dx = (extent[0][0] - extent[1][0]) dy = (extent[0][1] - extent[1][1]) dz = (extent[0][2] - extent[1][2]) half_width = 0.5 * math.sqrt(dx * dx + dy * dy + dz * dz) cmd.clip("atoms", 0.0, name) cur_view = cmd.get_view() center = (cur_view[-3] + cur_view[-2]) * 0.5 # center of clipping slab front = center - half_width back = center + half_width width = half_width * 2 new_view = tuple( list(cur_view[0:15]) + [ front + width * moe_front, front + width * (moe_front + moe_width), 0.0 ]) cmd.set_view(new_view) if 'graphics' in mr.system: cgo_cnt = 1 lab_cnt = 1 unique_cgo_names = {} for graphics in mr.system['graphics']: cgo = [] for gvertex in graphics.get('gvertex', []): vrt = gvertex[0] seg_list = gvertex[1]['seg'] idx = gvertex[1]['idx'] len_idx = len(idx) if not cmd.is_list(seg_list): seg_list = [seg_list] * (len_idx / seg_list) last_seg = None ix_start = 0 for seg in seg_list: if seg != last_seg: if last_seg != None: cgo.append(END) if seg == 3: cgo.extend([BEGIN, TRIANGLES]) elif seg == 2: cgo.extend([BEGIN, LINES]) elif seg == 1: cgo.extend([BEGIN, POINTS]) ix_stop = seg + ix_start if seg == 3: for s in idx[ix_start:ix_stop]: v = vrt[s - 1] cgo.extend([ COLOR, (0xFF & (v[0] >> 16)) / 255.0, (0xFF & (v[0] >> 8)) / 255.0, (0xFF & (v[0])) / 255.0 ]) if len(v) > 4: cgo.extend([NORMAL, v[4], v[5], v[6]]) cgo.extend([VERTEX, v[1], v[2], v[3]]) elif seg == 2: for s in idx[ix_start:ix_stop]: v = vrt[s - 1] cgo.extend([ COLOR, (0xFF & (v[0] >> 16)) / 255.0, (0xFF & (v[0] >> 8)) / 255.0, (0xFF & (v[0])) / 255.0 ]) if len(v) > 4: cgo.extend([NORMAL, v[4], v[5], v[6]]) cgo.extend([VERTEX, v[1], v[2], v[3]]) elif seg == 1: for s in idx[ix_start:ix_stop]: v = vrt[s - 1] cgo.extend([ COLOR, (0xFF & (v[0] >> 16)) / 255.0, (0xFF & (v[0] >> 8)) / 255.0, (0xFF & (v[0])) / 255.0 ]) if len(v) > 4: cgo.extend([NORMAL, v[4], v[5], v[6]]) cgo.extend([VERTEX, v[1], v[2], v[3]]) ix_start = ix_stop last_seg = seg if last_seg != None: cgo.append(END) for gtext in graphics.get('gtext', []): lab_name = name + ".label_%02d" % lab_cnt exists = 0 for entry in gtext: exists = 1 cmd.pseudoatom(lab_name, pos=[ float(entry[1]), float(entry[2]), float(entry[3]) ], color="0x%06x" % entry[0], label=entry[4]) if exists: cmd.set('label_color', -1, lab_name) lab_cnt = lab_cnt + 1 # TO DO -- via CGO's? if len(cgo): cgo_name = name + "." + make_valid_name( graphics.get('GTitle', 'graphics')) if cgo_name not in unique_cgo_names: unique_cgo_names[cgo_name] = cgo_name else: cnt = 2 while cgo_name + "_" + str(cnt) in unique_cgo_names: cnt = cnt + 1 new_name = cgo_name + "_" + str(cnt) unique_cgo_names[new_name] = new_name cgo_name = new_name cmd.load_cgo(cgo, cgo_name, state=state, quiet=quiet, zoom=0) cgo_cnt = cgo_cnt + 1 cmd.set("two_sided_lighting", 1) # global setting... cmd.set("cgo_line_width", 2, cgo_name) if 'GTransparency' in graphics: g_trans = graphics['GTransparency'] if len(g_trans) >= 2: if g_trans[0] != 0: cmd.set('cgo_transparency', '%1.6f' % (g_trans[0] / 255.0), cgo_name) cmd.set('transparency_global_sort') if 'meter' in mr.system: meter_name = name + ".meter" exists = 0 for meter_block in mr.system['meter']: if meter_block[0][0:2] == ['type', 'atoms']: for meter in meter_block[1]: (type, atoms) = meter[0:2] arg = tuple([meter_name] + list( map(lambda x, o=name: o + " and id " + str(x - 1), atoms))) getattr(cmd, type)(*arg) exists = 1 if exists: cmd.color("green", meter_name) # print mr.system['meter'] elif hasattr(mr, 'feature'): model = Indexed() cols = mr.feature[0] rows = mr.feature[1] col = {} cnt = 0 for a in cols: col[a] = cnt cnt = cnt + 1 for row in rows: atom = Atom() atom.coord = [row[col['x']], row[col['y']], row[col['z']]] atom.vdw = row[col['r']] atom.custom = row[col['expr']] model.atom.append(atom) obj_name = name + ".feature" cmd.load_model(model, obj_name, state=state, finish=finish, discrete=discrete, quiet=quiet, zoom=zoom) rank = 1 for row in rows: cmd.color("0x%06x" % row[col['color']], obj_name + " & id %d" % (rank - 1)) rank = rank + 1 cmd.show("mesh", obj_name) cmd.set("min_mesh_spacing", 0.55, obj_name) cmd.label(obj_name, "' '+custom") cmd.set("label_color", "yellow", obj_name) else: print(dir(mr))
''' Testing setting/getting properties for different types ''' import random import unittest from pymol import cmd, testing max_threads = cmd.get_setting_int('max_threads') @testing.requires('gui', 'no_run_all', 'multicore') class TestAsyncBuilds(testing.PyMOLTestCase): @testing.foreach.product(['surface', 'cartoon'], [0, 1]) def testAsyncBuilds(self, rep, async_builds): target = "1aon" if async_builds: msg = '%s cpus' % max_threads else: msg = '1 cpu' cmd.set("async_builds", async_builds) cmd.load(self.datafile('1aon.pdb.gz'), target) for x in cmd.get_chains(): cmd.create("Chain_%s" % x, target + " & c. " + x) cmd.delete(target) with self.timing('%s' % msg): cmd.show_as(rep) cmd.draw()