def pseudoatom(object='', selection='', name='PS1', resn='PSD', resi='1', chain='P',
segi='PSDO', elem='PS', vdw=-1.0, hetatm=1, b=0.0, q=0.0, color='',
label='', pos=None, state=0, mode='rms', quiet=1,_self=cmd):
'''
DESCRIPTION
"pseudoatom" adds a pseudoatom to a molecular object, and will
creating the molecular object if it does not yet exist.
USAGE
pseudoatom object [, selection [, name [, resn [, resi [, chain
[, segi [, elem [, vdw [, hetatm [, b [, q [, color [, label
[, pos [, state [, mode [, quiet ]]]]]]]]]]]]]]]]]
NOTES
"pseudoatom" can be used for a wide variety of random tasks where
on must place an atom or a label in 3D space.
'''
r = DEFAULT_ERROR
# preprocess selection
if len(color):
color = _self.get_color_index(str(color))
else:
color = -1 # default
object = str(object)
if not len(object):
object = _self.get_unused_name(prefix="pseudo")
selection = selector.process(selection)
mode = pseudoatom_mode_dict[pseudoatom_mode_sc.auto_err(str(mode),'pseudoatom mode')]
(name,resn,resi,chain,segi,elem,label) = map(unquote,(name,resn,resi,chain,segi,elem,label))
#
try:
_self.lock(_self)
if pos!=None:
if not (is_list(pos) or is_tuple(pos)):
pos = safe_list_eval(pos)
pos = (float(pos[0]), # tuple-ize
float(pos[1]),
float(pos[2]))
if len(selection.split())>1:
selection = "("+str(selection)+")"
r = _cmd.pseudoatom(_self._COb,str(object), str(selection),
str(name), str(resn), str(resi), str(chain),
str(segi), str(elem), float(vdw), int(hetatm),
float(b), float(q), str(label), pos, int(color),
int(state)-1, int(mode), int(quiet))
finally:
_self.unlock(r,_self)
if _self._raising(r,_self): raise pymol.CmdException
return r
def volume_color(name, colors, _self=cmd):
"""
DESCRIPTION -- untested do not use
ALSO -- this belongs in a different module
"""
if not (is_list(colors) or is_tuple(colors)):
colors = safe_list_eval(colors)
# tuple of tuples to list of float
cList = []
map(lambda x: cList.extend(x), colors)
cList = map(lambda x: float(x), cList)
try:
_self.lock(_self)
r = _cmd.volume_color(_self._COb, str(name), cList)
finally:
_self.unlock(r,_self)
if _self._raising(r,_self): raise pymol.CmdException
# unlock and then use this to differentiate our viz
return r
def volume_color(name, colors, _self=cmd):
"""
DESCRIPTION -- untested do not use
ALSO -- this belongs in a different module
"""
if not (is_list(colors) or is_tuple(colors)):
colors = safe_list_eval(colors)
# tuple of tuples to list of float
cList = []
map(lambda x: cList.extend(x), colors)
cList = map(lambda x: float(x), cList)
try:
_self.lock(_self)
r = _cmd.volume_color(_self._COb, str(name), cList)
finally:
_self.unlock(r, _self)
if _self._raising(r, _self): raise pymol.CmdException
# unlock and then use this to differentiate our viz
return r
def ramp_new(name, map_name, range=[-1.0,0.0,1.0],
color=['red',[1.0,1.0,1.0],'blue'], state=1,
selection='', beyond=2.0, within=6.0, sigma=2.0,
zero=1, quiet=1, _self=cmd):
'''
DESCRIPTION
"ramp_new" creates a color ramp based on a map potential value or
based on proximity to a molecular object.
USAGE
ramp_new name, map_name [, range [, color [, state [, selection [,
beyond [, within [, sigma [, zero ]]]]]]]]
ARGUMENTS
name = string: name of the ramp object
map_name = string: name of the map (for potential) or molecular
object (for proximity)
range = list: values corresponding to slots in the ramp
color = list: colors corresponding to slots in the ramp
state = integer: state identifier
selection = selection: for automatic ranging
beyond = number: with automatic ranging, are we excluding
values beyond a certain distance from the selection?
within = number: with automatic ranging, are we only including
valuess within a certain distance from the selection?
sigma = number: with automatic ranging, how many standard
deviations from the mean do we go?
zero = integer: with automatic ranging, do we force the central
value to be zero?
EXAMPLES
ramp_new e_pot_color, e_pot_map, [-10,0,10], [red,white,blue]
NOTES
Color ramps are extremely powerful but complicated to use.
In the simplest case, they can be used to color representations
based on the potential values found in a map object at the
corresponding positions in space.
In another simple case, representations can be colored based on
proximity to a target. Note that since ramp targets must
themselves be real objects (not merely selections), the "create"
command may be needed in order to generate an appropriate target.
In more complicated cases, they can be used to color
representations on one object based atoms found in another.
Ramps can operate recursively. In other words, the output color
from one ramp can be used as the input color for another. For
example, you could color by map potential within a certain
distance of the target object, beyond which, a uniform color is applied.
PYMOL API
def ramp_new(string name, string map_name, list range, list color,
int state, string selection, float beyond, float
within, float sigma, int zero, int quiet)
SEE ALSO
load, color, create, slice, gradient
'''
r = DEFAULT_ERROR
safe_color = string.strip(str(color))
if(safe_color[0:1]=="["): # looks like a list
color = safe_alpha_list_eval(str(safe_color))
else: # looks like a literal
color = str(color)
new_color = []
# preprocess selection
if selection!='':
selection = selector.process(selection)
# coerce range
try:
if isinstance(range, str):
range = safe_list_eval(range)
range = map(float, range)
except:
raise pymol.CmdException('invalid range')
if is_list(color):
for a in color:
if not is_list(a):
new_color.append(list(_self.get_color_tuple(a,4))) # incl negative RGB special colors
else:
new_color.append(a)
elif is_string(color):
new_color = ramp_spectrum_dict[ramp_spectrum_sc.auto_err(str(color),'ramp color spectrum')]
else:
new_color=int(color)
try:
_self.lock(_self)
r = _cmd.ramp_new(_self._COb,str(name),str(map_name),range,new_color,
int(state)-1,str(selection),float(beyond),float(within),
float(sigma),int(zero),int(quiet))
finally:
_self.unlock(r,_self)
if _self._raising(r,_self): raise pymol.CmdException
return r
def map_new(name, type='gaussian', grid=None, selection="(all)",
buffer=None, box=None, state=0, quiet=1, zoom=0,
normalize=-1, clamp=[1.0,-1.0], resolution=0.0, _self=cmd):
'''
DESCRIPTION
"map_new" creates a map object using one of the built-in map
generation routines. This command not yet fully supported.
USAGE
map_new name [, type [, grid [, selection [, buffer [, box [, state ]]]]]]
ARGUMENTS
name = string: name of the map object to create or modify
type = vdw, gaussian, gaussian_max, coulomb, coulomb_neutral, coulomb_local
grid = float: grid spacing
selection = string: atoms about which to generate the map
buffer = float: cutoff
state > 0: use the indicated state
state = 0: use all states independently with independent extents
state = -1: use current global state
state = -2: use effective object state(s)
state = -3: use all states in one map
state = -4: use all states independent states by with a unified extent
NOTES
This command can be used to create low-resolution surfaces of
protein structures.
'''
# preprocess selection
r = DEFAULT_ERROR
selection = selector.process(selection)
if box!=None: # box should be [[x1,y1,z1],[x2,y2,z2]]
if _self.is_string(box):
box = safe_list_eval(box)
box = (float(box[0][0]),
float(box[0][1]),
float(box[0][2]),
float(box[1][0]),
float(box[1][1]),
float(box[1][2]))
box_flag = 1
else:
box = (0.0,0.0,0.0,1.0,1.0,1.0)
box_flag = 0
if grid==None:
grid = _self.get_setting_legacy('gaussian_resolution')/3.0
if buffer==None:
buffer = _self.get_setting_legacy('gaussian_resolution')
grid = float(grid) # for now, uniform xyz; later (x,y,z)
if not is_list(clamp):
clamp = safe_list_eval(str(clamp))
if len(clamp)<2:
clamp = [1.0,-1.0]
type = map_type_dict[map_type_sc.auto_err(str(type),'map type')]
try:
_self.lock(_self)
r = _cmd.map_new(_self._COb,str(name),int(type),grid,str(selection),
float(buffer),box,int(state)-1,
int(box_flag),int(quiet),int(zoom),int(normalize),
float(clamp[0]),float(clamp[1]),float(resolution))
finally:
_self.unlock(r,_self)
if _self._raising(r,_self): raise pymol.CmdException
return r
def ramp_new(name,
map_name,
range=[-1.0, 0.0, 1.0],
color=['red', [1.0, 1.0, 1.0], 'blue'],
state=1,
selection='',
beyond=2.0,
within=6.0,
sigma=2.0,
zero=1,
quiet=1,
_self=cmd):
'''
DESCRIPTION
"ramp_new" creates a color ramp based on a map potential value or
based on proximity to a molecular object.
USAGE
ramp_new name, map_name [, range [, color [, state [, selection [,
beyond [, within [, sigma [, zero ]]]]]]]]
ARGUMENTS
name = string: name of the ramp object
map_name = string: name of the map (for potential) or molecular
object (for proximity)
range = list: values corresponding to slots in the ramp
color = list: colors corresponding to slots in the ramp
state = integer: state identifier
selection = selection: for automatic ranging
beyond = number: with automatic ranging, are we excluding
values beyond a certain distance from the selection?
within = number: with automatic ranging, are we only including
valuess within a certain distance from the selection?
sigma = number: with automatic ranging, how many standard
deviations from the mean do we go?
zero = integer: with automatic ranging, do we force the central
value to be zero?
EXAMPLES
ramp_new e_pot_color, e_pot_map, [-10,0,10], [red,white,blue]
NOTES
Color ramps are extremely powerful but complicated to use.
In the simplest case, they can be used to color representations
based on the potential values found in a map object at the
corresponding positions in space.
In another simple case, representations can be colored based on
proximity to a target. Note that since ramp targets must
themselves be real objects (not merely selections), the "create"
command may be needed in order to generate an appropriate target.
In more complicated cases, they can be used to color
representations on one object based atoms found in another.
Ramps can operate recursively. In other words, the output color
from one ramp can be used as the input color for another. For
example, you could color by map potential within a certain
distance of the target object, beyond which, a uniform color is applied.
PYMOL API
def ramp_new(string name, string map_name, list range, list color,
int state, string selection, float beyond, float
within, float sigma, int zero, int quiet)
SEE ALSO
load, color, create, slice, gradient
'''
r = DEFAULT_ERROR
safe_color = string.strip(str(color))
if (safe_color[0:1] == "["): # looks like a list
color = safe_alpha_list_eval(str(safe_color))
else: # looks like a literal
color = str(color)
new_color = []
# preprocess selection
if selection != '':
selection = selector.process(selection)
# coerce range
try:
if isinstance(range, str):
range = safe_list_eval(range)
range = map(float, range)
except:
raise pymol.CmdException('invalid range')
if is_list(color):
for a in color:
if not is_list(a):
new_color.append(list(_self.get_color_tuple(
a, 4))) # incl negative RGB special colors
else:
new_color.append(a)
elif is_string(color):
new_color = ramp_spectrum_dict[ramp_spectrum_sc.auto_err(
str(color), 'ramp color spectrum')]
else:
new_color = int(color)
try:
_self.lock(_self)
r = _cmd.ramp_new(_self._COb, str(name), str(map_name), range,
new_color,
int(state) - 1, str(selection), float(beyond),
float(within), float(sigma), int(zero),
int(quiet))
finally:
_self.unlock(r, _self)
if _self._raising(r, _self): raise pymol.CmdException
return r
def map_new(name,
type='gaussian',
grid=None,
selection="(all)",
buffer=None,
box=None,
state=0,
quiet=1,
zoom=0,
normalize=-1,
clamp=[1.0, -1.0],
resolution=0.0,
_self=cmd):
'''
DESCRIPTION
"map_new" creates a map object using one of the built-in map
generation routines. This command not yet fully supported.
USAGE
map_new name [, type [, grid [, selection [, buffer [, box [, state ]]]]]]
ARGUMENTS
name = string: name of the map object to create or modify
type = vdw, gaussian, gaussian_max, coulomb, coulomb_neutral, coulomb_local
grid = float: grid spacing
selection = string: atoms about which to generate the map
buffer = float: cutoff
state > 0: use the indicated state
state = 0: use all states independently with independent extents
state = -1: use current global state
state = -2: use effective object state(s)
state = -3: use all states in one map
state = -4: use all states independent states by with a unified extent
NOTES
This command can be used to create low-resolution surfaces of
protein structures.
'''
# preprocess selection
r = DEFAULT_ERROR
selection = selector.process(selection)
if box != None: # box should be [[x1,y1,z1],[x2,y2,z2]]
if _self.is_string(box):
box = safe_list_eval(box)
box = (float(box[0][0]), float(box[0][1]), float(box[0][2]),
float(box[1][0]), float(box[1][1]), float(box[1][2]))
box_flag = 1
else:
box = (0.0, 0.0, 0.0, 1.0, 1.0, 1.0)
box_flag = 0
if grid == None:
grid = _self.get_setting_legacy('gaussian_resolution') / 3.0
if buffer == None:
buffer = _self.get_setting_legacy('gaussian_resolution')
grid = float(grid) # for now, uniform xyz; later (x,y,z)
if not is_list(clamp):
clamp = safe_list_eval(str(clamp))
if len(clamp) < 2:
clamp = [1.0, -1.0]
type = map_type_dict[map_type_sc.auto_err(str(type), 'map type')]
try:
_self.lock(_self)
r = _cmd.map_new(_self._COb, str(name), int(type), grid,
str(selection), float(buffer), box,
int(state) - 1, int(box_flag), int(quiet),
int(zoom), int(normalize), float(clamp[0]),
float(clamp[1]), float(resolution))
finally:
_self.unlock(r, _self)
if _self._raising(r, _self): raise pymol.CmdException
return r
def pseudoatom(object='',
selection='',
name='PS1',
resn='PSD',
resi='1',
chain='P',
segi='PSDO',
elem='PS',
vdw=-1.0,
hetatm=1,
b=0.0,
q=0.0,
color='',
label='',
pos=None,
state=0,
mode='rms',
quiet=1,
_self=cmd):
'''
DESCRIPTION
"pseudoatom" adds a pseudoatom to a molecular object, and will
creating the molecular object if it does not yet exist.
USAGE
pseudoatom object [, selection [, name [, resn [, resi [, chain
[, segi [, elem [, vdw [, hetatm [, b [, q [, color [, label
[, pos [, state [, mode [, quiet ]]]]]]]]]]]]]]]]]
NOTES
"pseudoatom" can be used for a wide variety of random tasks where
on must place an atom or a label in 3D space.
'''
r = DEFAULT_ERROR
# preprocess selection
if len(color):
color = _self.get_color_index(str(color))
else:
color = -1 # default
object = str(object)
if not len(object):
object = _self.get_unused_name(prefix="pseudo")
selection = selector.process(selection)
mode = pseudoatom_mode_dict[pseudoatom_mode_sc.auto_err(
str(mode), 'pseudoatom mode')]
(name, resn, resi, chain, segi, elem,
label) = map(unquote, (name, resn, resi, chain, segi, elem, label))
#
try:
_self.lock(_self)
if pos != None:
if not (is_list(pos) or is_tuple(pos)):
pos = safe_list_eval(pos)
pos = (
float(pos[0]), # tuple-ize
float(pos[1]),
float(pos[2]))
if len(selection.split()) > 1:
selection = "(" + str(selection) + ")"
r = _cmd.pseudoatom(_self._COb, str(object), str(selection),
str(name), str(resn), str(resi), str(chain),
str(segi), str(elem), float(vdw), int(hetatm),
float(b), float(q), str(label), pos,
int(color),
int(state) - 1, int(mode), int(quiet))
finally:
_self.unlock(r, _self)
if _self._raising(r, _self): raise pymol.CmdException
return r
