3 """@namespace IMP.pmi.tools
4 Miscellaneous utilities.
7 from __future__
import print_function
15 from math
import log,pi,sqrt,exp
22 from collections
import defaultdict
24 from collections
import OrderedDict
26 from IMP.pmi._compat_collections
import OrderedDict
28 def _get_system_for_hier(hier):
29 """Given a top-level hierarchy, return the System that created it,
31 if hasattr(hier,
'_pmi2_system'):
32 return hier._pmi2_system()
34 def _all_protocol_outputs(representations, root_hier):
35 """Iterate over all (ProtocolOutput, State) pairs for the given
36 representations (PMI1) or root hier (PMI2)"""
38 system = _get_system_for_hier(root_hier)
40 for state
in system.states:
41 for p
in state._protocol_output:
44 for p
in representations[0]._protocol_output:
47 def _add_pmi_provenance(p):
48 """Tag the given particle as being created by the current version of PMI."""
52 location=
"https://integrativemodeling.org")
55 def _get_restraint_set_keys():
56 if not hasattr(_get_restraint_set_keys,
'pmi_rs_key'):
57 _get_restraint_set_keys.pmi_rs_key =
IMP.ModelKey(
"PMI restraints")
58 _get_restraint_set_keys.rmf_rs_key =
IMP.ModelKey(
"RMF restraints")
59 return (_get_restraint_set_keys.pmi_rs_key,
60 _get_restraint_set_keys.rmf_rs_key)
62 def _add_restraint_sets(model, mk, mk_rmf):
65 model.add_data(mk, rs)
66 model.add_data(mk_rmf, rs_rmf)
70 """Add a PMI restraint to the model.
71 Since Model.add_restraint() no longer exists (in modern IMP restraints
72 should be added to a ScoringFunction instead) store them instead in
73 a RestraintSet, and keep a reference to it in the Model.
75 If `add_to_rmf` is True, also add the restraint to a separate list
76 of restraints that will be written out to RMF files (by default, most
77 PMI restraints are not)."""
78 mk, mk_rmf = _get_restraint_set_keys()
79 if model.get_has_data(mk):
80 rs = IMP.RestraintSet.get_from(model.get_data(mk))
81 rs_rmf = IMP.RestraintSet.get_from(model.get_data(mk_rmf))
83 rs, rs_rmf = _add_restraint_sets(model, mk, mk_rmf)
84 rs.add_restraint(restraint)
86 rs_rmf.add_restraint(restraint)
89 """Get a RestraintSet containing all PMI restraints added to the model.
90 If `rmf` is True, return only the subset of these restraints that
91 should be written out to RMF files."""
92 mk, mk_rmf = _get_restraint_set_keys()
93 if not model.get_has_data(mk):
94 print(
"WARNING: no restraints added to model yet")
95 _add_restraint_sets(model, mk, mk_rmf)
97 return IMP.RestraintSet.get_from(model.get_data(mk_rmf))
99 return IMP.RestraintSet.get_from(model.get_data(mk))
102 """Collect timing information.
103 Add an instance of this class to outputobjects to get timing information
108 @param isdelta if True (the default) then report the time since the
109 last use of this class; if False, report cumulative time."""
110 self.starttime = time.clock()
112 self.isdelta = isdelta
114 def set_label(self, labelstr):
115 self.label = labelstr
117 def get_output(self):
120 newtime = time.clock()
121 output[
"Stopwatch_" + self.label +
"_delta_seconds"] \
122 = str(newtime - self.starttime)
123 self.starttime = newtime
125 output[
"Stopwatch_" + self.label +
"_elapsed_seconds"] \
126 = str(time.clock() - self.starttime)
130 class SetupNuisance(object):
132 def __init__(self, m, initialvalue, minvalue, maxvalue, isoptimized=True):
136 nuisance.set_lower(minvalue)
138 nuisance.set_upper(maxvalue)
141 nuisance.set_is_optimized(nuisance.get_nuisance_key(), isoptimized)
142 self.nuisance = nuisance
144 def get_particle(self):
148 class SetupWeight(object):
150 def __init__(self, m, isoptimized=True):
153 self.weight.set_weights_are_optimized(
True)
155 def get_particle(self):
159 class SetupSurface(object):
161 def __init__(self, m, center, normal, isoptimized=True):
164 self.surface.set_coordinates_are_optimized(isoptimized)
165 self.surface.set_normal_is_optimized(isoptimized)
167 def get_particle(self):
171 class ParticleToSampleList(object):
175 self.dictionary_particle_type = {}
176 self.dictionary_particle_transformation = {}
177 self.dictionary_particle_name = {}
184 particle_transformation,
186 if not particle_type
in [
"Rigid_Bodies",
"Floppy_Bodies",
"Nuisances",
"X_coord",
"Weights",
"Surfaces"]:
187 raise TypeError(
"not the right particle type")
189 self.dictionary_particle_type[particle] = particle_type
190 if particle_type ==
"Rigid_Bodies":
191 if type(particle_transformation) == tuple
and len(particle_transformation) == 2
and type(particle_transformation[0]) == float
and type(particle_transformation[1]) == float:
192 self.dictionary_particle_transformation[
193 particle] = particle_transformation
194 self.dictionary_particle_name[particle] = name
196 raise TypeError(
"ParticleToSampleList: not the right transformation format for Rigid_Bodies, should be a tuple of floats")
197 elif particle_type ==
"Surfaces":
198 if type(particle_transformation) == tuple
and len(particle_transformation) == 3
and all(isinstance(x, float)
for x
in particle_transformation):
199 self.dictionary_particle_transformation[
200 particle] = particle_transformation
201 self.dictionary_particle_name[particle] = name
203 raise TypeError(
"ParticleToSampleList: not the right transformation format for Surfaces, should be a tuple of floats")
205 if type(particle_transformation) == float:
206 self.dictionary_particle_transformation[
207 particle] = particle_transformation
208 self.dictionary_particle_name[particle] = name
210 raise TypeError(
"ParticleToSampleList: not the right transformation format, should be a float")
212 def get_particles_to_sample(self):
214 for particle
in self.dictionary_particle_type:
215 key = self.dictionary_particle_type[
216 particle] +
"ParticleToSampleList_" + self.dictionary_particle_name[particle] +
"_" + self.label
219 self.dictionary_particle_transformation[particle])
225 "If you use this class please let the PMI developers know.")
226 class Variance(object):
228 def __init__(self, model, tau, niter, prot, th_profile, write_data=False):
231 self.write_data = write_data
235 particles = IMP.atom.get_by_type(prot, IMP.atom.ATOM_TYPE)
236 self.particles = particles
238 self.refpos = [
IMP.core.XYZ(p).get_coordinates()
for p
in particles]
239 self.model_profile = th_profile
241 def perturb_particles(self, perturb=True):
242 for i, p
in enumerate(self.particles):
243 newpos = array(self.refpos[i])
245 newpos += random.normal(0, self.tau, 3)
249 def get_profile(self):
250 model_profile = self.model_profile
251 p = model_profile.calculate_profile(self.particles, IMP.saxs.CA_ATOMS)
252 return array([model_profile.get_intensity(i)
for i
in
253 range(model_profile.size())])
255 def init_variances(self):
257 N = self.model_profile.size()
258 a = self.profiles[0][:]
260 self.V = self.m * self.m.T
261 self.normm = linalg.norm(self.m)
262 self.normV = linalg.norm(self.V)
264 def update_variances(self):
265 a = matrix(self.profiles[-1])
266 n = float(len(self.profiles))
267 self.m = a.T / n + (n - 1) / n * self.m
268 self.V = a.T * a + self.V
269 self.oldnormm = self.normm
270 self.oldnormV = self.normV
271 self.normm = linalg.norm(self.m)
272 self.normV = linalg.norm(self.V)
273 self.diffm = (self.oldnormm - self.normm) / self.oldnormm
274 self.diffV = (self.oldnormV - self.normV) / self.oldnormV
276 def get_direct_stats(self, a):
281 for q, I
in enumerate(prof):
286 Sigma = (matrix(a - m))
287 Sigma = Sigma.T * Sigma / (nprof - 1)
288 mi = matrix(diag(1. / m))
289 Sigmarel = mi.T * Sigma * mi
290 return m, V, Sigma, Sigmarel
292 def store_data(self):
293 if not os.path.isdir(
'data'):
295 profiles = matrix(self.profiles)
296 self.directm, self.directV, self.Sigma, self.Sigmarel = \
297 self.get_direct_stats(array(profiles))
298 directV = self.directV
300 save(
'data/profiles', profiles)
302 fl = open(
'data/profiles.dat',
'w')
303 for i, l
in enumerate(array(profiles).T):
304 self.model_profile.get_q(i)
307 fl.write(
'%s ' % (k - self.directm[i]))
310 fl = open(
'data/profiles_rel.dat',
'w')
311 for i, l
in enumerate(array(profiles).T):
312 self.model_profile.get_q(i)
315 fl.write(
'%s ' % ((k - self.directm[i]) / self.directm[i]))
317 save(
'data/m', self.directm)
318 save(
'data/V', self.directV)
320 save(
'data/Sigma', Sigma)
322 fl = open(
'data/Sigma.dat',
'w')
323 model_profile = self.model_profile
324 for i
in range(model_profile.size()):
325 qi = model_profile.get_q(i)
326 for j
in range(model_profile.size()):
327 qj = model_profile.get_q(j)
328 vij = self.Sigma[i, j]
329 fl.write(
'%s %s %s\n' % (qi, qj, vij))
332 fl = open(
'data/eigenvals',
'w')
333 for i
in linalg.eigvalsh(Sigma):
335 Sigmarel = self.Sigmarel
336 save(
'data/Sigmarel', Sigmarel)
338 fl = open(
'data/Sigmarel.dat',
'w')
339 model_profile = self.model_profile
340 for i
in range(model_profile.size()):
341 qi = model_profile.get_q(i)
342 for j
in range(model_profile.size()):
343 qj = model_profile.get_q(j)
344 vij = self.Sigmarel[i, j]
345 fl.write(
'%s %s %s\n' % (qi, qj, vij))
348 fl = open(
'data/eigenvals_rel',
'w')
349 for i
in linalg.eigvalsh(Sigmarel):
352 fl = open(
'data/mean.dat',
'w')
353 for i
in range(len(self.directm)):
354 qi = self.model_profile.get_q(i)
356 fl.write(
'%s ' % self.directm[i])
357 fl.write(
'%s ' % sqrt(self.Sigma[i, i]))
360 def try_chol(self, jitter):
363 linalg.cholesky(Sigma + matrix(eye(len(Sigma))) * jitter)
364 except linalg.LinAlgError:
365 print(
"Decomposition failed with jitter =", jitter)
367 print(
"Successful decomposition with jitter =", jitter)
370 self.profiles = [self.get_profile()]
372 for n
in range(self.niter):
373 self.perturb_particles()
374 self.profiles.append(self.get_profile())
386 def get_cov(self, relative=True):
396 number_of_cross_links=10,
397 ambiguity_probability=0.1,
398 confidence_score_range=[0,100],
399 avoid_same_particles=
False):
400 '''Return a random cross-link dataset as a string.
401 Every line is a residue pair, together with UniqueIdentifier
404 residue_pairs=get_random_residue_pairs(representation, resolution, number_of_cross_links, avoid_same_particles=avoid_same_particles)
407 cmin=float(min(confidence_score_range))
408 cmax=float(max(confidence_score_range))
412 for (name1, r1, name2, r2)
in residue_pairs:
413 if random.random() > ambiguity_probability:
415 score=random.random()*(cmax-cmin)+cmin
416 dataset+=str(name1)+
" "+str(name2)+
" "+str(r1)+
" "+str(r2)+
" "+str(score)+
" "+str(unique_identifier)+
"\n"
423 def get_cross_link_data(directory, filename, dist, omega, sigma,
424 don=
None, doff=
None, prior=0, type_of_profile=
"gofr"):
426 (distmin, distmax, ndist) = dist
427 (omegamin, omegamax, nomega) = omega
428 (sigmamin, sigmamax, nsigma) = sigma
431 with open(filen)
as xlpot:
432 dictionary = ast.literal_eval(xlpot.readline())
434 xpot = dictionary[directory][filename][
"distance"]
435 pot = dictionary[directory][filename][type_of_profile]
437 dist_grid =
get_grid(distmin, distmax, ndist,
False)
438 omega_grid = get_log_grid(omegamin, omegamax, nomega)
439 sigma_grid = get_log_grid(sigmamin, sigmamax, nsigma)
441 if not don
is None and not doff
is None:
464 "If you use this function please let the PMI developers know.")
465 def get_cross_link_data_from_length(length, xxx_todo_changeme3, xxx_todo_changeme4, xxx_todo_changeme5):
466 (distmin, distmax, ndist) = xxx_todo_changeme3
467 (omegamin, omegamax, nomega) = xxx_todo_changeme4
468 (sigmamin, sigmamax, nsigma) = xxx_todo_changeme5
470 dist_grid =
get_grid(distmin, distmax, ndist,
False)
471 omega_grid = get_log_grid(omegamin, omegamax, nomega)
472 sigma_grid = get_log_grid(sigmamin, sigmamax, nsigma)
478 def get_grid(gmin, gmax, ngrid, boundaries):
480 dx = (gmax - gmin) / float(ngrid)
481 for i
in range(0, ngrid + 1):
482 if(
not boundaries
and i == 0):
484 if(
not boundaries
and i == ngrid):
486 grid.append(gmin + float(i) * dx)
492 def get_log_grid(gmin, gmax, ngrid):
494 for i
in range(0, ngrid + 1):
495 grid.append(gmin * exp(float(i) / ngrid * log(gmax / gmin)))
503 example '"{ID_Score}" > 28 AND "{Sample}" ==
504 "%10_1%" OR ":Sample}" == "%10_2%" OR ":Sample}"
505 == "%10_3%" OR ":Sample}" == "%8_1%" OR ":Sample}" == "%8_2%"'
508 import pyparsing
as pp
510 operator = pp.Regex(
">=|<=|!=|>|<|==|in").setName(
"operator")
511 value = pp.QuotedString(
513 r"[+-]?\d+(:?\.\d*)?(:?[eE][+-]?\d+)?")
514 identifier = pp.Word(pp.alphas, pp.alphanums +
"_")
515 comparison_term = identifier | value
516 condition = pp.Group(comparison_term + operator + comparison_term)
518 expr = pp.operatorPrecedence(condition, [
519 (
"OR", 2, pp.opAssoc.LEFT, ),
520 (
"AND", 2, pp.opAssoc.LEFT, ),
523 parsedstring = str(expr.parseString(inputstring)) \
529 .replace(
"{",
"float(entry['") \
530 .replace(
"}",
"'])") \
531 .replace(
":",
"str(entry['") \
532 .replace(
"}",
"'])") \
533 .replace(
"AND",
"and") \
538 def open_file_or_inline_text(filename):
540 fl = open(filename,
"r")
542 fl = filename.split(
"\n")
547 "If you use this function please let the PMI developers know.")
551 for i
in range(0, len(prot0) - 1):
552 for j
in range(i + 1, len(prot0)):
555 drmsd += (dist0 - dist1) ** 2
557 return math.sqrt(drmsd / npairs)
562 def get_ids_from_fasta_file(fastafile):
564 with open(fastafile)
as ff:
573 this function works with plain hierarchies, as read from the pdb,
574 no multi-scale hierarchies
581 atom_type=IMP.atom.AT_CA)
589 print(
"get_closest_residue_position: exiting while loop without result")
591 p = sel.get_selected_particles()
596 print(
"get_closest_residue_position: got NO residues for hierarchy %s and residue %i" % (hier, resindex))
597 raise Exception(
"get_closest_residue_position: got NO residues for hierarchy %s and residue %i" % (
600 raise ValueError(
"got multiple residues for hierarchy %s and residue %i; the list of particles is %s" % (hier, resindex, str([pp.get_name()
for pp
in p])))
604 Get the particle of the terminal residue at the GIVEN resolution
605 (NOTE: not the closest resolution!).
606 To get the terminal residue at the closest resolution use:
607 particles=IMP.pmi.tools.select_by_tuple(representation,molecule_name)
608 particles[0] and particles[-1] will be the first and last particles
609 corresponding to the two termini.
610 It is needed for instance to determine the last residue of a pdb.
611 @param hier hierarchy containing the terminal residue
612 @param terminus either 'N' or 'C'
613 @param resolution resolution to use.
619 resolution=resolution,
626 if termresidue
is None:
627 termresidue = max(residues)
629 elif max(residues) >= termresidue:
630 termresidue = max(residues)
632 elif terminus ==
"N":
633 if termresidue
is None:
634 termresidue = min(residues)
636 elif min(residues) <= termresidue:
637 termresidue = min(residues)
640 raise ValueError(
"terminus argument should be either N or C")
645 """Get XYZ coordinates of the terminal residue at the GIVEN resolution"""
651 Return the residue index gaps and contiguous segments in the hierarchy.
653 @param hierarchy hierarchy to examine
654 @param start first residue index
655 @param end last residue index
657 @return A list of lists of the form
658 [[1,100,"cont"],[101,120,"gap"],[121,200,"cont"]]
661 for n, rindex
in enumerate(range(start, end + 1)):
663 atom_type=IMP.atom.AT_CA)
665 if len(sel.get_selected_particles()) == 0:
669 rindexcont = start - 1
670 if rindexgap == rindex - 1:
676 gaps.append([rindex, rindex,
"gap"])
682 rindexgap = start - 1
684 if rindexcont == rindex - 1:
691 gaps.append([rindex, rindex,
"cont"])
702 def set_map_element(self, xvalue, yvalue):
703 self.map[xvalue] = yvalue
705 def get_map_element(self, invalue):
706 if type(invalue) == float:
710 dist = (invalue - x) * (invalue - x)
719 return self.map[minx]
720 elif type(invalue) == str:
721 return self.map[invalue]
723 raise TypeError(
"wrong type for map")
729 selection_arguments=
None,
731 name_is_ambiguous=
False,
735 representation_type=
None):
737 this function uses representation=SimplifiedModel
738 it returns the corresponding selected particles
739 representation_type="Beads", "Res:X", "Densities", "Representation", "Molecule"
742 if resolution
is None:
744 resolution_particles =
None
745 hierarchies_particles =
None
746 names_particles =
None
747 residue_range_particles =
None
748 residue_particles =
None
749 representation_type_particles =
None
751 if not resolution
is None:
752 resolution_particles = []
753 hs = representation.get_hierarchies_at_given_resolution(resolution)
757 if not hierarchies
is None:
758 hierarchies_particles = []
759 for h
in hierarchies:
764 if name_is_ambiguous:
765 for namekey
in representation.hier_dict:
768 representation.hier_dict[namekey])
769 elif name
in representation.hier_dict:
772 print(
"select: component %s is not there" % name)
774 if not first_residue
is None and not last_residue
is None:
776 residue_indexes=range(first_residue, last_residue + 1))
778 for p
in sel.get_selected_particles()]
780 if not residue
is None:
783 for p
in sel.get_selected_particles()]
785 if not representation_type
is None:
786 representation_type_particles = []
787 if representation_type ==
"Molecule":
788 for name
in representation.hier_representation:
789 for repr_type
in representation.hier_representation[name]:
790 if repr_type ==
"Beads" or "Res:" in repr_type:
791 h = representation.hier_representation[name][repr_type]
794 elif representation_type ==
"PDB":
795 for name
in representation.hier_representation:
796 for repr_type
in representation.hier_representation[name]:
797 if repr_type ==
"Res:" in repr_type:
798 h = representation.hier_representation[name][repr_type]
802 for name
in representation.hier_representation:
803 h = representation.hier_representation[
808 selections = [hierarchies_particles, names_particles,
809 residue_range_particles, residue_particles, representation_type_particles]
811 if resolution
is None:
812 selected_particles = set(allparticles)
814 selected_particles = set(resolution_particles)
818 selected_particles = (set(s) & selected_particles)
820 return list(selected_particles)
827 name_is_ambiguous=
False):
828 if isinstance(tupleselection, tuple)
and len(tupleselection) == 3:
830 name=tupleselection[2],
831 first_residue=tupleselection[0],
832 last_residue=tupleselection[1],
833 name_is_ambiguous=name_is_ambiguous)
834 elif isinstance(tupleselection, str):
837 name_is_ambiguous=name_is_ambiguous)
839 raise ValueError(
'you passed something bad to select_by_tuple()')
841 particles = IMP.pmi.tools.sort_by_residues(particles)
846 """New tuple format: molname OR (start,stop,molname,copynum,statenum)
847 Copy and state are optional. Can also use 'None' for them which will get all.
848 You can also pass -1 for stop which will go to the end.
849 Returns the particles
852 kwds[
'resolution'] = resolution
853 if type(tuple_selection)
is str:
854 kwds[
'molecule'] = tuple_selection
855 elif type(tuple_selection)
is tuple:
856 rbegin = tuple_selection[0]
857 rend = tuple_selection[1]
858 kwds[
'molecule'] = tuple_selection[2]
860 copynum = tuple_selection[3]
861 if copynum
is not None:
862 kwds[
'copy_index'] = copynum
866 statenum = tuple_selection[4]
867 if statenum
is not None:
868 kwds[
'state_index'] = statenum
875 residue_indexes=range(1,rbegin),
877 return s.get_selected_particles()
879 kwds[
'residue_indexes'] = range(rbegin,rend+1)
881 return s.get_selected_particles()
885 def get_db_from_csv(csvfilename):
888 with open(csvfilename)
as fh:
889 csvr = csv.DictReader(fh)
896 """Store the representations for a system."""
901 self.root_hierarchy_dict = {}
902 self.preroot_fragment_hierarchy_dict = {}
903 self.particle_to_name = {}
906 def add_name(self, name):
907 if name
not in self.db:
910 def add_residue_number(self, name, resn):
913 if resn
not in self.db[name]:
914 self.db[name][resn] = {}
916 def add_resolution(self, name, resn, resolution):
918 resolution = float(resolution)
920 self.add_residue_number(name, resn)
921 if resolution
not in self.db[name][resn]:
922 self.db[name][resn][resolution] = []
926 resolution = float(resolution)
928 self.add_residue_number(name, resn)
929 self.add_resolution(name, resn, resolution)
930 self.db[name][resn][resolution] += particles
932 (rh, prf) = self.get_root_hierarchy(p)
933 self.root_hierarchy_dict[p] = rh
934 self.preroot_fragment_hierarchy_dict[p] = prf
935 self.particle_to_name[p] = name
936 if self.model
is None:
937 self.model = particles[0].get_model()
943 names = list(self.db.keys())
949 resolution = float(resolution)
950 return self.db[name][resn][resolution]
952 def get_particles_at_closest_resolution(self, name, resn, resolution):
954 resolution = float(resolution)
955 closestres = min(self.get_residue_resolutions(name, resn),
956 key=
lambda x: abs(float(x) - float(resolution)))
957 return self.get_particles(name, resn, closestres)
959 def get_residue_resolutions(self, name, resn):
961 resolutions = list(self.db[name][resn].keys())
965 def get_molecule_resolutions(self, name):
967 for resn
in self.db[name]:
968 resolutions.update(list(self.db[name][resn].keys()))
972 def get_residue_numbers(self, name):
973 residue_numbers = list(self.db[name].keys())
974 residue_numbers.sort()
975 return residue_numbers
977 def get_particles_by_resolution(self, name, resolution):
978 resolution = float(resolution)
980 for resn
in self.get_residue_numbers(name):
981 result = self.get_particles_at_closest_resolution(
985 pstemp = [p
for p
in result
if p
not in particles]
989 def get_all_particles_by_resolution(self, resolution):
990 resolution = float(resolution)
992 for name
in self.get_names():
993 particles += self.get_particles_by_resolution(name, resolution)
996 def get_root_hierarchy(self, particle):
997 prerootfragment = particle
1007 prerootfragment = particle
1013 def get_all_root_hierarchies_by_resolution(self, resolution):
1015 resolution = float(resolution)
1016 particles = self.get_all_particles_by_resolution(resolution)
1018 rh = self.root_hierarchy_dict[p]
1019 if rh
not in hierarchies:
1023 def get_preroot_fragments_by_resolution(self, name, resolution):
1025 resolution = float(resolution)
1026 particles = self.get_particles_by_resolution(name, resolution)
1028 fr = self.preroot_fragment_hierarchy_dict[p]
1029 if fr
not in fragments:
1030 fragments.append(fr)
1033 def show(self, name):
1035 for resn
in self.get_residue_numbers(name):
1037 for resolution
in self.get_residue_resolutions(name, resn):
1038 print(
"----", resolution)
1039 for p
in self.get_particles(name, resn, resolution):
1040 print(
"--------", p.get_name())
1044 '''Return the component name provided a particle and a list of names'''
1046 protname = root.get_name()
1048 while not protname
in list_of_names:
1049 root0 = root.get_parent()
1052 protname = root0.get_name()
1057 if "Beads" in protname:
1060 return (protname, is_a_bead)
1065 Retrieve the residue indexes for the given particle.
1067 The particle must be an instance of Fragment,Residue, Atom or Molecule
1068 or else returns an empty list
1079 resind_tmp=IMP.pmi.tools.OrderedSet()
1085 resind=list(resind_tmp)
1091 def sort_by_residues(particles):
1094 sorted_particles_residues = sorted(
1096 key=
lambda tup: tup[1])
1097 particles = [p[0]
for p
in sorted_particles_residues]
1102 "If you use this function please let the PMI developers know.")
1103 def get_residue_to_particle_map(particles):
1105 particles = sort_by_residues(particles)
1108 return dict(zip(particles_residues, particles))
1116 """Synchronize data over a parallel run"""
1117 from mpi4py
import MPI
1118 comm = MPI.COMM_WORLD
1119 rank = comm.Get_rank()
1120 number_of_processes = comm.size
1123 comm.send(data, dest=0, tag=11)
1126 for i
in range(1, number_of_processes):
1127 data_tmp = comm.recv(source=i, tag=11)
1128 if type(data) == list:
1130 elif type(data) == dict:
1131 data.update(data_tmp)
1133 raise TypeError(
"data not supported, use list or dictionaries")
1135 for i
in range(1, number_of_processes):
1136 comm.send(data, dest=i, tag=11)
1139 data = comm.recv(source=0, tag=11)
1143 "If you use this function please let the PMI developers know.")
1144 def scatter_and_gather_dict_append(data):
1145 """Synchronize data over a parallel run"""
1146 from mpi4py
import MPI
1147 comm = MPI.COMM_WORLD
1148 rank = comm.Get_rank()
1149 number_of_processes = comm.size
1152 comm.send(data, dest=0, tag=11)
1154 for i
in range(1, number_of_processes):
1155 data_tmp = comm.recv(source=i, tag=11)
1157 data[k]+=data_tmp[k]
1159 for i
in range(1, number_of_processes):
1160 comm.send(data, dest=i, tag=11)
1163 data = comm.recv(source=0, tag=11)
1171 def sublist_iterator(l, lmin=None, lmax=None):
1173 Yield all sublists of length >= lmin and <= lmax
1181 for j
in range(i + 1, n):
1182 if len(l[i:j]) <= lmax
and len(l[i:j]) >= lmin:
1186 def flatten_list(l):
1187 return [item
for sublist
in l
for item
in sublist]
1190 def list_chunks_iterator(list, length):
1191 """ Yield successive length-sized chunks from a list.
1193 for i
in range(0, len(list), length):
1194 yield list[i:i + length]
1197 def chunk_list_into_segments(seq, num):
1199 avg = len(seq) / float(num)
1203 while last < len(seq):
1204 out.append(seq[int(last):int(last + avg)])
1210 class Segments(object):
1212 ''' This class stores integers
1213 in ordered compact lists eg:
1215 the methods help splitting and merging the internal lists
1217 s=Segments([1,2,3]) is [[1,2,3]]
1218 s.add(4) is [[1,2,3,4]] (add right)
1219 s.add(3) is [[1,2,3,4]] (item already existing)
1220 s.add(7) is [[1,2,3,4],[7]] (new list)
1221 s.add([8,9]) is [[1,2,3,4],[7,8,9]] (add item right)
1222 s.add([5,6]) is [[1,2,3,4,5,6,7,8,9]] (merge)
1223 s.remove(3) is [[1,2],[4,5,6,7,8,9]] (split)
1227 def __init__(self,index):
1228 '''index can be a integer or a list of integers '''
1229 if type(index)
is int:
1231 elif type(index)
is list:
1232 self.segs=[[index[0]]]
1236 raise TypeError(
"index must be an int or list of ints")
1238 def add(self,index):
1239 '''index can be a integer or a list of integers '''
1240 if type(index)
is int:
1243 for n,s
in enumerate(self.segs):
1251 if mergeright
is None and mergeleft
is None:
1252 self.segs.append([index])
1253 if not mergeright
is None and mergeleft
is None:
1254 self.segs[mergeright].append(index)
1255 if not mergeleft
is None and mergeright
is None:
1256 self.segs[mergeleft]=[index]+self.segs[mergeleft]
1257 if not mergeleft
is None and not mergeright
is None:
1258 self.segs[mergeright]=self.segs[mergeright]+[index]+self.segs[mergeleft]
1259 del self.segs[mergeleft]
1261 for n
in range(len(self.segs)):
1264 self.segs.sort(key=
lambda tup: tup[0])
1266 elif type(index)
is list:
1270 raise TypeError(
"index must be an int or list of ints")
1272 def remove(self,index):
1273 '''index can be a integer'''
1274 for n,s
in enumerate(self.segs):
1281 i=self.segs[n].index(index)
1283 self.segs.append(s[i+1:])
1284 for n
in range(len(self.segs)):
1286 if len(self.segs[n])==0:
1288 self.segs.sort(key=
lambda tup: tup[0])
1290 def get_flatten(self):
1291 ''' Returns a flatten list '''
1292 return [item
for sublist
in self.segs
for item
in sublist]
1296 for seg
in self.segs:
1297 ret_tmp+=str(seg[0])+
"-"+str(seg[-1])+
","
1298 ret=ret_tmp[:-1]+
"]"
1309 "If you use this function please let the PMI developers know.")
1310 def translate_hierarchy(hierarchy, translation_vector):
1312 Apply a translation to a hierarchy along the input vector.
1316 if type(translation_vector) == list:
1336 "If you use this function please let the PMI developers know.")
1337 def translate_hierarchies(hierarchies, translation_vector):
1338 for h
in hierarchies:
1339 IMP.pmi.tools.translate_hierarchy(h, translation_vector)
1343 "If you use this function please let the PMI developers know.")
1344 def translate_hierarchies_to_reference_frame(hierarchies):
1349 for h
in hierarchies:
1359 IMP.pmi.tools.translate_hierarchies(hierarchies, (-xc, -yc, -zc))
1366 def normal_density_function(expected_value, sigma, x):
1368 1 / math.sqrt(2 * math.pi) / sigma *
1369 math.exp(-(x - expected_value) ** 2 / 2 / sigma / sigma)
1373 def log_normal_density_function(expected_value, sigma, x):
1375 1 / math.sqrt(2 * math.pi) / sigma / x *
1376 math.exp(-(math.log(x / expected_value) ** 2 / 2 / sigma / sigma))
1380 def get_random_residue_pairs(representation, resolution,
1383 avoid_same_particles=
False,
1388 names=list(representation.hier_dict.keys())
1391 prot = representation.hier_dict[name]
1392 particles +=
select(representation,name=name,resolution=resolution)
1393 random_residue_pairs = []
1394 while len(random_residue_pairs)<=number:
1395 p1 = random.choice(particles)
1396 p2 = random.choice(particles)
1397 if max_distance
is not None and \
1402 if r1==r2
and avoid_same_particles:
continue
1403 name1 = representation.get_prot_name_from_particle(p1)
1404 name2 = representation.get_prot_name_from_particle(p2)
1405 random_residue_pairs.append((name1, r1, name2, r2))
1407 return random_residue_pairs
1411 "If you use this function please let the PMI developers know.")
1412 def get_random_data_point(
1418 begin_end_nbins_tuple,
1423 begin = begin_end_nbins_tuple[0]
1424 end = begin_end_nbins_tuple[1]
1425 nbins = begin_end_nbins_tuple[2]
1428 fmod_grid =
get_grid(begin, end, nbins,
True)
1430 fmod_grid = get_log_grid(begin, end, nbins)
1437 for i
in range(0, ntrials):
1438 a.append([random.random(),
True])
1441 for j
in range(1, len(fmod_grid)):
1443 fjm1 = fmod_grid[j - 1]
1447 pj = normal_density_function(expected_value, sigma, fj)
1448 pjm1 = normal_density_function(expected_value, sigma, fjm1)
1450 pj = log_normal_density_function(expected_value, sigma, fj)
1451 pjm1 = log_normal_density_function(expected_value, sigma, fjm1)
1453 norm += (pj + pjm1) / 2.0 * df
1459 for i
in range(len(cumul)):
1462 if (aa[0] <= cumul[i] / norm
and aa[1]):
1463 random_points.append(
1464 int(fmod_grid[i] / sensitivity) * sensitivity)
1468 random_points = [expected_value] * ntrials
1470 for i
in range(len(random_points)):
1471 if random.random() < outlierprob:
1472 a = random.uniform(begin, end)
1473 random_points[i] = int(a / sensitivity) * sensitivity
1474 print(random_points)
1476 for i in range(ntrials):
1477 if random.random() > OUTLIERPROB_:
1478 r=truncnorm.rvs(0.0,1.0,expected_value,BETA_)
1479 if r>1.0: print r,expected_value,BETA_
1482 random_points.append(int(r/sensitivity)*sensitivity)
1487 for r
in random_points:
1491 rmean /= float(ntrials)
1492 rmean2 /= float(ntrials)
1493 stddev = math.sqrt(max(rmean2 - rmean * rmean, 0.))
1494 return rmean, stddev
1496 def print_multicolumn(list_of_strings, ncolumns=2, truncate=40):
1502 for i
in range(len(l) % cols):
1505 split = [l[i:i + len(l) / cols]
for i
in range(0, len(l), len(l) / cols)]
1506 for row
in zip(*split):
1507 print(
"".join(str.ljust(i, truncate)
for i
in row))
1509 class ColorChange(object):
1510 '''Change color code to hexadecimal to rgb'''
1512 self._NUMERALS =
'0123456789abcdefABCDEF'
1513 self._HEXDEC = dict((v, int(v, 16))
for v
in (x+y
for x
in self._NUMERALS
for y
in self._NUMERALS))
1514 self.LOWERCASE, self.UPPERCASE =
'x',
'X'
1516 def rgb(self,triplet):
1517 return float(self._HEXDEC[triplet[0:2]]), float(self._HEXDEC[triplet[2:4]]), float(self._HEXDEC[triplet[4:6]])
1519 def triplet(self,rgb, lettercase=None):
1520 if lettercase
is None: lettercase=self.LOWERCASE
1521 return format(rgb[0]<<16 | rgb[1]<<8 | rgb[2],
'06'+lettercase)
1525 class OrderedSet(collections.MutableSet):
1527 def __init__(self, iterable=None):
1529 end += [
None, end, end]
1531 if iterable
is not None:
1535 return len(self.map)
1537 def __contains__(self, key):
1538 return key
in self.map
1541 if key
not in self.map:
1544 curr[2] = end[1] = self.map[key] = [key, curr, end]
1546 def discard(self, key):
1548 key, prev, next = self.map.pop(key)
1555 while curr
is not end:
1559 def __reversed__(self):
1562 while curr
is not end:
1566 def pop(self, last=True):
1568 raise KeyError(
'set is empty')
1570 key = self.end[1][0]
1572 key = self.end[2][0]
1578 return '%s()' % (self.__class__.__name__,)
1579 return '%s(%r)' % (self.__class__.__name__, list(self))
1581 def __eq__(self, other):
1582 if isinstance(other, OrderedSet):
1583 return len(self) == len(other)
and list(self) == list(other)
1584 return set(self) == set(other)
1587 class OrderedDefaultDict(OrderedDict):
1588 """Store objects in order they were added, but with default type.
1589 Source: http://stackoverflow.com/a/4127426/2608793
1591 def __init__(self, *args, **kwargs):
1593 self.default_factory =
None
1595 if not (args[0]
is None or callable(args[0])):
1596 raise TypeError(
'first argument must be callable or None')
1597 self.default_factory = args[0]
1599 super(OrderedDefaultDict, self).__init__(*args, **kwargs)
1601 def __missing__ (self, key):
1602 if self.default_factory
is None:
1604 self[key] = default = self.default_factory()
1607 def __reduce__(self):
1608 args = (self.default_factory,)
if self.default_factory
else ()
1609 if sys.version_info[0] >= 3:
1610 return self.__class__, args,
None,
None, self.items()
1612 return self.__class__, args,
None,
None, self.iteritems()
1617 def set_coordinates_from_rmf(hier,rmf_fn,frame_num=0):
1618 """Extract frame from RMF file and fill coordinates. Must be identical topology.
1619 @param hier The (System) hierarchy to fill (e.g. after you've built it)
1620 @param rmf_fn The file to extract from
1621 @param frame_num The frame number to extract
1623 rh = RMF.open_rmf_file_read_only(rmf_fn)
1628 def input_adaptor(stuff,
1631 selection_tuple=
None,
1632 warn_about_slices=
True):
1633 """Adapt things for PMI (degrees of freedom, restraints, ...)
1634 Returns list of list of hierarchies, separated into Molecules if possible.
1635 The input can be a list, or a list of lists (iterable of ^1 or iterable of ^2)
1636 (iterable of ^2) Hierarchy -> returns input as list of list of hierarchies,
1637 only one entry, not grouped by molecules.
1638 (iterable of ^2) PMI::System/State/Molecule/TempResidue ->
1639 returns residue hierarchies, grouped in molecules, at requested resolution
1640 @param stuff Can be one of the following inputs:
1641 IMP Hierarchy, PMI System/State/Molecule/TempResidue, or a list/set (of list/set) of them.
1642 Must be uniform input, however. No mixing object types.
1643 @param pmi_resolution For selecting, only does it if you pass PMI objects. Set it to "all"
1644 if you want all resolutions!
1645 @param flatten Set to True if you just want all hierarchies in one list.
1646 @param warn_about_slices Print a warning if you are requesting only part
1647 of a bead. Sometimes you just don't care!
1648 @note since this relies on IMP::atom::Selection, this will not return
1649 any objects if they weren't built! But there should be no problem
1650 if you request unbuilt residues - they should be ignored.
1656 if hasattr(stuff,
'__iter__'):
1662 if all(hasattr(el,
'__iter__')
for el
in thelist):
1663 thelist = [i
for sublist
in thelist
for i
in sublist]
1664 elif any(hasattr(el,
'__iter__')
for el
in thelist):
1665 raise Exception(
'input_adaptor: input_object must be a list or a list of lists')
1674 except NotImplementedError:
1685 if is_system
or is_state
or is_molecule
or is_temp_residue:
1688 indexes_per_mol = OrderedDefaultDict(list)
1690 for system
in stuff:
1691 for state
in system.get_states():
1692 mdict = state.get_molecules()
1693 for molname
in mdict:
1694 for copy
in mdict[molname]:
1695 indexes_per_mol[copy] += [r.get_index()
for r
in copy.get_residues()]
1698 mdict = state.get_molecules()
1699 for molname
in mdict:
1700 for copy
in mdict[molname]:
1701 indexes_per_mol[copy] += [r.get_index()
for r
in copy.get_residues()]
1703 for molecule
in stuff:
1704 indexes_per_mol[molecule] += [r.get_index()
for r
in molecule.get_residues()]
1706 for tempres
in stuff:
1707 indexes_per_mol[tempres.get_molecule()].append(tempres.get_index())
1708 for mol
in indexes_per_mol:
1709 if pmi_resolution==
'all':
1712 ps = select_at_all_resolutions(mol.get_hierarchy(),
1713 residue_indexes=indexes_per_mol[mol])
1716 resolution=pmi_resolution,
1717 residue_indexes=indexes_per_mol[mol])
1718 ps = sel.get_selected_particles()
1721 if warn_about_slices:
1722 rset = set(indexes_per_mol[mol])
1726 if not fset <= rset:
1732 resbreak = maxf
if minf==minset
else minset-1
1733 print(
'WARNING: You are trying to select only part of the bead %s:%i-%i.\n'
1734 'The residues you requested are %i-%i. You can fix this by:\n'
1735 '1) requesting the whole bead/none of it or\n'
1736 '2) break the bead up by passing bead_extra_breaks=[\'%i\'] in '
1737 'molecule.add_representation()'
1738 %(mol.get_name(),minset,maxset,minf,maxf,resbreak))
1743 if pmi_resolution==
'all':
1745 ps+=select_at_all_resolutions(h)
1751 hier_list = [hier_list]
1753 raise Exception(
'input_adaptor: you passed something of wrong type or a list with mixed types')
1755 if flatten
and pmi_input:
1756 return [h
for sublist
in hier_list
for h
in sublist]
1761 def get_sorted_segments(mol):
1762 """Returns sequence-sorted segments array, each containing the first particle
1763 the last particle and the first residue index."""
1765 from operator
import itemgetter
1766 hiers=IMP.pmi.tools.input_adaptor(mol)
1768 raise ValueError(
"only pass stuff from one Molecule, please")
1784 segs.append((start, end, startres))
1785 return sorted(segs, key=itemgetter(2))
1787 def display_bonds(mol):
1788 """Decorate the sequence-consecutive particles from a PMI2 molecule with a bond,
1789 so that they appear connected in the rmf file"""
1790 SortedSegments=get_sorted_segments(mol)
1791 for x
in range(len(SortedSegments) - 1):
1793 last = SortedSegments[x][1]
1794 first = SortedSegments[x + 1][0]
1796 p1 = last.get_particle()
1797 p2 = first.get_particle()
1809 class ThreeToOneConverter(defaultdict):
1810 """This class converts three to one letter codes, and return X for any unknown codes"""
1811 def __init__(self,is_nucleic=False):
1814 threetoone = {
'ALA':
'A',
'ARG':
'R', 'ASN': 'N', 'ASP': 'D',
1815 'CYS':
'C',
'GLU':
'E',
'GLN':
'Q',
'GLY':
'G',
1816 'HIS':
'H',
'ILE':
'I',
'LEU':
'L',
'LYS':
'K',
1817 'MET':
'M',
'PHE':
'F',
'PRO':
'P',
'SER':
'S',
1818 'THR':
'T',
'TRP':
'W',
'TYR':
'Y',
'VAL':
'V',
'UNK':
'X'}
1820 threetoone = {
'ADE':
'A',
'URA':
'U', 'CYT': 'C', 'GUA': 'G',
1821 'THY':
'T',
'UNK':
'X'}
1823 defaultdict.__init__(self,
lambda:
"X", threetoone)
1828 def get_residue_type_from_one_letter_code(code,is_nucleic=False):
1829 threetoone=ThreeToOneConverter(is_nucleic)
1831 for k
in threetoone:
1832 one_to_three[threetoone[k]] = k
1836 def get_all_leaves(list_of_hs):
1837 """ Just get the leaves from a list of hierarchies """
1838 lvs = list(itertools.chain.from_iterable(
IMP.atom.get_leaves(item)
for item
in list_of_hs))
1842 def select_at_all_resolutions(hier=None,
1845 """Perform selection using the usual keywords but return ALL resolutions (BEADS and GAUSSIANS).
1846 Returns in flat list!
1851 if hier
is not None:
1854 print(
"WARNING: You passed nothing to select_at_all_resolutions()")
1861 raise Exception(
'select_at_all_resolutions: you have to pass an IMP Hierarchy')
1863 raise Exception(
'select_at_all_resolutions: you have to pass an IMP Hierarchy')
1864 if 'resolution' in kwargs
or 'representation_type' in kwargs:
1865 raise Exception(
"don't pass resolution or representation_type to this function")
1867 representation_type=IMP.atom.BALLS,**kwargs)
1869 representation_type=IMP.atom.DENSITIES,**kwargs)
1870 ret |= OrderedSet(selB.get_selected_particles())
1871 ret |= OrderedSet(selD.get_selected_particles())
1875 def get_particles_within_zone(hier,
1880 """Utility to retrieve particles from a hierarchy within a
1881 zone around a set of ps.
1882 @param hier The hierarchy in which to look for neighbors
1883 @param target_ps The particles for zoning
1884 @param sel_zone The maximum distance
1885 @param entire_residues If True, will grab entire residues
1886 @param exclude_backbone If True, will only return sidechain particles
1890 backbone_types=[
'C',
'N',
'CB',
'O']
1891 if exclude_backbone:
1893 for n
in backbone_types])
1894 test_ps = test_sel.get_selected_particles()
1895 nn = IMP.algebra.NearestNeighbor3D([
IMP.core.XYZ(p).get_coordinates()
1898 for target
in target_ps:
1899 zone|=set(nn.get_in_ball(
IMP.core.XYZ(target).get_coordinates(),sel_zone))
1900 zone_ps = [test_ps[z]
for z
in zone]
1905 zone_ps = [h.get_particle()
for h
in final_ps]
1909 def get_rbs_and_beads(hiers):
1910 """Returns unique objects in original order"""
1914 if not hasattr(hiers,
'__iter__'):
1916 for p
in get_all_leaves(hiers):
1921 rbs_ordered.append(rb)
1926 rbs_ordered.append(rb)
1930 return rbs_ordered,beads
1932 def get_molecules(input_objects):
1933 "This function returns the parent molecule hierarchies of given objects"
1934 stuff=input_adaptor(input_objects, pmi_resolution=
'all',flatten=
True)
1939 while not (is_molecule
or is_root):
1940 root=IMP.atom.get_root(h)
1947 return list(molecules)
1949 def get_molecules_dictionary(input_objects):
1950 moldict=defaultdict(list)
1951 for mol
in IMP.pmi.tools.get_molecules(input_objects):
1953 moldict[name].append(mol)
1959 def get_molecules_dictionary_by_copy(input_objects):
1960 moldict=defaultdict(dict)
1961 for mol
in IMP.pmi.tools.get_molecules(input_objects):
1964 moldict[name][c]=mol
1967 def get_selections_dictionary(input_objects):
1968 moldict=IMP.pmi.tools.get_molecules_dictionary(input_objects)
1969 seldict=defaultdict(list)
1970 for name, mols
in moldict.items():
1975 def get_densities(input_objects):
1976 """Given a list of PMI objects, returns all density hierarchies within
1977 these objects. The output of this function can be inputted into
1978 things such as EM restraints. This function is intended to gather density particles
1979 appended to molecules (and not other hierarchies which might have been appended to the root node directly).
1983 molecules=get_molecules(input_objects)
1986 densities+=
IMP.atom.Selection(i,representation_type=IMP.atom.DENSITIES).get_selected_particles()
1989 def shuffle_configuration(objects,
1990 max_translation=300., max_rotation=2.0 * pi,
1991 avoidcollision_rb=
True, avoidcollision_fb=
False,
1992 cutoff=10.0, niterations=100,
1994 excluded_rigid_bodies=[],
1995 hierarchies_excluded_from_collision=[],
1996 hierarchies_included_in_collision=[],
1998 return_debug=
False):
1999 """Shuffle particles. Used to restart the optimization.
2000 The configuration of the system is initialized by placing each
2001 rigid body and each bead randomly in a box. If `bounding_box` is
2002 specified, the particles are placed inside this box; otherwise, each
2003 particle is displaced by up to max_translation angstroms, and randomly
2004 rotated. Effort is made to place particles far enough from each other to
2005 prevent any steric clashes.
2006 @param objects Can be one of the following inputs:
2007 IMP Hierarchy, PMI System/State/Molecule/TempResidue, or a list/set of them
2008 @param max_translation Max translation (rbs and flexible beads)
2009 @param max_rotation Max rotation (rbs only)
2010 @param avoidcollision_rb check if the particle/rigid body was
2011 placed close to another particle; uses the optional
2012 arguments cutoff and niterations
2013 @param avoidcollision_fb Advanced. Generally you want this False because it's hard to shuffle beads.
2014 @param cutoff Distance less than this is a collision
2015 @param niterations How many times to try avoiding collision
2016 @param bounding_box Only shuffle particles within this box. Defined by ((x1,y1,z1),(x2,y2,z2)).
2017 @param excluded_rigid_bodies Don't shuffle these rigid body objects
2018 @param hierarchies_excluded_from_collision Don't count collision with these bodies
2019 @param hierarchies_included_in_collision Hierarchies that are not shuffled, but should be included in collision calculation (for fixed regions)
2020 @param verbose Give more output
2021 @note Best to only call this function after you've set up degrees of freedom
2022 For debugging purposes, returns: <shuffled indexes>, <collision avoided indexes>
2026 hierarchies = IMP.pmi.tools.input_adaptor(objects,
2027 pmi_resolution=
'all',
2029 rigid_bodies,flexible_beads = get_rbs_and_beads(hierarchies)
2030 if len(rigid_bodies)>0:
2031 mdl = rigid_bodies[0].get_model()
2032 elif len(flexible_beads)>0:
2033 mdl = flexible_beads[0].get_model()
2035 raise Exception(
"Could not find any particles in the hierarchy")
2036 if len(rigid_bodies) == 0:
2037 print(
"shuffle_configuration: rigid bodies were not intialized")
2041 gcpf.set_distance(cutoff)
2044 collision_excluded_hierarchies = IMP.pmi.tools.input_adaptor(hierarchies_excluded_from_collision,
2045 pmi_resolution=
'all',
2048 collision_included_hierarchies = IMP.pmi.tools.input_adaptor(hierarchies_included_in_collision,
2049 pmi_resolution=
'all',
2052 collision_excluded_idxs = set([l.get_particle().
get_index()
for h
in collision_excluded_hierarchies \
2055 collision_included_idxs = set([l.get_particle().
get_index()
for h
in collision_included_hierarchies \
2060 for p
in IMP.pmi.tools.get_all_leaves(hierarchies):
2062 all_idxs.append(p.get_particle_index())
2064 collision_excluded_idxs.add(p.get_particle_index())
2066 if bounding_box
is not None:
2067 ((x1, y1, z1), (x2, y2, z2)) = bounding_box
2072 all_idxs = set(all_idxs) | collision_included_idxs
2073 all_idxs = all_idxs - collision_excluded_idxs
2075 print(
'shuffling', len(rigid_bodies),
'rigid bodies')
2076 for rb
in rigid_bodies:
2077 if rb
not in excluded_rigid_bodies:
2079 if avoidcollision_rb:
2080 rb_idxs = set(rb.get_member_particle_indexes()) - \
2081 collision_excluded_idxs
2082 other_idxs = all_idxs - rb_idxs
2088 while niter < niterations:
2089 rbxyz = (rb.get_x(), rb.get_y(), rb.get_z())
2109 debug.append([rb, other_idxs
if avoidcollision_rb
else set()])
2113 if avoidcollision_rb:
2115 npairs = len(gcpf.get_close_pairs(mdl,
2124 print(
"shuffle_configuration: rigid body placed close to other %d particles, trying again..." % npairs)
2125 print(
"shuffle_configuration: rigid body name: " + rb.get_name())
2126 if niter == niterations:
2127 raise ValueError(
"tried the maximum number of iterations to avoid collisions, increase the distance cutoff")
2131 print(
'shuffling', len(flexible_beads),
'flexible beads')
2132 for fb
in flexible_beads:
2134 if avoidcollision_fb:
2136 other_idxs = all_idxs - fb_idxs
2142 while niter < niterations:
2155 xyz = memb.get_internal_coordinates()
2160 rf = memb.get_rigid_body().get_reference_frame()
2161 glob_to_int = rf.get_transformation_from()
2162 memb.set_internal_coordinates(
2163 glob_to_int.get_transformed(translation))
2165 xyz_transformed=transformation.get_transformed(xyz)
2166 memb.set_internal_coordinates(xyz_transformed)
2167 debug.append([xyz,other_idxs
if avoidcollision_fb
else set()])
2174 debug.append([d,other_idxs
if avoidcollision_fb
else set()])
2180 if avoidcollision_fb:
2182 npairs = len(gcpf.get_close_pairs(mdl,
2190 print(
"shuffle_configuration: floppy body placed close to other %d particles, trying again..." % npairs)
2191 if niter == niterations:
2192 raise ValueError(
"tried the maximum number of iterations to avoid collisions, increase the distance cutoff")
2198 class ColorHierarchy(object):
2200 def __init__(self,hier):
2201 import matplotlib
as mpl
2203 import matplotlib.pyplot
as plt
2207 hier.ColorHierarchy=self
2211 self.method=self.nochange
2219 def get_color(self,fl):
2222 def get_log_scale(self,fl):
2225 return math.log(fl+eps)
2227 def color_by_resid(self):
2228 self.method=self.color_by_resid
2229 self.scheme=self.mpl.cm.rainbow
2230 for mol
in self.mols:
2236 c=self.get_color(float(ri)/self.last)
2240 avr=sum(ris)/len(ris)
2241 c=self.get_color(float(avr)/self.last)
2244 def color_by_uncertainty(self):
2245 self.method=self.color_by_uncertainty
2246 self.scheme=self.mpl.cm.jet
2253 self.first=self.get_log_scale(1.0)
2254 self.last=self.get_log_scale(100.0)
2256 value=self.get_log_scale(unc_dict[p])
2257 if value>=self.last: value=self.last
2258 if value<=self.first: value=self.first
2259 c=self.get_color((value-self.first)/(self.last-self.first))
2262 def get_color_bar(self,filename):
2263 import matplotlib
as mpl
2265 import matplotlib.pyplot
as plt
2268 fig = plt.figure(figsize=(8, 3))
2269 ax1 = fig.add_axes([0.05, 0.80, 0.9, 0.15])
2272 norm = mpl.colors.Normalize(vmin=0.0, vmax=1.0)
2274 if self.method == self.color_by_uncertainty:
2275 angticks=[1.0,2.5,5.0,10.0,25.0,50.0,100.0]
2279 vvalue=(self.get_log_scale(at)-self.first)/(self.last-self.first)
2280 if vvalue <= 1.0
and vvalue >= 0.0:
2281 vvalues.append(vvalue)
2282 marks.append(str(at))
2283 cb1 = mpl.colorbar.ColorbarBase(ax1, cmap=cmap,
2286 orientation=
'horizontal')
2287 print(self.first,self.last,marks,vvalues)
2288 cb1.ax.set_xticklabels(marks)
2289 cb1.set_label(
'Angstorm')
2290 plt.savefig(filename, dpi=150, transparent=
True)
2296 def color2rgb(colorname):
2297 """Given a chimera color name, return RGB"""
2298 d = {
'aquamarine': (0.4980392156862745, 1.0, 0.8313725490196079),
2299 'black': (0.0, 0.0, 0.0),
2300 'blue': (0.0, 0.0, 1.0),
2301 'brown': (0.6470588235294118, 0.16470588235294117, 0.16470588235294117),
2302 'chartreuse': (0.4980392156862745, 1.0, 0.0),
2303 'coral': (1.0, 0.4980392156862745, 0.3137254901960784),
2304 'cornflower blue': (0.39215686274509803, 0.5843137254901961, 0.9294117647058824),
2305 'cyan': (0.0, 1.0, 1.0),
2306 'dark cyan': (0.0, 0.5450980392156862, 0.5450980392156862),
2307 'dark gray': (0.6627450980392157, 0.6627450980392157, 0.6627450980392157),
2308 'dark green': (0.0, 0.39215686274509803, 0.0),
2309 'dark khaki': (0.7411764705882353, 0.7176470588235294, 0.4196078431372549),
2310 'dark magenta': (0.5450980392156862, 0.0, 0.5450980392156862),
2311 'dark olive green': (0.3333333333333333, 0.4196078431372549, 0.1843137254901961),
2312 'dark red': (0.5450980392156862, 0.0, 0.0),
2313 'dark slate blue': (0.2823529411764706, 0.23921568627450981, 0.5450980392156862),
2314 'dark slate gray': (0.1843137254901961, 0.30980392156862746, 0.30980392156862746),
2315 'deep pink': (1.0, 0.0784313725490196, 0.5764705882352941),
2316 'deep sky blue': (0.0, 0.7490196078431373, 1.0),
2317 'dim gray': (0.4117647058823529, 0.4117647058823529, 0.4117647058823529),
2318 'dodger blue': (0.11764705882352941, 0.5647058823529412, 1.0),
2319 'firebrick': (0.6980392156862745, 0.13333333333333333, 0.13333333333333333),
2320 'forest green': (0.13333333333333333, 0.5450980392156862, 0.13333333333333333),
2321 'gold': (1.0, 0.8431372549019608, 0.0),
2322 'goldenrod': (0.8549019607843137, 0.6470588235294118, 0.12549019607843137),
2323 'gray': (0.7450980392156863, 0.7450980392156863, 0.7450980392156863),
2324 'green': (0.0, 1.0, 0.0),
2325 'hot pink': (1.0, 0.4117647058823529, 0.7058823529411765),
2326 'khaki': (0.9411764705882353, 0.9019607843137255, 0.5490196078431373),
2327 'light blue': (0.6784313725490196, 0.8470588235294118, 0.9019607843137255),
2328 'light gray': (0.8274509803921568, 0.8274509803921568, 0.8274509803921568),
2329 'light green': (0.5647058823529412, 0.9333333333333333, 0.5647058823529412),
2330 'light sea green': (0.12549019607843137, 0.6980392156862745, 0.6666666666666666),
2331 'lime green': (0.19607843137254902, 0.803921568627451, 0.19607843137254902),
2332 'magenta': (1.0, 0.0, 1.0),
2333 'medium blue': (0.19607843137254902, 0.19607843137254902, 0.803921568627451),
2334 'medium purple': (0.5764705882352941, 0.4392156862745098, 0.8588235294117647),
2335 'navy blue': (0.0, 0.0, 0.5019607843137255),
2336 'olive drab': (0.4196078431372549, 0.5568627450980392, 0.13725490196078433),
2337 'orange red': (1.0, 0.27058823529411763, 0.0),
2338 'orange': (1.0, 0.4980392156862745, 0.0),
2339 'orchid': (0.8549019607843137, 0.4392156862745098, 0.8392156862745098),
2340 'pink': (1.0, 0.7529411764705882, 0.796078431372549),
2341 'plum': (0.8666666666666667, 0.6274509803921569, 0.8666666666666667),
2342 'purple': (0.6274509803921569, 0.12549019607843137, 0.9411764705882353),
2343 'red': (1.0, 0.0, 0.0),
2344 'rosy brown': (0.7372549019607844, 0.5607843137254902, 0.5607843137254902),
2345 'salmon': (0.9803921568627451, 0.5019607843137255, 0.4470588235294118),
2346 'sandy brown': (0.9568627450980393, 0.6431372549019608, 0.3764705882352941),
2347 'sea green': (0.1803921568627451, 0.5450980392156862, 0.3411764705882353),
2348 'sienna': (0.6274509803921569, 0.3215686274509804, 0.17647058823529413),
2349 'sky blue': (0.5294117647058824, 0.807843137254902, 0.9215686274509803),
2350 'slate gray': (0.4392156862745098, 0.5019607843137255, 0.5647058823529412),
2351 'spring green': (0.0, 1.0, 0.4980392156862745),
2352 'steel blue': (0.27450980392156865, 0.5098039215686274, 0.7058823529411765),
2353 'tan': (0.8235294117647058, 0.7058823529411765, 0.5490196078431373),
2354 'turquoise': (0.25098039215686274, 0.8784313725490196, 0.8156862745098039),
2355 'violet red': (0.8156862745098039, 0.12549019607843137, 0.5647058823529412),
2356 'white': (1.0, 1.0, 1.0),
2357 'yellow': (1.0, 1.0, 0.0)}
2361 "If you use this class please let the PMI developers know.")
2365 "reds":[(
"maroon",
"#800000",(128,0,0)),(
"dark red",
"#8B0000",(139,0,0)),
2366 (
"brown",
"#A52A2A",(165,42,42)),(
"firebrick",
"#B22222",(178,34,34)),
2367 (
"crimson",
"#DC143C",(220,20,60)),(
"red",
"#FF0000",(255,0,0)),
2368 (
"tomato",
"#FF6347",(255,99,71)),(
"coral",
"#FF7F50",(255,127,80)),
2369 (
"indian red",
"#CD5C5C",(205,92,92)),(
"light coral",
"#F08080",(240,128,128)),
2370 (
"dark salmon",
"#E9967A",(233,150,122)),(
"salmon",
"#FA8072",(250,128,114)),
2371 (
"light salmon",
"#FFA07A",(255,160,122)),(
"orange red",
"#FF4500",(255,69,0)),
2372 (
"dark orange",
"#FF8C00",(255,140,0))],
2373 "yellows":[(
"orange",
"#FFA500",(255,165,0)),(
"gold",
"#FFD700",(255,215,0)),
2374 (
"dark golden rod",
"#B8860B",(184,134,11)),(
"golden rod",
"#DAA520",(218,165,32)),
2375 (
"pale golden rod",
"#EEE8AA",(238,232,170)),(
"dark khaki",
"#BDB76B",(189,183,107)),
2376 (
"khaki",
"#F0E68C",(240,230,140)),(
"olive",
"#808000",(128,128,0)),
2377 (
"yellow",
"#FFFF00",(255,255,0)),(
"antique white",
"#FAEBD7",(250,235,215)),
2378 (
"beige",
"#F5F5DC",(245,245,220)),(
"bisque",
"#FFE4C4",(255,228,196)),
2379 (
"blanched almond",
"#FFEBCD",(255,235,205)),(
"wheat",
"#F5DEB3",(245,222,179)),
2380 (
"corn silk",
"#FFF8DC",(255,248,220)),(
"lemon chiffon",
"#FFFACD",(255,250,205)),
2381 (
"light golden rod yellow",
"#FAFAD2",(250,250,210)),(
"light yellow",
"#FFFFE0",(255,255,224))],
2382 "greens":[(
"yellow green",
"#9ACD32",(154,205,50)),(
"dark olive green",
"#556B2F",(85,107,47)),
2383 (
"olive drab",
"#6B8E23",(107,142,35)),(
"lawn green",
"#7CFC00",(124,252,0)),
2384 (
"chart reuse",
"#7FFF00",(127,255,0)),(
"green yellow",
"#ADFF2F",(173,255,47)),
2385 (
"dark green",
"#006400",(0,100,0)),(
"green",
"#008000",(0,128,0)),
2386 (
"forest green",
"#228B22",(34,139,34)),(
"lime",
"#00FF00",(0,255,0)),
2387 (
"lime green",
"#32CD32",(50,205,50)),(
"light green",
"#90EE90",(144,238,144)),
2388 (
"pale green",
"#98FB98",(152,251,152)),(
"dark sea green",
"#8FBC8F",(143,188,143)),
2389 (
"medium spring green",
"#00FA9A",(0,250,154)),(
"spring green",
"#00FF7F",(0,255,127)),
2390 (
"sea green",
"#2E8B57",(46,139,87)),(
"medium aqua marine",
"#66CDAA",(102,205,170)),
2391 (
"medium sea green",
"#3CB371",(60,179,113)),(
"light sea green",
"#20B2AA",(32,178,170)),
2392 (
"dark slate gray",
"#2F4F4F",(47,79,79)),(
"teal",
"#008080",(0,128,128)),
2393 (
"dark cyan",
"#008B8B",(0,139,139))],
2394 "blues":[(
"dark turquoise",
"#00CED1",(0,206,209)),
2395 (
"turquoise",
"#40E0D0",(64,224,208)),(
"medium turquoise",
"#48D1CC",(72,209,204)),
2396 (
"pale turquoise",
"#AFEEEE",(175,238,238)),(
"aqua marine",
"#7FFFD4",(127,255,212)),
2397 (
"powder blue",
"#B0E0E6",(176,224,230)),(
"cadet blue",
"#5F9EA0",(95,158,160)),
2398 (
"steel blue",
"#4682B4",(70,130,180)),(
"corn flower blue",
"#6495ED",(100,149,237)),
2399 (
"deep sky blue",
"#00BFFF",(0,191,255)),(
"dodger blue",
"#1E90FF",(30,144,255)),
2400 (
"light blue",
"#ADD8E6",(173,216,230)),(
"sky blue",
"#87CEEB",(135,206,235)),
2401 (
"light sky blue",
"#87CEFA",(135,206,250)),(
"midnight blue",
"#191970",(25,25,112)),
2402 (
"navy",
"#000080",(0,0,128)),(
"dark blue",
"#00008B",(0,0,139)),
2403 (
"medium blue",
"#0000CD",(0,0,205)),(
"blue",
"#0000FF",(0,0,255)),(
"royal blue",
"#4169E1",(65,105,225)),
2404 (
"aqua",
"#00FFFF",(0,255,255)),(
"cyan",
"#00FFFF",(0,255,255)),(
"light cyan",
"#E0FFFF",(224,255,255))],
2405 "violets":[(
"blue violet",
"#8A2BE2",(138,43,226)),(
"indigo",
"#4B0082",(75,0,130)),
2406 (
"dark slate blue",
"#483D8B",(72,61,139)),(
"slate blue",
"#6A5ACD",(106,90,205)),
2407 (
"medium slate blue",
"#7B68EE",(123,104,238)),(
"medium purple",
"#9370DB",(147,112,219)),
2408 (
"dark magenta",
"#8B008B",(139,0,139)),(
"dark violet",
"#9400D3",(148,0,211)),
2409 (
"dark orchid",
"#9932CC",(153,50,204)),(
"medium orchid",
"#BA55D3",(186,85,211)),
2410 (
"purple",
"#800080",(128,0,128)),(
"thistle",
"#D8BFD8",(216,191,216)),
2411 (
"plum",
"#DDA0DD",(221,160,221)),(
"violet",
"#EE82EE",(238,130,238)),
2412 (
"magenta / fuchsia",
"#FF00FF",(255,0,255)),(
"orchid",
"#DA70D6",(218,112,214)),
2413 (
"medium violet red",
"#C71585",(199,21,133)),(
"pale violet red",
"#DB7093",(219,112,147)),
2414 (
"deep pink",
"#FF1493",(255,20,147)),(
"hot pink",
"#FF69B4",(255,105,180)),
2415 (
"light pink",
"#FFB6C1",(255,182,193)),(
"pink",
"#FFC0CB",(255,192,203))],
2416 "browns":[(
"saddle brown",
"#8B4513",(139,69,19)),(
"sienna",
"#A0522D",(160,82,45)),
2417 (
"chocolate",
"#D2691E",(210,105,30)),(
"peru",
"#CD853F",(205,133,63)),
2418 (
"sandy brown",
"#F4A460",(244,164,96)),(
"burly wood",
"#DEB887",(222,184,135)),
2419 (
"tan",
"#D2B48C",(210,180,140)),(
"rosy brown",
"#BC8F8F",(188,143,143)),
2420 (
"moccasin",
"#FFE4B5",(255,228,181)),(
"navajo white",
"#FFDEAD",(255,222,173)),
2421 (
"peach puff",
"#FFDAB9",(255,218,185)),(
"misty rose",
"#FFE4E1",(255,228,225)),
2422 (
"lavender blush",
"#FFF0F5",(255,240,245)),(
"linen",
"#FAF0E6",(250,240,230)),
2423 (
"old lace",
"#FDF5E6",(253,245,230)),(
"papaya whip",
"#FFEFD5",(255,239,213)),
2424 (
"sea shell",
"#FFF5EE",(255,245,238))],
2425 "greys":[(
"black",
"#000000",(0,0,0)),(
"dim gray / dim grey",
"#696969",(105,105,105)),
2426 (
"gray / grey",
"#808080",(128,128,128)),(
"dark gray / dark grey",
"#A9A9A9",(169,169,169)),
2427 (
"silver",
"#C0C0C0",(192,192,192)),(
"light gray / light grey",
"#D3D3D3",(211,211,211)),
2428 (
"gainsboro",
"#DCDCDC",(220,220,220)),(
"white smoke",
"#F5F5F5",(245,245,245)),
2429 (
"white",
"#FFFFFF",(255,255,255))]}
2431 def assign_color_group(self,color_group,representation,component_names):
2432 for n,p
in enumerate(component_names):
2434 psel=s.get_selected_particles()
2435 ctuple=self.colors[color_group][n]
2436 print(
"Assigning "+p+
" to color "+ctuple[0])
2445 def get_list_distant_colors(self):
2446 cnames = [
'#F0F8FF',
'#FAEBD7',
'#00FFFF',
'#7FFFD4',
'#F0FFFF',
'#F5F5DC',
2447 '#FFE4C4',
'#000000',
'#FFEBCD',
'#0000FF',
'#8A2BE2',
'#A52A2A',
'#DEB887',
2448 '#5F9EA0',
'#7FFF00',
'#D2691E',
'#FF7F50',
'#6495ED',
'#FFF8DC',
'#DC143C',
2449 '#00FFFF',
'#00008B',
'#008B8B',
'#B8860B',
'#A9A9A9',
'#006400',
'#BDB76B',
2450 '#8B008B',
'#556B2F',
'#FF8C00',
'#9932CC',
'#8B0000',
'#E9967A',
'#8FBC8F',
2451 '#483D8B',
'#2F4F4F',
'#00CED1',
'#9400D3',
'#FF1493',
'#00BFFF',
'#696969',
2452 '#1E90FF',
'#B22222',
'#FFFAF0',
'#228B22',
'#FF00FF',
'#DCDCDC',
'#F8F8FF',
2453 '#FFD700',
'#DAA520',
'#808080',
'#008000',
'#ADFF2F',
'#F0FFF0',
'#FF69B4',
2454 '#CD5C5C',
'#4B0082',
'#FFFFF0',
'#F0E68C',
'#E6E6FA',
'#FFF0F5',
'#7CFC00',
2455 '#FFFACD',
'#ADD8E6',
'#F08080',
'#E0FFFF',
'#FAFAD2',
'#90EE90',
'#D3D3D3',
2456 '#FFB6C1',
'#FFA07A',
'#20B2AA',
'#87CEFA',
'#778899',
'#B0C4DE',
'#FFFFE0',
2457 '#00FF00',
'#32CD32',
'#FAF0E6',
'#FF00FF',
'#800000',
'#66CDAA',
'#0000CD',
2458 '#BA55D3',
'#9370DB',
'#3CB371',
'#7B68EE',
'#00FA9A',
'#48D1CC',
'#C71585',
2459 '#191970',
'#F5FFFA',
'#FFE4E1',
'#FFE4B5',
'#FFDEAD',
'#000080',
'#FDF5E6',
2460 '#808000',
'#6B8E23',
'#FFA500',
'#FF4500',
'#DA70D6',
'#EEE8AA',
'#98FB98',
2461 '#AFEEEE',
'#DB7093',
'#FFEFD5',
'#FFDAB9',
'#CD853F',
'#FFC0CB',
'#DDA0DD',
2462 '#B0E0E6',
'#800080',
'#FF0000',
'#BC8F8F',
'#4169E1',
'#8B4513',
'#FA8072',
2463 '#FAA460',
'#2E8B57',
'#FFF5EE',
'#A0522D',
'#C0C0C0',
'#87CEEB',
'#6A5ACD',
2464 '#708090',
'#FFFAFA',
'#00FF7F',
'#4682B4',
'#D2B48C',
'#008080',
'#D8BFD8',
2465 '#FF6347',
'#40E0D0',
'#EE82EE',
'#F5DEB3',
'#FFFFFF',
'#F5F5F5',
'#FFFF00',
static bool get_is_setup(const IMP::ParticleAdaptor &p)
static bool get_is_setup(const IMP::ParticleAdaptor &p)
A decorator to associate a particle with a part of a protein/DNA/RNA.
Extends the functionality of IMP.atom.Molecule.
def add_script_provenance
Tag the given particle with the current Python script.
static bool get_is_setup(const IMP::ParticleAdaptor &p)
void add_particles(RMF::FileHandle fh, const ParticlesTemp &hs)
Set of Python classes to create a multi-state, multi-resolution IMP hierarchy.
static Weight setup_particle(Model *m, ParticleIndex pi)
A decorator for a particle which has bonds.
double get_drmsd(const Vector3DsOrXYZs0 &m0, const Vector3DsOrXYZs1 &m1)
Calculate distance the root mean square deviation between two sets of 3D points.
Rotation3D get_random_rotation_3d(const Rotation3D ¢er, double distance)
Pick a rotation at random near the provided one.
def deprecated_function
Python decorator to mark a function as deprecated.
std::string get_module_version()
IMP::Vector< Color > Colors
ParticlesTemp get_particles(Model *m, const ParticleIndexes &ps)
static Surface setup_particle(Model *m, ParticleIndex pi)
Add uncertainty to a particle.
void add_particle(RMF::FileHandle fh, Particle *hs)
static bool get_is_setup(const IMP::ParticleAdaptor &p)
static bool get_is_setup(const IMP::ParticleAdaptor &p)
GenericHierarchies get_leaves(Hierarchy mhd)
Get all the leaves of the bit of hierarchy.
This class initializes the root node of the global IMP.atom.Hierarchy.
double get_distance(XYZR a, XYZR b)
Compute the sphere distance between a and b.
def add_imp_provenance
Tag the given particle as being created by the current version of IMP.
Vector3D get_random_vector_in(const Cylinder3D &c)
Generate a random vector in a cylinder with uniform density.
Add resolution to a particle.
Bond create_bond(Bonded a, Bonded b, Bond o)
Connect the two wrapped particles by a custom bond.
Object used to hold a set of restraints.
algebra::GridD< 3, algebra::DenseGridStorageD< 3, float >, float > get_grid(DensityMap *in_map)
Return a dense grid containing the voxels of the passed density map.
Stores a named protein chain.
static bool get_is_setup(Model *m, ParticleIndex pi)
def add_software_provenance
Tag the given particle with the software used to create it.
A decorator for keeping track of copies of a molecule.
ParticleIndexPairs get_indexes(const ParticlePairsTemp &ps)
static bool get_is_setup(Model *m, ParticleIndex pi)
The standard decorator for manipulating molecular structures.
Ints get_index(const ParticlesTemp &particles, const Subset &subset, const Subsets &excluded)
A decorator for a particle representing an atom.
void transform(XYZ a, const algebra::Transformation3D &tr)
Apply a transformation to the particle.
static Bonded setup_particle(Model *m, ParticleIndex pi)
void load_frame(RMF::FileConstHandle file, RMF::FrameID frame)
Load the given RMF frame into the state of the linked objects.
A decorator for a particle with x,y,z coordinates.
static Scale setup_particle(Model *m, ParticleIndex pi)
static Colored setup_particle(Model *m, ParticleIndex pi, Color color)
A decorator for a particle that is part of a rigid body but not rigid.
std::ostream & show(Hierarchy h, std::ostream &out=std::cout)
Print the hierarchy using a given decorator to display each node.
Find all nearby pairs by testing all pairs.
static bool get_is_setup(const IMP::ParticleAdaptor &p)
def deprecated_object
Python decorator to mark a class as deprecated.
A decorator for a residue.
General purpose algebraic and geometric methods that are expected to be used by a wide variety of IMP...
static bool get_is_setup(const IMP::ParticleAdaptor &p)
static bool get_is_setup(Model *m, ParticleIndex p)
Check if the particle has the needed attributes for a cast to succeed.
The general base class for IMP exceptions.
Rotation3D get_identity_rotation_3d()
Return a rotation that does not do anything.
void link_hierarchies(RMF::FileConstHandle fh, const atom::Hierarchies &hs)
Class to handle individual particles of a Model object.
Bond get_bond(Bonded a, Bonded b)
Get the bond between two particles.
Stores a list of Molecules all with the same State index.
std::string get_data_path(std::string file_name)
Return the full path to one of this module's data files.
int get_copy_index(Hierarchy h)
Walk up the hierarchy to find the current copy index.
Python classes to represent, score, sample and analyze models.
static bool get_is_setup(Model *m, ParticleIndex pi)
double get_resolution(Model *m, ParticleIndex pi)
Estimate the resolution of the hierarchy as used by Representation.
A decorator for a rigid body.
static bool get_is_setup(const IMP::ParticleAdaptor &p)
Hierarchies get_leaves(const Selection &h)
A decorator for a molecule.
Select hierarchy particles identified by the biological name.
Support for the RMF file format for storing hierarchical molecular data and markup.
static bool get_is_setup(const IMP::ParticleAdaptor &p)
Transformation3D get_random_local_transformation(Vector3D origin, double max_translation=5., double max_angle_in_rad=0.26)
Get a local transformation.
Temporarily stores residue information, even without structure available.
Inferential scoring building on methods developed as part of the Inferential Structure Determination ...