def __init__(self, references, clones_list, transforms, label='', strength=10.0, ca_only=False): """Constructor @param references Can be one of the following inputs: IMP Hierarchy, PMI System/State/Molecule/TempResidue, or a list/set of them @param clones_list List of lists of the above @param transforms Transforms moving each selection to the first selection @param label Label for output @param strength The elastic bond strength @param ca_only Optionally select so only CAlpha particles are used """ refs = IMP.pmi.tools.input_adaptor(references, flatten=True) self.mdl = refs[0].get_model() self.rs = IMP.RestraintSet(self.mdl, "Symmetry") self.weight = 1 self.label = label if len(clones_list) != len(transforms): raise Exception( 'Error: There should be as many clones as transforms') harmonic = IMP.core.Harmonic(0., strength) for tmp_clones, trans in zip(clones_list, transforms): clones = IMP.pmi.tools.input_adaptor(tmp_clones, flatten=True) if len(clones) != len(refs): raise Exception("Error: len(references)!=len(clones)") pair_score = IMP.core.TransformedDistancePairScore(harmonic, trans) for p0, p1 in zip(refs, clones): if not ca_only or (IMP.atom.Atom(p0).get_atom_type() == IMP.atom.AtomType("CA") and IMP.atom.Atom(p1).get_atom_type() == IMP.atom.AtomType("CA")): r = IMP.core.PairRestraint( self.mdl, pair_score, [p0.get_particle_index(), p1.get_particle_index()]) self.rs.add_restraint(r) print('created symmetry network with', self.rs.get_number_of_restraints(), 'restraints')
def test_xyz_particles(self): m = IMP.Model() ps = [] hs = [] for i in range(10): p = IMP.Particle(m) h = IMP.atom.Hierarchy.setup_particle(p) d = IMP.core.XYZR.setup_particle(p) IMP.atom.Mass.setup_particle(p, 1.0) d.set_coordinates( IMP.algebra.get_random_vector_in( IMP.algebra.Sphere3D((0, 0, 0), 10))) d.set_radius(1) ps.append(p) hs.append(h) srbm = IMP.pmi.TransformMover(m, 1, 0.5) #origin point origin = IMP.Particle(m) d = IMP.core.XYZR.setup_particle(origin) d.set_coordinates((0, 0, 0)) d.set_radius(1) rs = IMP.RestraintSet(m) ts1 = IMP.core.Harmonic(10, 10) dr = IMP.core.DistanceRestraint(m, ts1, ps[0], origin) for p in ps: srbm.add_xyz_particle(IMP.core.XYZ(p)) smv = IMP.core.SerialMover([srbm]) mc = IMP.core.MonteCarlo(m) mc.set_scoring_function([dr]) mc.set_return_best(False) mc.set_kt(1.0) mc.add_mover(smv) rh = RMF.create_rmf_file("test_transform_mover_xyz.rmf3") IMP.rmf.add_hierarchies(rh, hs) for n in range(10): mc.optimize(1) IMP.rmf.save_frame(rh) del rh
def __init__( self, representation, handleparticles_tuples, compositeparticles_tuple_list, cut_off=5.0, lam=1.0, plateau=0.0, resolution=None, label="None"): # composite particles: all particles beside the handle self.label = label self.m = representation.prot.get_model() self.rs = IMP.RestraintSet(self.m, 'cr') self.handleparticles = [] for s in handleparticles_tuples: self.handleparticles += IMP.pmi.tools.select_by_tuple(representation, s, resolution=resolution, name_is_ambiguous=True) self.compositeparticles=[] compositeparticle_list = [] for list in compositeparticles_tuple_list: tmplist = [] for s in list: tmplist += IMP.pmi.tools.select_by_tuple( representation, s, resolution=resolution, name_is_ambiguous=True) compositeparticle_list.append(tmplist) self.compositeparticles+=tmplist ln = IMP.pmi.CompositeRestraint( self.m, self.handleparticles, cut_off, lam, True, plateau) for ps in compositeparticle_list: # composite particles is a list of list of particles ln.add_composite_particle(ps) self.rs.add_restraint(ln)
def __init__(self, representation, selection_tuple, distance=3.78, strength=10.0, jitter=None): """Constructor @param representation @param selection_tuple Requested selection @param distance Resting distance for restraint @param strength Bond constant @param jitter Defines the +- added to the optimal distance in the harmonic well restraint used to increase the tolerance """ self.m = representation.prot.get_model() self.rs = IMP.RestraintSet(self.m, "Bonds") self.weight = 1 self.label = "None" self.pairslist = [] particles = IMP.pmi.tools.select_by_tuple( representation, selection_tuple, resolution=1) if not jitter: ts = IMP.core.Harmonic(distance, strength) else: ts = IMP.core.HarmonicWell( (distance - jitter, distance + jitter), strength) for ps in IMP.pmi.tools.sublist_iterator(particles, 2, 2): pair = [] if len(ps) != 2: raise ValueError("wrong length of pair") for p in ps: if not IMP.atom.Residue.get_is_setup(p): raise TypeError("not a residue") else: pair.append(p) print("ResidueBondRestraint: adding a restraint between %s %s" % (pair[0].get_name(), pair[1].get_name())) self.rs.add_restraint( IMP.core.DistanceRestraint(self.m, ts, pair[0], pair[1])) self.pairslist.append(IMP.ParticlePair(pair[0], pair[1])) self.pairslist.append(IMP.ParticlePair(pair[1], pair[0]))
def test_some_scores(self): pdb_fn = self.get_input_file_name('helix2.pdb') mdl = IMP.Model() mh = IMP.atom.read_pdb(pdb_fn, mdl, IMP.atom.NonWaterPDBSelector()) ps = IMP.atom.Selection( mh, atom_type=IMP.atom.AtomType("CA")).get_selected_particles() strength = 10.0 rs = IMP.RestraintSet(mdl, "ElasticNetwork") for pidx in itertools.combinations(range(len(ps)), 2): pair = [ps[pidx[0]], ps[pidx[1]]] distance = IMP.algebra.get_distance( IMP.core.XYZ(pair[0]).get_coordinates(), IMP.core.XYZ(pair[1]).get_coordinates()) ts = IMP.core.Harmonic(distance, strength) rs.add_restraint(IMP.core.DistanceRestraint(ts, pair[0], pair[1])) mdl.add_restraint(rs) print(rs.evaluate(False))
def __init__( self, representation, images, resolution=None): self.weight=1.0 self.m = representation.prot.get_model() self.rs = IMP.RestraintSet(self.m, 'em2d') self.label = "None" # IMP.atom.get_by_type particles = IMP.pmi.tools.select( representation, resolution=resolution) em2d = None self.rs.add_restraint(em2d)
def test_decomposition_4(self): """Test cache with decomposition with nested sets""" (m, ps, r, pst, ik, cache) = self._create_stuff() rs = IMP.RestraintSet(m, 1.0, "outer") rs.set_maximum_score(2) rs.add_restraint(r) r.set_weight(3) cache.add_restraints([rs]) subset = IMP.domino.Subset(ps) rsb = cache.get_restraints(subset, [IMP.domino.Subset([p]) for p in ps]) self.assertEqual(len(rsb), 1) slc = cache.get_slice(rsb[0], subset) self.assertEqual(len(slc), len(ps)) aslc = slc.get_sliced(IMP.domino.Assignment(range(len(ps)))) self.assertEqual(len(aslc), len(ps)) score = cache.get_score(rsb[0], aslc) self.assert_(score > 1000)
def init_model_NOEs_marginal(self, prot, seqfile, tblfile, name='NOE', verbose=True, sequence_match=(1, 1)): """read TBL file and store NOE restraints, using the marginal of the lognormal with one sigma and one gamma, for the whole dataset. - prot: protein hierarchy - seqfile: a file with 3-letter sequence - tblfile: a TBL file with the restraints - name: an optional name for the restraintset - verbose: be verbose (default True) - sequence_match : (noe_start, sequence_start) Returns: data_rs """ # likelihood rs = IMP.RestraintSet(self._m, 1.0, name) # use the TBLReader to parse the TBL file. sequence = IMP.isd.utils.read_sequence_file( seqfile, first_residue_number=sequence_match[1]) tblr = IMP.isd.TBLReader.TBLReader(sequence, sequence_match=sequence_match) restraints = tblr.read_distances(tblfile, 'NOE')['NOE'] ln = IMP.isd.MarginalNOERestraint() for i, restraint in enumerate(restraints): if verbose and i % 100 == 0: print("\r%d" % i, end=' ') sys.stdout.flush() # a restraint is (contributions, dist, upper, lower, volume) # where contributions is a tuple of contributing pairs # and a pair is (c1, c2), where c1 is of the form (resno, atname) # residue numbers start at 0 pairs = [(self.find_atom(i, prot).get_particle(), self.find_atom(j, prot).get_particle()) for (i, j) in restraint[0]] pairs = IMP.container.ListPairContainer(pairs) ln.add_contribution(pairs, restraint[4]) rs.add_restraint(ln) if verbose: print("\r%d NOE contributions added" % (len(restraints))) self._m.add_restraint(rs) return rs
def test_global_min2(self): """Testing finding minima with rigid bodies""" m = IMP.Model() rbs = [self._create_rb("1", m), self._create_rb("2", m)] trs = [ ReferenceFrame3D( Transformation3D(get_identity_rotation_3d(), Vector3D(0, 0, 0))), ReferenceFrame3D( Transformation3D(get_identity_rotation_3d(), Vector3D(2, 0, 0))), ReferenceFrame3D( Transformation3D(get_identity_rotation_3d(), Vector3D(4, 0, 0))) ] ps = IMP.core.HarmonicSphereDistancePairScore(0, 1) r = IMP.core.PairRestraint( m, ps, (rbs[0].get_rigid_members()[0], rbs[1].get_rigid_members()[0])) r.set_name("restraint") rs = IMP.RestraintSet(m) rs.add_restraint(r) r.set_maximum_score(.5) pst = IMP.domino.ParticleStatesTable() pstate = IMP.domino.RigidBodyStates(trs) pst.set_particle_states(rbs[0], pstate) pst.set_particle_states(rbs[1], pstate) rg = IMP.domino.get_restraint_graph(rs, pst) # rg.show_dotty() print("ig") ig = IMP.domino.get_interaction_graph([rs], pst) # IMP.show_graphviz(ig) print("dg") IMP.set_log_level(IMP.VERBOSE) dg = IMP.get_dependency_graph(m) # IMP.show_graphviz(dg) print("jt") jt = IMP.domino.get_junction_tree(ig) # jt.show_dotty() s = IMP.domino.DominoSampler(m, pst) s.set_restraints([rs]) s.set_log_level(IMP.VERBOSE) cg = s.create_sample() self.assertEqual(cg.get_number_of_configurations(), 4)
def __init__(self, ps, dmap, resolution, origin=None, voxel_size=None, weight=1.0, label=""): """Constructor @param ps The particles to restrain. Currently these must be atomic particles. @param map_fn The EM density map to fit to @param resolution Map resolution @param origin In case you need to tell IMP the correct origin @param voxel_size In case you need to tell IMP the angstroms per pixel @param weight The data weight @param label Extra PMI label """ print('FitRestraint: setup') #print('\tmap_fn',map_fn) print('\tresolution',resolution) print('\tvoxel_size',voxel_size) print('\torigin',origin) print('\tweight',weight) # some parameters self.mdl = ps[0].get_model() self.label = label self.dmap = dmap #IMP.em.read_map(map_fn,IMP.em.MRCReaderWriter()) #dh = self.dmap.get_header() #dh.set_resolution(resolution) if voxel_size: self.dmap.update_voxel_size(voxel_size) if origin is not None: if type(origin)==IMP.algebra.Vector3D: self.dmap.set_origin(origin) elif type(origin)==list: self.dmap.set_origin(*origin) else: print('FitRestraint did not recognize format of origin') exit() fr = IMP.em.FitRestraint(ps,self.dmap) self.rs = IMP.RestraintSet(self.mdl,weight,"FitRestraint") self.rs.add_restraint(fr) self.set_weight(weight)
def __init__(self, representation, tuple_selection1, tuple_selection2, distancemin, distancemax, resolution=1.0, kappa=1.0): self.m = representation.prot.get_model() self.rs = IMP.RestraintSet(self.m, 'distance') #ts = IMP.core.Harmonic(distance,kappa) ts1 = IMP.core.HarmonicUpperBound(distancemax, kappa) ts2 = IMP.core.HarmonicLowerBound(distancemin, kappa) # IMP.atom.get_by_type particles1 = IMP.pmi.tools.select(representation, resolution=resolution, name=tuple_selection1[2], residue=tuple_selection1[0]) particles2 = IMP.pmi.tools.select(representation, resolution=resolution, name=tuple_selection2[2], residue=tuple_selection2[0]) for p in particles1: print p.get_name() for p in particles2: print p.get_name() if len(particles1) > 1: print "DistanceRestraint error: more than one particle selected" exit() if len(particles2) > 1: print "DistanceRestraint error: more than one particle selected" exit() self.rs.add_restraint( IMP.core.DistanceRestraint(ts1, particles1[0], particles2[0])) self.rs.add_restraint( IMP.core.DistanceRestraint(ts2, particles1[0], particles2[0]))
def test_refcount_director_restraints(self): """Refcounting should prevent director Restraints from being deleted""" dirchk = IMP.test.DirectorObjectChecker(self) m = IMP.Model("ref count dir restraints") rs = IMP.RestraintSet(m) IMP.set_log_level(IMP.VERBOSE) r = DummyRestraint(m) r.python_member = 'test string' rs.add_restraint(r) # Since C++ now holds a reference to r, it should be safe to delete the # Python object (director objects should not be freed while C++ holds # a reference) del r newr = rs.get_restraint(0) self.assertEqual(newr.python_member, 'test string') # Make sure that all director objects are cleaned up dirchk.assert_number(1) del newr, m, rs dirchk.assert_number(0)
def test_global_min3(self): """Testing splitting restraints with rigid bodies and interestings scores""" m = IMP.Model() rbs = [ self._create_rb("1", m, 4), self._create_rb("2", m, 4), self._create_rb("3", m, 4) ] trs = [ ReferenceFrame3D( Transformation3D(get_identity_rotation_3d(), Vector3D(0, 0, 0))), ReferenceFrame3D( Transformation3D(get_identity_rotation_3d(), Vector3D(2, 0, 0))), ReferenceFrame3D( Transformation3D(get_identity_rotation_3d(), Vector3D(4, 0, 0))) ] lps = IMP.core.SphereDistancePairScore( IMP.core.HarmonicUpperBound(0, 1)) ps = IMP.core.KClosePairsPairScore(lps, IMP.core.RigidMembersRefiner()) pl = IMP.container.ListPairContainer(m, [(rbs[0], rbs[1]), (rbs[1], rbs[2])]) r = IMP.container.PairsRestraint(ps, pl) r.set_name("restraint") rs = IMP.RestraintSet(m) rs.add_restraint(r) r.set_maximum_score(.5) dg = IMP.get_dependency_graph(m) # dg.show_dotty() pst = IMP.domino.ParticleStatesTable() pstate = IMP.domino.RigidBodyStates(trs) pst.set_particle_states(rbs[0], pstate) pst.set_particle_states(rbs[1], pstate) pst.set_particle_states(rbs[2], pstate) #occ= IMP.domino.OptimizeRestraints(m.get_root_restraint_set(), pst) rc = IMP.domino.RestraintCache(pst) rc.add_restraints([rs]) allr = rc.get_restraints() for r in allr: print(r.get_name()) self.assertEqual(len(allr), 3)
def __init__(self, representation, hierarchies=None, other_hierarchies=None, resolution=None, kappa=1.0): self.m = representation.prot.get_model() self.rs = IMP.RestraintSet(self.m, 'excluded_volume') self.weight = 1.0 self.kappa = kappa self.label = "None" self.cpc = None ssps = IMP.core.SoftSpherePairScore(self.kappa) lsa = IMP.container.ListSingletonContainer(self.m) particles = IMP.pmi.tools.select( representation, resolution=resolution, hierarchies=hierarchies) lsa.add_particles(particles) if other_hierarchies is None: rbcpf = IMP.core.RigidClosePairsFinder() self.cpc = IMP.container.ClosePairContainer(lsa, 0.0, rbcpf, 10.0) evr = IMP.container.PairsRestraint(ssps, self.cpc) else: other_lsa = IMP.container.ListSingletonContainer(self.m) other_particles = IMP.pmi.tools.select( representation, resolution=resolution, hierarchies=other_hierarchies) other_lsa.add_particles(particles) self.cpc = IMP.container.CloseBipartitePairContainer( lsa, other_lsa, 0.0, 10.0) evr = IMP.container.PairsRestraint(ssps, self.cpc) self.rs.add_restraint(evr)
def create_restraints_for_rmf(self): """ create dummy harmonic restraints for each XL but don't add to model Makes it easy to see each contribution to each XL in RMF """ dummy_mdl = IMP.Model() hps = IMP.core.HarmonicDistancePairScore(self.length, 1.0) dummy_rs = [] for nxl in range(self.rs.get_number_of_restraints()): xl = IMP.isd.AtomicCrossLinkMSRestraint.get_from( self.rs.get_restraint(nxl)) rs = IMP.RestraintSet(dummy_mdl, 'atomic_xl_' + str(nxl)) for ncontr in range(xl.get_number_of_contributions()): ps = xl.get_contribution(ncontr) dr = IMP.core.PairRestraint( hps, [self.mdl.get_particle(p) for p in ps], 'xl%i_contr%i' % (nxl, ncontr)) rs.add_restraint(dr) dummy_rs.append(MyGetRestraint(rs)) return dummy_rs
def __init__(self, root, map_fn, resolution, origin=None, voxel_size=None, weight=1.0, label="", selection_dict=None): """ create a FitRestraint. can provide rigid bodies instead of individual particles """ print('FitRestraint: setup') print('\tmap_fn', map_fn) print('\tresolution', resolution) print('\tvoxel_size', voxel_size) print('\torigin', origin) print('\tweight', weight) # some parameters self.mdl = root.get_model() self.label = label self.dmap = IMP.em.read_map(map_fn, IMP.em.MRCReaderWriter()) dh = self.dmap.get_header() dh.set_resolution(resolution) if voxel_size: self.dmap.update_voxel_size(voxel_size) if type(origin) == IMP.algebra.Vector3D: self.dmap.set_origin(origin) elif type(origin) == list: self.dmap.set_origin(*origin) else: print('FitRestraint did not recognize format of origin') exit() if selection_dict: ps = IMP.atom.Selection(root, **selection_dict).get_selected_particles() else: ps = IMP.atom.get_leaves(root) fr = IMP.em.FitRestraint(ps, self.dmap) self.rs = IMP.RestraintSet(self.mdl, weight, "FitRestraint") self.rs.add_restraint(fr) self.set_weight(weight)
def __init__( self, representation, selection_tuple, anglemin=100.0, anglemax=140.0, strength=10.0): self.m = representation.prot.get_model() self.rs = IMP.RestraintSet(self.m, "Angles") self.weight = 1 self.label = "None" self.pairslist = [] particles = IMP.pmi.tools.select_by_tuple( representation, selection_tuple, resolution=1) ts = IMP.core.HarmonicWell( (self.pi * anglemin / 180.0, self.pi * anglemax / 180.0), strength) for ps in IMP.pmi.tools.sublist_iterator(particles, 3, 3): triplet = [] if len(ps) != 3: print "ResidueAngleRestraint: wrong length of triplet" exit() for p in ps: if not IMP.atom.Residue.get_is_setup(p): print "ResidueAngleRestraint: not a residue" exit() else: triplet.append(p) print "ResidueAngleRestraint: adding a restraint between %s %s %s" % (triplet[0].get_name(), triplet[1].get_name(), triplet[2].get_name()) self.rs.add_restraint( IMP.core.AngleRestraint(ts, triplet[0], triplet[1], triplet[2])) self.pairslist.append(IMP.ParticlePair(triplet[0], triplet[2])) self.pairslist.append(IMP.ParticlePair(triplet[2], triplet[0]))
def test_delete_model_accessor_2(self): "Python Restraints from vector accessors should survive model deletion" refcnt = IMP.test.RefCountChecker(self) m = IMP.Model("restraint survival") rs = IMP.RestraintSet(m) r = IMP._ConstRestraint(m, [], 1) rs.add_restraint(r) del r # Now create new Python Restraint r from a C++ vector accessor # These accessors call specific methods in the SWIG wrapper which # are modified by typemaps in our interface. r = rs.get_restraints()[0] # Python reference r plus C++ reference from m self.assertEqual(r.get_ref_count(), 2) del m, rs # Now only the Python reference r should survive self.assertEqual(r.get_ref_count(), 1) refcnt.assert_number(1) del r refcnt.assert_number(0)
def test_delete_model_iterator(self): """Python Restraints from iterators should survive model deletion""" refcnt = IMP.test.RefCountChecker(self) m = IMP.Model("python restraint survival") rs = IMP.RestraintSet(m) r = IMP._ConstRestraint(m, [], 1) rs.add_restraint(r) del r # Now create new Python Restraint r from C++ iterator # This calls swig::from() internally, which is modified by template # specialization in our SWIG interface. r = rs.get_restraints()[0] # Python reference r plus C++ reference from m self.assertEqual(r.get_ref_count(), 2) del m, rs # Now only the Python reference r should survive self.assertEqual(r.get_ref_count(), 1) refcnt.assert_number(1) del r refcnt.assert_number(0)
def __init__(self, objects, kappa=10.0, resolution=1.0, label="None"): self.weight = 1.0 self.kappa = kappa self.label = label if self.label == "None": self.label = str(selection_tuples) # noqa: F821 hiers = [] for obj in objects: hiers.append( IMP.pmi.tools.input_adaptor(obj, resolution, flatten=True)) self.m = hiers[0][0].get_model() cr = ConnectivityNetworkRestraint(self.m) for hs in hiers: cr.add_particles([h.get_particle() for h in hs]) self.rs = IMP.RestraintSet(self.m, label) self.rs.add_restraint(cr)
def test_rescaling(self): """Test thermostatting by velocity rescaling""" for i in range(100): self.particles.append(self.create_point_particle(self.model, -43.0, 65.0, 93.0)) self.particles[-1].add_attribute(masskey, cmass, False) self.md.assign_velocities(100.0) scaler = IMP.atom.VelocityScalingOptimizerState(self.model, self.particles, 298.0) scaler.set_period(10) self.md.add_optimizer_state(scaler) r = IMP.RestraintSet(self.model) self.md.set_scoring_function(r) self.md.optimize(10) # Temperature should have been rescaled to 298.0 at some point: self._check_temperature(298.0, 0.1) # Also check immediate rescaling: scaler.set_temperature(50.0) scaler.rescale_velocities() self._check_temperature(50.0, 0.1)
def save_rmf_snapshot(self, filename): sorted_ids = None sorted_group_ids = sorted(self.cross_link_db.data_base.keys()) list_of_pairs = [] for group in sorted_group_ids: group_xls = [] group_dists_particles = [] for xl in self.cross_link_db.data_base[group]: xllabel = self.cross_link_db.get_short_cross_link_string(xl) (c1, c2, r1, r2) = IMP.pmi.io.crosslink._ProteinsResiduesArray(xl) try: (mdist, p1, p2) = self._get_distance_and_particle_pair( r1, c1, r2, c2) except TypeError: continue group_dists_particles.append((mdist, p1, p2, xllabel)) if group_dists_particles: (minmdist, minp1, minp2, minxllabel) = min(group_dists_particles, key=lambda t: t[0]) list_of_pairs.append((minp1, minp2, xllabel)) else: continue m = self.prots[0].get_model() linear = IMP.core.Linear(0, 0.0) linear.set_slope(1.0) dps2 = IMP.core.DistancePairScore(linear) rslin = IMP.RestraintSet(m, 'linear_dummy_restraints') for pair in list_of_pairs: pr = IMP.core.PairRestraint(m, dps2, (pair[0], pair[1])) pr.set_name(pair[2]) rslin.add_restraint(pr) rh = RMF.create_rmf_file(filename) IMP.rmf.add_hierarchies(rh, self.prots) IMP.rmf.add_restraints(rh, [rslin]) IMP.rmf.save_frame(rh) del rh
def test_interaction_graph(self): """Testing the interaction graph with rigid bodies""" m = IMP.Model() rb0 = self._create_rigid_body(m) rb1 = self._create_rigid_body(m) rb2 = self._create_rigid_body(m) r = IMP.core.PairRestraint(m, IMP.core.HarmonicDistancePairScore(0, 1), (rb0, rb1)) rs = IMP.RestraintSet(m) rs.add_restraint(r) dg = IMP.get_dependency_graph(m) # IMP.show_graphviz(dg) ig = IMP.domino.get_interaction_graph([rs], [rb0, rb1, rb2]) # IMP.show_graphviz(ig) for v in ig.get_vertices(): if ig.get_vertex_name(v) == rb0 or ig.get_vertex_name(v) == rb1: self.assertEqual(len(ig.get_out_neighbors(v)), 1) self.assertEqual(len(ig.get_in_neighbors(v)), 1) else: self.assertEqual(len(ig.get_out_neighbors(v)), 0) self.assertEqual(len(ig.get_in_neighbors(v)), 0)
def test_decomposition_5(self): """Test cache with simple restraint""" (m, ps, r, pst, ik, cache) = self._create_stuff() rs = IMP.RestraintSet(m, 1.0, "outer") r = IMP._ConstRestraint(1, [ps[0]]) r.set_name("const 2") rs.add_restraint(r) r.set_maximum_score(.5) cache.add_restraints([rs]) print("info:") cache.show_restraint_information() subset = IMP.domino.Subset([ps[0]]) rsb = cache.get_restraints(subset, []) self.assertEqual(len(rsb), 1) slc = cache.get_slice(rsb[0], subset) self.assertEqual(len(slc), 1) aslc = slc.get_sliced(IMP.domino.Assignment(range(len(ps)))) self.assertEqual(len(aslc), 1) score = cache.get_score(rsb[0], aslc) print(score) self.assert_(score > 1000)
def setUp(self): """set up distance restraints and create optimizer """ IMP.test.TestCase.setUp(self) self.imp_model = IMP.Model() self.particles = [] self.restraint_sets = [] self.rsrs = [] # create particles 0 - 1 self.particles.append(self.create_point_particle(self.imp_model, -43.0, 65.0, 93.0)) self.particles.append(self.create_point_particle(self.imp_model, 20.0, 74.0, -80.0)) self.particles.append(self.create_point_particle(self.imp_model, 4.0, -39.0, 26.0)) p1 = self.particles[0] p1.add_attribute(radkey, 1.0, False) p1 = self.particles[1] p1.add_attribute(radkey, 2.0, False) p1 = self.particles[2] p1.add_attribute(radkey, 3.0, False) # separate 3 particles by their radii for pairs in ((0, 1), (1, 2), (0, 2)): p1 = self.particles[pairs[0]] p2 = self.particles[pairs[1]] mean = p1.get_value(radkey) + p2.get_value(radkey) sf = IMP.core.Harmonic(mean, 0.1) rsr = IMP.core.DistanceRestraint(self.imp_model, sf, p1, p2) self.rsrs.append(rsr) # add restraints rs = IMP.RestraintSet(self.imp_model, 1.0, "distance_rsrs") self.restraint_sets.append(rs) for i in range(len(self.rsrs)): rs.add_restraint(self.rsrs[i]) self.steepest_descent = IMP.core.SteepestDescent(self.imp_model) self.steepest_descent.set_scoring_function([rs])
def test_global_min3(self): """Test sampling with edge scores""" m = IMP.Model() m.set_log_level(IMP.SILENT) ps = [] for i in range(0, 3): p = IMP.Particle(m) d = IMP.core.XYZ.setup_particle(p) ps.append(p) pts = [ IMP.algebra.Vector3D(0, 0, 0), IMP.algebra.Vector3D(1, 0, 0), IMP.algebra.Vector3D(2, 0, 0), IMP.algebra.Vector3D(3, 0, 0) ] particle_state = IMP.domino.XYZStates(pts) pst = IMP.domino.ParticleStatesTable() r = IMP.RestraintSet(m) for p in ps: pst.set_particle_states(p, particle_state) r.add_restraint(IMP._ConstRestraint(1, [p])) r.add_restraint( IMP.core.DistanceRestraint(m, IMP.core.Harmonic(1, 1), ps[0], ps[1])) r.add_restraint( IMP.core.DistanceRestraint(m, IMP.core.Harmonic(1, 1), ps[1], ps[2])) r.set_maximum_score(3.1) sampler = IMP.domino.DominoSampler(m, pst) sampler.set_restraints([r]) sampler.set_log_level(IMP.VERBOSE) cs = sampler.create_sample() self.assertGreater(cs.get_number_of_configurations(), 0) for i in range(0, cs.get_number_of_configurations()): cs.load_configuration(i) self.assertLess((IMP.core.get_distance(IMP.core.XYZ( ps[0]), IMP.core.XYZ(ps[1])) - 1)**2, .1) self.assertLess((IMP.core.get_distance(IMP.core.XYZ( ps[1]), IMP.core.XYZ(ps[2])) - 1)**2, .1)
def test_global_min1(self): """Testing splitting restraints with rigid bodies""" m = IMP.Model() rbs = [ self._create_rb("1", m), self._create_rb("2", m), self._create_rb("3", m) ] trs = [ ReferenceFrame3D( Transformation3D(get_identity_rotation_3d(), Vector3D(0, 0, 0))), ReferenceFrame3D( Transformation3D(get_identity_rotation_3d(), Vector3D(2, 0, 0))), ReferenceFrame3D( Transformation3D(get_identity_rotation_3d(), Vector3D(4, 0, 0))) ] ps = IMP.core.HarmonicSphereDistancePairScore(0, 1) members = IMP.get_indexes([x.get_rigid_members()[0] for x in rbs]) pl = IMP.container.ListPairContainer(m, [(members[0], members[1]), (members[1], members[2])]) r = IMP.container.PairsRestraint(ps, pl) r.set_name("restraint") rs = IMP.RestraintSet(m) rs.add_restraint(r) r.set_maximum_score(.5) pst = IMP.domino.ParticleStatesTable() pstate = IMP.domino.RigidBodyStates(trs) pst.set_particle_states(rbs[0], pstate) pst.set_particle_states(rbs[1], pstate) pst.set_particle_states(rbs[2], pstate) rc = IMP.domino.RestraintCache(pst) rc.add_restraints([rs]) allr = rc.get_restraints() for r in allr: print(r.get_name()) self.assertEqual(len(allr), 3)
def __init__(self, representation, radius, hierarchies=None, resolution=None): self.m = representation.prot.get_model() self.rs = IMP.RestraintSet(self.m, 'barrier') self.radius = radius self.label = "None" c3 = IMP.algebra.Vector3D(0, 0, 0) ub3 = IMP.core.HarmonicUpperBound(radius, 10.0) ss3 = IMP.core.DistanceToSingletonScore(ub3, c3) lsc = IMP.container.ListSingletonContainer(self.m) # IMP.atom.get_by_type particles = IMP.pmi.tools.select(representation, resolution=resolution, hierarchies=hierarchies) lsc.add_particles(particles) r3 = IMP.container.SingletonsRestraint(ss3, lsc) self.rs.add_restraint(r3)
def __init__(self, representation, images, pixel_size, image_resolution, projection_number, resolution=None): self.weight = 1.0 self.m = representation.prot.get_model() self.rs = IMP.RestraintSet(self.m, 'em2d') self.label = "None" # IMP.atom.get_by_type particles = IMP.pmi.tools.select(representation, resolution=resolution) #print particles em2d = IMP.em2d.PCAFitRestraint(particles, images, pixel_size, image_resolution, projection_number, True) self.rs.add_restraint(em2d)
def __init__(self, objects, distance=3.78, strength=10.0, jitter=None): """Constructor @param objects Objects to restrain @param distance Resting distance for restraint @param strength Bond constant @param jitter Defines the +- added to the optimal distance in the harmonic well restraint used to increase the tolerance """ particles = IMP.pmi.tools.input_adaptor(objects, 1, flatten=True) self.m = particles[0].get_model() self.rs = IMP.RestraintSet(self.m, "Bonds") self.weight = 1 self.label = "None" self.pairslist = [] if not jitter: ts = IMP.core.Harmonic(distance, strength) else: ts = IMP.core.HarmonicWell((distance - jitter, distance + jitter), strength) for ps in IMP.pmi.tools.sublist_iterator(particles, 2, 2): pair = [] if len(ps) != 2: raise ValueError("wrong length of pair") for p in ps: if not IMP.atom.Residue.get_is_setup(p): raise TypeError("%s is not a residue" % p) else: pair.append(p) print("ResidueBondRestraint: adding a restraint between %s %s" % (pair[0].get_name(), pair[1].get_name())) self.rs.add_restraint( IMP.core.DistanceRestraint(self.m, ts, pair[0], pair[1])) self.pairslist.append(IMP.ParticlePair(pair[0], pair[1])) self.pairslist.append(IMP.ParticlePair(pair[1], pair[0]))