def __init__(self, session):
self.session = session
self._openers = {}
self._fetchers = {}
from chimerax.core.triggerset import TriggerSet
self.triggers = TriggerSet()
self.triggers.add_trigger("open command changed")
def __init__(self, session):
self.session = session
self._formats = {}
self._suffix_to_formats = {}
from chimerax.core.triggerset import TriggerSet
self.triggers = TriggerSet()
self.triggers.add_trigger("data formats changed")
def __init__(self,
session,
grid_step,
radius,
atoms=None,
transforms=None,
transform_indices=None,
coords=None,
pad=None,
interpolation_threshold=0.75):
if pad is None:
pad = radius
self.structure = None
self._symmetry_map = {}
self._atoms = atoms
if atoms is not None:
self.structure = self._unique_structure(atoms)
self._structure_change_handler = None
self.session = session
self._step = grid_step
self._radius = radius
self._coords = coords
self._pad = pad
self.threshold = interpolation_threshold
self._mask = None
self._update_needed = False
self._resize_box = True
from chimerax.core.triggerset import TriggerSet
self.triggers = TriggerSet()
self.triggers.add_trigger('atom coords updated')
def __init__(self, manager, name):
super().__init__(name, manager.session)
self._mgr = manager
if not hasattr(self, 'triggers'):
from chimerax.core.triggerset import TriggerSet
self.triggers = TriggerSet()
trigger_names = (
'map box changed',
'map box moved',
)
for t in trigger_names:
self.triggers.add_trigger(t)
mh = self._mgr_handlers = []
mh.append((manager,
manager.triggers.add_handler('spotlight moved',
self._box_moved_cb)))
mh.append((manager,
manager.triggers.add_handler('spotlight changed',
self._box_changed_cb)))
mh.append((manager,
manager.triggers.add_handler('cover coords',
self._cover_coords_cb)))
def __init__(self, session, *args, **kwargs):
# 1.2 adds an __init__ to ProviderManager that uses the manager name for things
# this is not the case in 1.1
self.session = session
self.local_jobs = []
self.remote_jobs = []
self.unknown_status_jobs = []
self.paused = False
self._thread = None
self.initialized = False
self.queue_dict = {}
self.formats = {}
self.triggers = TriggerSet()
self.triggers.add_trigger(JOB_FINISHED)
self.triggers.add_handler(JOB_FINISHED, self.job_finished)
self.triggers.add_trigger(JOB_STARTED)
self.triggers.add_handler(JOB_STARTED, self.job_started)
self.triggers.add_trigger(JOB_QUEUED)
self.triggers.add_handler(JOB_QUEUED, self.check_queue)
self.triggers.add_handler(JOB_QUEUED, self.write_json)
params = signature(super().__init__).parameters
if any("name" in param for param in params):
super().__init__(*args, **kwargs)
else:
super().__init__()
def __init__(self, session):
# Just for good form. Base class currently has no __init__.
super().__init__()
self.schemes = set()
from chimerax.core.triggerset import TriggerSet
self.triggers = TriggerSet()
self.triggers.add_trigger("html schemes changed")
def __init__(self, session, bundle_info):
self.bond_rotations = {} # bond -> BondRotation
self.bond_rotaters = {} # ident -> BondRotater
self.session = session
from chimerax.core.triggerset import TriggerSet
self.triggers = TriggerSet()
for trig_name in self.trigger_names:
self.triggers.add_trigger(trig_name)
def __init__(self, session):
self.session = session
self.rot_libs = None
from chimerax.core.triggerset import TriggerSet
self.triggers = TriggerSet()
self.triggers.add_trigger("rotamer libs changed")
self._library_info = {}
self.settings = _RotamerManagerSettings(session, "rotamer lib manager")
self._uninstalled_suffix = " [not installed]"
def __init__(self, crystal_manager, spotlight_radius=12, default_oversampling_rate=2.0,
auto_add = True):
cm = self._mgr = crystal_manager
super().__init__('Map Manager', cm.session)
self._default_oversampling_rate=default_oversampling_rate
self._zone_mgr = None
if not hasattr(self, 'triggers'):
from chimerax.core.triggerset import TriggerSet
self.triggers = TriggerSet()
trigger_names = (
# Deprecated
'map box changed',
# Ask each MapSet to expand its volumes to cover an arbitrary set
# of coordinates as efficiently as possible.
'cover coords',
# Change the radius of the "spotlight" sphere. It is up to each
# MapSet to work out how to accommodate it
'spotlight changed',
'spotlight moved', # Just changed the centre of the box
)
for t in trigger_names:
self.triggers.add_trigger(t)
self._max_voxels_for_live_remask = self.DEFAULT_MAX_VOXELS
# Handler for live box update
self._box_update_handler = None
# Is the map box moving with the centre of rotation?
self._spotlight_center = None
self._initialize_zone_mgr()
# Radius of the sphere in which the map will be displayed when
# in live-scrolling mode
self.spotlight_radius = spotlight_radius
if self.spotlight_mode:
self._start_spotlight_mode()
# self.display=False
self._rezone_pending = False
# Apply the surface mask
mh = self._mgr_handlers = []
mh.append((cm, cm.triggers.add_handler('mode changed',
self._spotlight_mode_changed_cb)))
# self.session.triggers.add_handler('frame drawn', self._first_init_cb)
if auto_add:
cm.add([self])
def get_triggers(session=None):
"""Get the atomic triggers (prior implementation used 'session' arg)"""
global _triggers
if _triggers is None:
from chimerax.core.triggerset import TriggerSet
_triggers = TriggerSet()
_triggers.add_trigger("atoms transformed")
_triggers.add_trigger("changes")
_triggers.add_trigger("changes done")
return _triggers
def __init__(self, alignment, **kw):
self.alignment = alignment
self.triggers = TriggerSet()
self.triggers.add_trigger("seqs changed")
alignment.add_observer(self)
super().__init__(list_func=lambda aln=alignment: alignment.seqs,
key_func=lambda seq, aln=alignment: aln.seqs.index(seq),
item_text_func=lambda seq: seq.name,
trigger_info=[
(self.triggers, "seqs changed"),
],
**kw)
def __init__(self, session):
self.session = session
self._toolbar = {}
return
# TODO:
from . import settings
settings.settings = settings._ToolbarSettings(session, "toolbar")
from chimerax.core.triggerset import TriggerSet
self.triggers = TriggerSet()
self.triggers.add_trigger("toolbar changed")
if session.ui.is_gui:
session.ui.triggers.add_handler('ready',
lambda *arg, ses=session: settings.
register_settings_options(session))
def __init__(self, session):
self.session = session
from . import settings
settings.settings = settings._PresetsSettings(session, "presets")
settings.settings.triggers.add_handler("setting changed",
self._new_custom_folder_cb)
self._presets = {}
from chimerax.core.triggerset import TriggerSet
self.triggers = TriggerSet()
self.triggers.add_trigger("presets changed")
self._new_custom_folder_cb()
if session.ui.is_gui:
session.ui.triggers.add_handler('ready',
lambda *arg, ses=session: settings.
register_settings_options(session))
def __init__(self, session, bundle_info):
# Just for good form. Neither base class currently defines __init__.
super().__init__()
self._alignments = {}
# bundle_info needed for session save
self.bundle_info = bundle_info
self.session = session
self.viewer_info = {'alignment': {}, 'sequence': {}}
self.viewer_to_subcommand = {}
from chimerax.core.triggerset import TriggerSet
self.triggers = TriggerSet()
self.triggers.add_trigger("new alignment")
self.triggers.add_trigger("destroy alignment")
self._installed_headers = {}
self._installed_viewers = {}
def __init__(self, session, base_residue, rotamers):
self.init_state_manager(session, "residue rotamers")
self.session = session
self.base_residue = base_residue
self.rotamers = list(
rotamers) # don't want auto-shrinking of a Collection
self.group = session.models.add_group(
rotamers,
name="%s rotamers" % base_residue.string(omit_structure=True),
parent=base_residue.structure)
from chimerax.atomic import get_triggers
self.handler = get_triggers().add_handler('changes', self._changes_cb)
from chimerax.core.triggerset import TriggerSet
self.triggers = TriggerSet()
self.triggers.add_trigger('fewer rotamers') # but not zero
self.triggers.add_trigger('self destroyed')
def __init__(self, session, *args, **kwargs):
super().__init__(*args, **kwargs)
self.triggers = TriggerSet()
self.triggers.add_trigger(FILEREADER_CHANGE)
self.triggers.add_trigger(FILEREADER_ADDED)
self.triggers.add_trigger(FILEREADER_REMOVED)
self.triggers.add_trigger(ADD_FILEREADER)
session.triggers.add_handler(REMOVE_MODELS, self.remove_models)
session.triggers.add_handler(ADD_MODELS, self.apply_preset)
session.triggers.add_handler(ADD_MODELS, self.trigger_fr_add)
self.triggers.add_handler(ADD_FILEREADER, self.add_filereader)
#list of models with an associated FileReader object
self.models = []
self.filereaders = []
self.waiting_models = []
self.waiting_filereaders = []
def __init__(self, session, *args, **kwargs):
super().__setattr__("initialized", False)
self.session = session
self.local_jobs = []
self.remote_jobs = []
self.unknown_status_jobs = []
self.paused = False
self._thread = None
self.queue_dict = {}
self.formats = {}
self.triggers = TriggerSet()
self.triggers.add_trigger(JOB_FINISHED)
self.triggers.add_handler(JOB_FINISHED, self.job_finished)
self.triggers.add_trigger(JOB_STARTED)
self.triggers.add_handler(JOB_STARTED, self.job_started)
self.triggers.add_trigger(JOB_QUEUED)
self.triggers.add_handler(JOB_QUEUED, self.check_queue)
self.triggers.add_handler(JOB_QUEUED, self.write_json)
super().__init__(*args, **kwargs)
def __init__(self, session):
self.session = session
self._savers = {}
from chimerax.core.triggerset import TriggerSet
self.triggers = TriggerSet()
self.triggers.add_trigger("save command changed")
The inheriting class must implement the distance(SimpleMeasurable or ComplexMeasurable)
and angle(ComplexMeasurable) methods, either returning the corresponding value or NotImplemented
for objects that it does not know how to make the measurement to.
'''
@abstractmethod
def distance(self, obj, *, signed=False):
pass
@abstractmethod
def angle(self, obj):
pass
from chimerax.core.triggerset import TriggerSet
group_triggers = TriggerSet()
group_triggers.add_trigger("update")
group_triggers.add_trigger("delete")
def distance(session, objects, *, color=None, dashes=None,
decimal_places=None, radius=None, symbol=None, signed=False):
'''
Show/report distance between two objects.
'''
from chimerax.core.errors import UserError, LimitationError
measurables = [m for m in objects.models if isinstance(m, (SimpleMeasurable, ComplexMeasurable))]
measurables.extend(objects.atoms)
if len(measurables) != 2:
raise UserError("Expected exactly two atoms and/or measurable objects (e.g. axes, planes), got %d"
% len(measurables))
if len(objects.atoms) != 2:
def __init__(self, session, isolde, atoms):
'''
Initialise the object, including creating the splines from the current
coordinates. No restraints are applied at this stage.
Args:
* session:
- the ChimeraX master session object
* isolde:
- the :class:`Isolde` session
* atoms:
- a :class:`chimerax.AtomicStructure` instance. All atoms must
be mobile, and from a single contiguous stretch of peptide
chain. All unique residues in the selection will be chosen for
shifting
'''
if not is_continuous_protein_chain(atoms):
raise TypeError(
'Selection must be atoms from a continuous peptide chain!')
self.spring_constant =\
isolde.sim_params.position_restraint_spring_constant.value_in_unit(
defaults.OPENMM_SPRING_UNIT
) # kJ/mol/A2
# Number of GUI update steps between each residue along the spline
self.spline_steps_per_residue = 10
self._spline_step = 1 / self.spline_steps_per_residue
# Current value of the spline parameter
self._current_position_on_spline = 0
from chimerax.core.triggerset import TriggerSet
triggers = self.triggers = TriggerSet()
for t in (
'register shift started',
'register shift finished',
'register shift released',
):
triggers.add_trigger(t)
self.finished = False
# Trigger handler to update position along spline
self._handler = None
self.session = session
self.isolde = isolde
from .. import session_extensions as sx
self._pr_mgr = sx.get_position_restraint_mgr(isolde.selected_model)
self.polymer = find_polymer(atoms)
residues = atoms.unique_residues
from chimerax.atomic import Residues
residues = self.residues = Residues(
sorted(residues,
key=lambda r: (r.chain_id, r.number, r.insertion_code)))
self._extended_atoms = None
nres = len(residues)
# We need to build up the array of atoms procedurally here, since
# we want to know where there's a gap in the CB positions.
atoms = self._make_atom_arrays(residues)
coords = []
n_atoms = self._n_atoms = Atoms(atoms[:, 0])
ncoords = n_atoms.coords
ca_atoms = self._ca_atoms = Atoms(atoms[:, 1])
cacoords = ca_atoms.coords
c_atoms = self._c_atoms = Atoms(atoms[:, 2])
ccoords = c_atoms.coords
nocb = numpy.equal(atoms[:, 3], None)
nocb_indices = numpy.argwhere(nocb).ravel()
cb_indices = self._cb_indices = numpy.argwhere(
numpy.invert(nocb)).ravel()
cbcoords = numpy.empty([nres, 3])
cb_atoms = self._cb_atoms = Atoms(atoms[cb_indices, 3])
cbcoords[cb_indices] = cb_atoms.coords
# Fill in the missing CB positions. If CB is missing we'll assume
# we're dealing with a glycine and fudge it by using the HA3
# position
glyres = residues[nocb_indices]
glyha3 = glyres.atoms.filter(glyres.atoms.names == 'HA3')
cbcoords[nocb_indices] = glyha3.coords
u_vals = numpy.arange(0, nres)
# Prepare the splines
nspl = self.n_spline = interpolate.splprep(ncoords.transpose(),
u=u_vals)
caspl = self._ca_spline = interpolate.splprep(cacoords.transpose(),
u=u_vals)
cspl = self._c_spline = interpolate.splprep(ccoords.transpose(),
u=u_vals)
cbspl = self._cb_spline = interpolate.splprep(cbcoords.transpose(),
u=u_vals)