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 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 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 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 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 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 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 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))
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()
'''
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()
