def set_complementarity_restraint(self, name1, name2, rname, max_sep_distance, max_penetration, weight, max_score=1e10): """ Set a restraint for geometric complementarity between 2 components @param name1 name of @param name2 - The restraint is applied to this components @param rname - The name given to the restraint @param max_sep_distance - maximum distance between molecules tolerated by the restraint @param max_penetration - Maximum penetration allowed (angstrom) @param weight @param max_score """ log.info("Setting geometric complementarity restraint %s: %s - %s", rname, name1, name2) A = representation.get_component(self.assembly, name1) B = representation.get_component(self.assembly, name2) restraint = multifit.ComplementarityRestraint(atom.get_leaves(A), atom.get_leaves(B), rname) restraint.set_maximum_separation(max_sep_distance) restraint.set_maximum_penetration(max_penetration) log.debug("Maximum separation: %s Maximum penetration score: %s", max_sep_distance, max_penetration) self.add_restraint(restraint, rname, weight, max_score)
def set_complementarity_restraint(self, name1, name2, rname, max_sep_distance, max_penetration, weight, max_score=1e10): """ Set a restraint for geometric complementarity between 2 components @param name1 name of @param name2 - The restraint is applied to this components @param rname - The name given to the restraint @param max_sep_distance - maximum distance between molecules tolerated by the restraint @param max_penetration - Maximum penetration allowed (angstrom) @param weight @param max_score """ log.info("Setting geometric complementarity restraint %s: %s - %s", rname, name1, name2) A = representation.get_component(self.assembly, name1) B = representation.get_component(self.assembly, name2) restraint = multifit.ComplementarityRestraint(atom.get_leaves(A), atom.get_leaves(B), rname) restraint.set_maximum_separation(max_sep_distance) restraint.set_maximum_penetration(max_penetration) log.debug("Maximum separation: %s Maximum penetration score: %s", max_sep_distance, max_penetration) self.add_restraint(restraint, rname, weight, max_score)
def set_pair_score_restraint( self, name1, name2, restraint_name, distance=10, weight=1.0, n_pairs=1, stddev=2, max_score=None ): """ Set a pair_score restraint between the coarse representation of two components @param name1 Name of the first component @param name2 Name of the second component @param restraint_name Name for the restraint @param distance Maximum distance tolerated between particles @param weight Weight of the restraint @param n_pairs @param max_score Maximum value tolerated for the restraint @param stddev Standard deviation used to approximate the HarmonicUpperBound function to a Gaussian """ table_refiner = core.TableRefiner() # The particles in A are attached to a marker particle via a refiner. # When the refiner gets a request for marker1, it returns the attached # particles A = representation.get_component(self.coarse_assembly, name1) marker1 = IMP.Particle(self.model, "marker1 " + restraint_name) table_refiner.add_particle(marker1, atom.get_leaves(A)) # same for B B = representation.get_component(self.coarse_assembly, name2) marker2 = IMP.Particle(self.model, "marker2 " + restraint_name) table_refiner.add_particle(marker2, atom.get_leaves(B)) k = core.Harmonic.get_k_from_standard_deviation(stddev) score = core.HarmonicUpperBoundSphereDistancePairScore(distance, k) # The score is set for the n_pairs closest pairs of particles pair_score = core.KClosePairsPairScore(score, table_refiner, n_pairs) # When KClosePairsPairScore is called, the refiner will provide the # particles for A and B if not max_score: # Build a maximum score based on the function type that is used, # an HarmonicUpperBound temp_score = core.HarmonicUpperBound(distance, k) error_distance_allowed = 10 max_score = weight * n_pairs * temp_score.evaluate(distance + error_distance_allowed) log.info( "Setting pair score restraint for %s %s. k = %s, max_score " "= %s, stddev %s", name1, name2, k, max_score, stddev, ) r = core.PairRestraint(pair_score, IMP.ParticlePair(marker1, marker2)) self.add_restraint(r, restraint_name, weight, max_score)
def set_xlink_restraint(self, id1, chain1, residue1, id2, chain2, residue2, distance, weight, stddev, max_score=False): """ Set a restraint on the maximum distance between 2 residues @param id1 Name of the first component @param chain1 @param residue1 Residue number for the aminoacid in the first component.The number is the number in the PDB file, not the number relative to the beginning of the chain @param id2 Name of the second component @param chain2 @param residue2 Residue number for the aminoacid in the second component. @param distance Maximum distance tolerated @param weight Weight of the restraint @param stddev Standard deviation used to approximate the HarmonicUpperBound function to a Gaussian @param max_score See help for add_restraint(). If none is given, the maximum score is set to allow a maximum distance of 10 Angstrom greater than the parameter "distance". """ xlink = buildxlinks.Xlink( id1, chain1, residue1, id2, chain2, residue2, distance) log.info("Setting cross-linking restraint ") log.info("%s", xlink.show()) self.xlinks_dict.add(xlink) # setup restraint A = representation.get_component(self.assembly, xlink.first_id) s1 = IMP.atom.Selection(A, chain=xlink.first_chain, residue_index=xlink.first_residue) p1 = s1.get_selected_particles()[0] B = representation.get_component(self.assembly, xlink.second_id) s2 = IMP.atom.Selection(B, chain=xlink.second_chain, residue_index=xlink.second_residue) p2 = s2.get_selected_particles()[0] k = core.Harmonic.get_k_from_standard_deviation(stddev) score = core.HarmonicUpperBound(xlink.distance, k) pair_score = IMP.core.DistancePairScore(score) r = IMP.core.PairRestraint(self.model, pair_score, (p1, p2)) if not max_score: error_distance_allowed = 100 max_score = weight * \ score.evaluate(distance + error_distance_allowed) log.info("%s, max_score %s", xlink.show(), max_score) self.add_restraint(r, xlink.get_name(), weight, max_score)
def set_pair_score_restraint(self, name1, name2, restraint_name, distance=10, weight=1.0, n_pairs=1, stddev=2, max_score=None): """ Set a pair_score restraint between the coarse representation of two components @param name1 Name of the first component @param name2 Name of the second component @param restraint_name Name for the restraint @param distance Maximum distance tolerated between particles @param weight Weight of the restraint @param n_pairs @param max_score Maximum value tolerated for the restraint @param stddev Standard deviation used to approximate the HarmonicUpperBound function to a Gaussian """ table_refiner = core.TableRefiner() # The particles in A are attached to a marker particle via a refiner. # When the refiner gets a request for marker1, it returns the attached # particles A = representation.get_component(self.coarse_assembly, name1) marker1 = IMP.Particle(self.model, "marker1 " + restraint_name) table_refiner.add_particle(marker1, atom.get_leaves(A)) # same for B B = representation.get_component(self.coarse_assembly, name2) marker2 = IMP.Particle(self.model, "marker2 " + restraint_name) table_refiner.add_particle(marker2, atom.get_leaves(B)) k = core.Harmonic.get_k_from_standard_deviation(stddev) score = core.HarmonicUpperBoundSphereDistancePairScore(distance, k) # The score is set for the n_pairs closest pairs of particles pair_score = core.KClosePairsPairScore(score, table_refiner, n_pairs) # When KClosePairsPairScore is called, the refiner will provide the # particles for A and B if not max_score: # Build a maximum score based on the function type that is used, # an HarmonicUpperBound temp_score = core.HarmonicUpperBound(distance, k) error_distance_allowed = 10 max_score = weight * n_pairs * \ temp_score.evaluate(distance + error_distance_allowed) log.info("Setting pair score restraint for %s %s. k = %s, max_score " "= %s, stddev %s", name1, name2, k, max_score, stddev) r = core.PairRestraint( pair_score, IMP.ParticlePair( marker1, marker2)) self.add_restraint(r, restraint_name, weight, max_score)
def set_xlink_restraint(self, id1, chain1, residue1, id2, chain2, residue2, distance, weight, stddev, max_score=False): """ Set a restraint on the maximum distance between 2 residues @param id1 Name of the first component @param chain1 @param residue1 Residue number for the aminoacid in the first component.The number is the number in the PDB file, not the number relative to the beginning of the chain @param id2 Name of the second component @param chain2 @param residue2 Residue number for the aminoacid in the second component. @param distance Maximum distance tolerated @param weight Weight of the restraint @param stddev Standard deviation used to approximate the HarmonicUpperBound function to a Gaussian @param max_score See help for add_restraint(). If none is given, the maximum score is set to allow a maximum distance of 10 Angstrom greater than the parameter "distance". """ xlink = buildxlinks.Xlink( id1, chain1, residue1, id2, chain2, residue2, distance) log.info("Setting cross-linking restraint ") log.info("%s", xlink.show()) self.xlinks_dict.add(xlink) # setup restraint A = representation.get_component(self.assembly, xlink.first_id) s1 = IMP.atom.Selection(A, chain=xlink.first_chain, residue_index=xlink.first_residue) p1 = s1.get_selected_particles()[0] B = representation.get_component(self.assembly, xlink.second_id) s2 = IMP.atom.Selection(B, chain=xlink.second_chain, residue_index=xlink.second_residue) p2 = s2.get_selected_particles()[0] k = core.Harmonic.get_k_from_standard_deviation(stddev) score = core.HarmonicUpperBound(xlink.distance, k) pair_score = IMP.core.DistancePairScore(score) r = IMP.core.PairRestraint(pair_score, IMP.ParticlePair(p1, p2)) if not max_score: error_distance_allowed = 100 max_score = weight * \ score.evaluate(distance + error_distance_allowed) log.info("%s, max_score %s", xlink.show(), max_score) self.add_restraint(r, xlink.get_name(), weight, max_score)
def set_connectivity_restraint(self, names, rname, distance=10, weight=1.0, max_score=None, n_pairs=1, stddev=2): """ Set a connectivity restraint between the elements of the assembly @param names List with all the elements to be connected @param distance Maximum distance tolerated by the restraint @param rname Name for the restraint @param weight Weight for the restraint @param max_score Maximum score for the restraint @param n_pairs Number of pairs of particles used in the KClosePairScore of the connectivity restraint @param stddev Standard deviation used to approximate the HarmonicUpperBound function to a Gaussian """ components = [] for name in names: c = representation.get_component(self.coarse_assembly, name) components.append(c) log.info("Connectivity restraint for %s", components) spring_constant = core.Harmonic.get_k_from_standard_deviation(stddev) if max_score is None: max_score = weight * spring_constant * n_pairs * (stddev) ** 2 r = restraints.get_connectivity_restraint( components, distance, n_pairs, spring_constant) self.add_restraint(r, rname, weight, max_score)
def set_connectivity_restraint(self, names, rname, distance=10, weight=1.0, max_score=None, n_pairs=1, stddev=2): """ Set a connectivity restraint between the elements of the assembly @param names List with all the elements to be connected @param distance Maximum distance tolerated by the restraint @param rname Name for the restraint @param weight Weight for the restraint @param max_score Maximum score for the restraint @param n_pairs Number of pairs of particles used in the KClosePairScore of the connectivity restraint @param stddev Standard deviation used to approximate the HarmonicUpperBound function to a Gaussian """ components = [] for name in names: c = representation.get_component(self.coarse_assembly, name) components.append(c) log.info("Connectivity restraint for %s", components) spring_constant = core.Harmonic.get_k_from_standard_deviation(stddev) if max_score is None: max_score = weight * spring_constant * n_pairs * (stddev) ** 2 r = restraints.get_connectivity_restraint( components, distance, n_pairs, spring_constant) self.add_restraint(r, rname, weight, max_score)