downstream

Bindings for protocols::match::downstream namespace

class pyrosetta.rosetta.protocols.match.downstream.ActiveSiteGrid

Bases: pybind11_object

assign(self: pyrosetta.rosetta.protocols.match.downstream.ActiveSiteGrid, rhs: pyrosetta.rosetta.protocols.match.downstream.ActiveSiteGrid) → pyrosetta.rosetta.protocols.match.downstream.ActiveSiteGrid

C++: protocols::match::downstream::ActiveSiteGrid::operator=(const class protocols::match::downstream::ActiveSiteGrid &) –> class protocols::match::downstream::ActiveSiteGrid &

bounding_box(self: pyrosetta.rosetta.protocols.match.downstream.ActiveSiteGrid) → pyrosetta.rosetta.numeric.geometry.BoundingBox_numeric_xyzVector_double_t

Accessor for the bounding box

C++: protocols::match::downstream::ActiveSiteGrid::bounding_box() const –> const class numeric::geometry::BoundingBox<class numeric::xyzVector<double> > &

clear(self: pyrosetta.rosetta.protocols.match.downstream.ActiveSiteGrid) → None

Reset all the voxels to false

C++: protocols::match::downstream::ActiveSiteGrid::clear() –> void

enlargen_to_capture_volume_within_radius_of_backbone(self: pyrosetta.rosetta.protocols.match.downstream.ActiveSiteGrid, res: pyrosetta.rosetta.core.conformation.Residue, radius: float) → None

Set the bounding box to be large enough to hold the volume within the

radius of any backbone atom in the given residue. This function has the side-effect of clearing the grid.

C++: protocols::match::downstream::ActiveSiteGrid::enlargen_to_capture_volume_within_radius_of_backbone(const class core::conformation::Residue &, double) –> void

enlargen_to_capture_volume_within_radius_of_residue(self: pyrosetta.rosetta.protocols.match.downstream.ActiveSiteGrid, res: pyrosetta.rosetta.core.conformation.Residue, radius: float) → None

Set the bounding box to be large enough to hold the volume within the

radius of any atom in the given residue. This function has the side-effect of clearing the grid.

C++: protocols::match::downstream::ActiveSiteGrid::enlargen_to_capture_volume_within_radius_of_residue(const class core::conformation::Residue &, double) –> void

enlargen_to_capture_volume_within_radius_of_sidechain(self: pyrosetta.rosetta.protocols.match.downstream.ActiveSiteGrid, res: pyrosetta.rosetta.core.conformation.Residue, radius: float) → None

Set the bounding box to be large enough to hold the volume within the

radius of any sidechain atom in the given residue. This function has the side-effect of clearing the grid.

C++: protocols::match::downstream::ActiveSiteGrid::enlargen_to_capture_volume_within_radius_of_sidechain(const class core::conformation::Residue &, double) –> void

grid(self: pyrosetta.rosetta.protocols.match.downstream.ActiveSiteGrid) → pyrosetta.rosetta.protocols.match.Bool3DGrid

C++: protocols::match::downstream::ActiveSiteGrid::grid() const –> const class protocols::match::Bool3DGrid &

initialize(self: pyrosetta.rosetta.protocols.match.downstream.ActiveSiteGrid) → None

Ensures the grid is up-to-date after any calls to enlargen_*.

C++: protocols::match::downstream::ActiveSiteGrid::initialize() –> void

initialize_from_gridlig_file(self: pyrosetta.rosetta.protocols.match.downstream.ActiveSiteGrid, fname: str) → None

C++: protocols::match::downstream::ActiveSiteGrid::initialize_from_gridlig_file(const std::string &) –> void

occupied(self: pyrosetta.rosetta.protocols.match.downstream.ActiveSiteGrid, p: pyrosetta.rosetta.numeric.xyzVector_double_t) → bool

Is a point in this grid active? False for a point outside the bounding box.

C++: protocols::match::downstream::ActiveSiteGrid::occupied(const class numeric::xyzVector<double> &) const –> bool

or_within_radius_of_backbone(self: pyrosetta.rosetta.protocols.match.downstream.ActiveSiteGrid, res: pyrosetta.rosetta.core.conformation.Residue, radius: float) → None

Set all the voxels within a certain radius of the backbone atoms to true.

C++: protocols::match::downstream::ActiveSiteGrid::or_within_radius_of_backbone(const class core::conformation::Residue &, double) –> void

or_within_radius_of_residue(self: pyrosetta.rosetta.protocols.match.downstream.ActiveSiteGrid, res: pyrosetta.rosetta.core.conformation.Residue, radius: float) → None

Set all the voxels within a certain radius of the residue atoms to true.

C++: protocols::match::downstream::ActiveSiteGrid::or_within_radius_of_residue(const class core::conformation::Residue &, double) –> void

or_within_radius_of_sidechain(self: pyrosetta.rosetta.protocols.match.downstream.ActiveSiteGrid, res: pyrosetta.rosetta.core.conformation.Residue, radius: float) → None

Set all the voxels within a certain radius of the sidechain atoms to true.

C++: protocols::match::downstream::ActiveSiteGrid::or_within_radius_of_sidechain(const class core::conformation::Residue &, double) –> void

set_bin_width(self: pyrosetta.rosetta.protocols.match.downstream.ActiveSiteGrid, width: float) → None

C++: protocols::match::downstream::ActiveSiteGrid::set_bin_width(double) –> void

set_bounding_box(self: pyrosetta.rosetta.protocols.match.downstream.ActiveSiteGrid, bb: pyrosetta.rosetta.numeric.geometry.BoundingBox_numeric_xyzVector_double_t) → None

Set the bounding box for this grid

C++: protocols::match::downstream::ActiveSiteGrid::set_bounding_box(const class numeric::geometry::BoundingBox<class numeric::xyzVector<double> > &) –> void

class pyrosetta.rosetta.protocols.match.downstream.AtomAngleSecMatchRPE

Bases: AtomGeometrySecMatchRPE

RPE to figure out if three atoms are within a given angle atoms need to be set through the parent class add_at_ind function

add_at_ind(self: pyrosetta.rosetta.protocols.match.downstream.AtomGeometrySecMatchRPE, which_cst_res: int, atom_ind_in_res: int) → None

C++: protocols::match::downstream::AtomGeometrySecMatchRPE::add_at_ind(unsigned long, unsigned long) –> void

assign(self: pyrosetta.rosetta.protocols.match.downstream.AtomAngleSecMatchRPE, : pyrosetta.rosetta.protocols.match.downstream.AtomAngleSecMatchRPE) → pyrosetta.rosetta.protocols.match.downstream.AtomAngleSecMatchRPE

C++: protocols::match::downstream::AtomAngleSecMatchRPE::operator=(const class protocols::match::downstream::AtomAngleSecMatchRPE &) –> class protocols::match::downstream::AtomAngleSecMatchRPE &

at_inds(self: pyrosetta.rosetta.protocols.match.downstream.AtomGeometrySecMatchRPE) → pyrosetta.rosetta.utility.vector1_std_pair_unsigned_long_unsigned_long_t

C++: protocols::match::downstream::AtomGeometrySecMatchRPE::at_inds() const –> const class utility::vector1<struct std::pair<unsigned long, unsigned long>, class std::allocator<struct std::pair<unsigned long, unsigned long> > > &

candidate_res_atoms_reqd_near_target_atom(self: pyrosetta.rosetta.protocols.match.downstream.SecMatchResiduePairEvaluator, target_atom_id: int) → pyrosetta.rosetta.utility.vector1_unsigned_long

Return a list of atom indices on the candidate residue; if all atoms

in this list are further than max_separation_dist_to_target_atom() away from the target_atom_id atom for a given pair of conformations of the target_residue and the candidate_residue, then this evaluator will return false in the call to evaluate( candidate_residue, target_residue ). This list will allow the SecondaryMatcher to (conservatively!) prune conformations of the candidate_residue from consideration. The base class implements a noop – it returns an empty list.

C++: protocols::match::downstream::SecMatchResiduePairEvaluator::candidate_res_atoms_reqd_near_target_atom(unsigned long) const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

check_value(self: pyrosetta.rosetta.protocols.match.downstream.AtomGeometrySecMatchRPE, value: float) → bool

determines if the passed in value is between lowval and highval

C++: protocols::match::downstream::AtomGeometrySecMatchRPE::check_value(double) const –> bool

evaluate_residues(self: pyrosetta.rosetta.protocols.match.downstream.AtomAngleSecMatchRPE, candidate_res: pyrosetta.rosetta.core.conformation.Residue, target_res: pyrosetta.rosetta.core.conformation.Residue) → bool

C++: protocols::match::downstream::AtomAngleSecMatchRPE::evaluate_residues(const class core::conformation::Residue &, const class core::conformation::Residue &) const –> bool

highval(self: pyrosetta.rosetta.protocols.match.downstream.AtomGeometrySecMatchRPE) → float

C++: protocols::match::downstream::AtomGeometrySecMatchRPE::highval() const –> double

lowval(self: pyrosetta.rosetta.protocols.match.downstream.AtomGeometrySecMatchRPE) → float

C++: protocols::match::downstream::AtomGeometrySecMatchRPE::lowval() const –> double

max_separation_dist_to_target_atom(self: pyrosetta.rosetta.protocols.match.downstream.SecMatchResiduePairEvaluator, target_atom_id: int) → float

Return the maximum separation distance that any of the match-residue

atoms identified by the function match_atoms_reqd_near_target_atom may be from a particular atom on the target residue. Returns a negative value if there is no requirement that any atom be within a certain radius of the target atom. The base class implementation returns -1.0.

C++: protocols::match::downstream::SecMatchResiduePairEvaluator::max_separation_dist_to_target_atom(unsigned long) const –> double

print(self: pyrosetta.rosetta.protocols.match.downstream.AtomAngleSecMatchRPE, candidate_restype: pyrosetta.rosetta.core.chemical.ResidueType, target_restype: pyrosetta.rosetta.core.chemical.ResidueType) → str

C++: protocols::match::downstream::AtomAngleSecMatchRPE::print(class std::shared_ptr<const class core::chemical::ResidueType>, class std::shared_ptr<const class core::chemical::ResidueType>) const –> std::string

require_all_target_residue_atom_coordinates(self: pyrosetta.rosetta.protocols.match.downstream.AtomGeometrySecMatchRPE) → bool

C++: protocols::match::downstream::AtomGeometrySecMatchRPE::require_all_target_residue_atom_coordinates() const –> bool

require_candidate_residue_atoms_to_lie_near_target_atom(self: pyrosetta.rosetta.protocols.match.downstream.SecMatchResiduePairEvaluator, target_atom_id: int) → bool

Are there atoms of the candidate residue that must be within

some cutoff distance of a given atom on the target residue? Base class implementation returns false.

C++: protocols::match::downstream::SecMatchResiduePairEvaluator::require_candidate_residue_atoms_to_lie_near_target_atom(unsigned long) const –> bool

require_target_atom_coordinate(self: pyrosetta.rosetta.protocols.match.downstream.AtomGeometrySecMatchRPE, target_atom_id: int) → bool

C++: protocols::match::downstream::AtomGeometrySecMatchRPE::require_target_atom_coordinate(unsigned long) const –> bool

class pyrosetta.rosetta.protocols.match.downstream.AtomDihedralSecMatchRPE

Bases: AtomGeometrySecMatchRPE

RPE to figure out if four atoms are within a given dihedral angle atoms need to be set through the parent class add_at_ind function also checks whether a dihedral is periodic, i.e. multiple minima

add_at_ind(self: pyrosetta.rosetta.protocols.match.downstream.AtomGeometrySecMatchRPE, which_cst_res: int, atom_ind_in_res: int) → None

C++: protocols::match::downstream::AtomGeometrySecMatchRPE::add_at_ind(unsigned long, unsigned long) –> void

assign(self: pyrosetta.rosetta.protocols.match.downstream.AtomDihedralSecMatchRPE, : pyrosetta.rosetta.protocols.match.downstream.AtomDihedralSecMatchRPE) → pyrosetta.rosetta.protocols.match.downstream.AtomDihedralSecMatchRPE

C++: protocols::match::downstream::AtomDihedralSecMatchRPE::operator=(const class protocols::match::downstream::AtomDihedralSecMatchRPE &) –> class protocols::match::downstream::AtomDihedralSecMatchRPE &

at_inds(self: pyrosetta.rosetta.protocols.match.downstream.AtomGeometrySecMatchRPE) → pyrosetta.rosetta.utility.vector1_std_pair_unsigned_long_unsigned_long_t

C++: protocols::match::downstream::AtomGeometrySecMatchRPE::at_inds() const –> const class utility::vector1<struct std::pair<unsigned long, unsigned long>, class std::allocator<struct std::pair<unsigned long, unsigned long> > > &

candidate_res_atoms_reqd_near_target_atom(self: pyrosetta.rosetta.protocols.match.downstream.SecMatchResiduePairEvaluator, target_atom_id: int) → pyrosetta.rosetta.utility.vector1_unsigned_long

Return a list of atom indices on the candidate residue; if all atoms

in this list are further than max_separation_dist_to_target_atom() away from the target_atom_id atom for a given pair of conformations of the target_residue and the candidate_residue, then this evaluator will return false in the call to evaluate( candidate_residue, target_residue ). This list will allow the SecondaryMatcher to (conservatively!) prune conformations of the candidate_residue from consideration. The base class implements a noop – it returns an empty list.

C++: protocols::match::downstream::SecMatchResiduePairEvaluator::candidate_res_atoms_reqd_near_target_atom(unsigned long) const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

check_value(self: pyrosetta.rosetta.protocols.match.downstream.AtomGeometrySecMatchRPE, value: float) → bool

determines if the passed in value is between lowval and highval

C++: protocols::match::downstream::AtomGeometrySecMatchRPE::check_value(double) const –> bool

evaluate_residues(self: pyrosetta.rosetta.protocols.match.downstream.AtomDihedralSecMatchRPE, candidate_res: pyrosetta.rosetta.core.conformation.Residue, target_res: pyrosetta.rosetta.core.conformation.Residue) → bool

C++: protocols::match::downstream::AtomDihedralSecMatchRPE::evaluate_residues(const class core::conformation::Residue &, const class core::conformation::Residue &) const –> bool

highval(self: pyrosetta.rosetta.protocols.match.downstream.AtomGeometrySecMatchRPE) → float

C++: protocols::match::downstream::AtomGeometrySecMatchRPE::highval() const –> double

lowval(self: pyrosetta.rosetta.protocols.match.downstream.AtomGeometrySecMatchRPE) → float

C++: protocols::match::downstream::AtomGeometrySecMatchRPE::lowval() const –> double

max_separation_dist_to_target_atom(self: pyrosetta.rosetta.protocols.match.downstream.SecMatchResiduePairEvaluator, target_atom_id: int) → float

Return the maximum separation distance that any of the match-residue

atoms identified by the function match_atoms_reqd_near_target_atom may be from a particular atom on the target residue. Returns a negative value if there is no requirement that any atom be within a certain radius of the target atom. The base class implementation returns -1.0.

C++: protocols::match::downstream::SecMatchResiduePairEvaluator::max_separation_dist_to_target_atom(unsigned long) const –> double

print(self: pyrosetta.rosetta.protocols.match.downstream.AtomDihedralSecMatchRPE, candidate_restype: pyrosetta.rosetta.core.chemical.ResidueType, target_restype: pyrosetta.rosetta.core.chemical.ResidueType) → str

C++: protocols::match::downstream::AtomDihedralSecMatchRPE::print(class std::shared_ptr<const class core::chemical::ResidueType>, class std::shared_ptr<const class core::chemical::ResidueType>) const –> std::string

require_all_target_residue_atom_coordinates(self: pyrosetta.rosetta.protocols.match.downstream.AtomGeometrySecMatchRPE) → bool

C++: protocols::match::downstream::AtomGeometrySecMatchRPE::require_all_target_residue_atom_coordinates() const –> bool

require_candidate_residue_atoms_to_lie_near_target_atom(self: pyrosetta.rosetta.protocols.match.downstream.SecMatchResiduePairEvaluator, target_atom_id: int) → bool

Are there atoms of the candidate residue that must be within

some cutoff distance of a given atom on the target residue? Base class implementation returns false.

C++: protocols::match::downstream::SecMatchResiduePairEvaluator::require_candidate_residue_atoms_to_lie_near_target_atom(unsigned long) const –> bool

require_target_atom_coordinate(self: pyrosetta.rosetta.protocols.match.downstream.AtomGeometrySecMatchRPE, target_atom_id: int) → bool

C++: protocols::match::downstream::AtomGeometrySecMatchRPE::require_target_atom_coordinate(unsigned long) const –> bool

class pyrosetta.rosetta.protocols.match.downstream.AtomDistanceSecMatchRPE

Bases: AtomGeometrySecMatchRPE

RPE to figure out if two atoms are within a given distance atoms need to be set through the parent class add_at_ind function

add_at_ind(self: pyrosetta.rosetta.protocols.match.downstream.AtomGeometrySecMatchRPE, which_cst_res: int, atom_ind_in_res: int) → None

C++: protocols::match::downstream::AtomGeometrySecMatchRPE::add_at_ind(unsigned long, unsigned long) –> void

assign(self: pyrosetta.rosetta.protocols.match.downstream.AtomDistanceSecMatchRPE, : pyrosetta.rosetta.protocols.match.downstream.AtomDistanceSecMatchRPE) → pyrosetta.rosetta.protocols.match.downstream.AtomDistanceSecMatchRPE

C++: protocols::match::downstream::AtomDistanceSecMatchRPE::operator=(const class protocols::match::downstream::AtomDistanceSecMatchRPE &) –> class protocols::match::downstream::AtomDistanceSecMatchRPE &

at_inds(self: pyrosetta.rosetta.protocols.match.downstream.AtomGeometrySecMatchRPE) → pyrosetta.rosetta.utility.vector1_std_pair_unsigned_long_unsigned_long_t

C++: protocols::match::downstream::AtomGeometrySecMatchRPE::at_inds() const –> const class utility::vector1<struct std::pair<unsigned long, unsigned long>, class std::allocator<struct std::pair<unsigned long, unsigned long> > > &

candidate_res_atoms_reqd_near_target_atom(self: pyrosetta.rosetta.protocols.match.downstream.AtomDistanceSecMatchRPE, target_atom_id: int) → pyrosetta.rosetta.utility.vector1_unsigned_long

C++: protocols::match::downstream::AtomDistanceSecMatchRPE::candidate_res_atoms_reqd_near_target_atom(unsigned long) const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

check_value(self: pyrosetta.rosetta.protocols.match.downstream.AtomGeometrySecMatchRPE, value: float) → bool

determines if the passed in value is between lowval and highval

C++: protocols::match::downstream::AtomGeometrySecMatchRPE::check_value(double) const –> bool

evaluate_residues(self: pyrosetta.rosetta.protocols.match.downstream.AtomDistanceSecMatchRPE, candidate_res: pyrosetta.rosetta.core.conformation.Residue, target_res: pyrosetta.rosetta.core.conformation.Residue) → bool

C++: protocols::match::downstream::AtomDistanceSecMatchRPE::evaluate_residues(const class core::conformation::Residue &, const class core::conformation::Residue &) const –> bool

highval(self: pyrosetta.rosetta.protocols.match.downstream.AtomGeometrySecMatchRPE) → float

C++: protocols::match::downstream::AtomGeometrySecMatchRPE::highval() const –> double

lowval(self: pyrosetta.rosetta.protocols.match.downstream.AtomGeometrySecMatchRPE) → float

C++: protocols::match::downstream::AtomGeometrySecMatchRPE::lowval() const –> double

max_separation_dist_to_target_atom(self: pyrosetta.rosetta.protocols.match.downstream.AtomDistanceSecMatchRPE, target_atom_id: int) → float

C++: protocols::match::downstream::AtomDistanceSecMatchRPE::max_separation_dist_to_target_atom(unsigned long) const –> double

print(self: pyrosetta.rosetta.protocols.match.downstream.AtomDistanceSecMatchRPE, candidate_restype: pyrosetta.rosetta.core.chemical.ResidueType, target_restype: pyrosetta.rosetta.core.chemical.ResidueType) → str

C++: protocols::match::downstream::AtomDistanceSecMatchRPE::print(class std::shared_ptr<const class core::chemical::ResidueType>, class std::shared_ptr<const class core::chemical::ResidueType>) const –> std::string

require_all_target_residue_atom_coordinates(self: pyrosetta.rosetta.protocols.match.downstream.AtomGeometrySecMatchRPE) → bool

C++: protocols::match::downstream::AtomGeometrySecMatchRPE::require_all_target_residue_atom_coordinates() const –> bool

require_candidate_residue_atoms_to_lie_near_target_atom(self: pyrosetta.rosetta.protocols.match.downstream.AtomDistanceSecMatchRPE, target_atom_id: int) → bool

C++: protocols::match::downstream::AtomDistanceSecMatchRPE::require_candidate_residue_atoms_to_lie_near_target_atom(unsigned long) const –> bool

require_target_atom_coordinate(self: pyrosetta.rosetta.protocols.match.downstream.AtomGeometrySecMatchRPE, target_atom_id: int) → bool

C++: protocols::match::downstream::AtomGeometrySecMatchRPE::require_target_atom_coordinate(unsigned long) const –> bool

class pyrosetta.rosetta.protocols.match.downstream.AtomGeometrySecMatchRPE

Bases: SecMatchResiduePairEvaluator

helper class for GeometrySec abstract base class for distance, angle, and dihedral derived classes

add_at_ind(self: pyrosetta.rosetta.protocols.match.downstream.AtomGeometrySecMatchRPE, which_cst_res: int, atom_ind_in_res: int) → None

C++: protocols::match::downstream::AtomGeometrySecMatchRPE::add_at_ind(unsigned long, unsigned long) –> void

assign(self: pyrosetta.rosetta.protocols.match.downstream.AtomGeometrySecMatchRPE, : pyrosetta.rosetta.protocols.match.downstream.AtomGeometrySecMatchRPE) → pyrosetta.rosetta.protocols.match.downstream.AtomGeometrySecMatchRPE

C++: protocols::match::downstream::AtomGeometrySecMatchRPE::operator=(const class protocols::match::downstream::AtomGeometrySecMatchRPE &) –> class protocols::match::downstream::AtomGeometrySecMatchRPE &

at_inds(self: pyrosetta.rosetta.protocols.match.downstream.AtomGeometrySecMatchRPE) → pyrosetta.rosetta.utility.vector1_std_pair_unsigned_long_unsigned_long_t

C++: protocols::match::downstream::AtomGeometrySecMatchRPE::at_inds() const –> const class utility::vector1<struct std::pair<unsigned long, unsigned long>, class std::allocator<struct std::pair<unsigned long, unsigned long> > > &

candidate_res_atoms_reqd_near_target_atom(self: pyrosetta.rosetta.protocols.match.downstream.SecMatchResiduePairEvaluator, target_atom_id: int) → pyrosetta.rosetta.utility.vector1_unsigned_long

Return a list of atom indices on the candidate residue; if all atoms

in this list are further than max_separation_dist_to_target_atom() away from the target_atom_id atom for a given pair of conformations of the target_residue and the candidate_residue, then this evaluator will return false in the call to evaluate( candidate_residue, target_residue ). This list will allow the SecondaryMatcher to (conservatively!) prune conformations of the candidate_residue from consideration. The base class implements a noop – it returns an empty list.

C++: protocols::match::downstream::SecMatchResiduePairEvaluator::candidate_res_atoms_reqd_near_target_atom(unsigned long) const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

check_value(self: pyrosetta.rosetta.protocols.match.downstream.AtomGeometrySecMatchRPE, value: float) → bool

determines if the passed in value is between lowval and highval

C++: protocols::match::downstream::AtomGeometrySecMatchRPE::check_value(double) const –> bool

evaluate_residues(self: pyrosetta.rosetta.protocols.match.downstream.AtomGeometrySecMatchRPE, candidate_res: pyrosetta.rosetta.core.conformation.Residue, target_res: pyrosetta.rosetta.core.conformation.Residue) → bool

C++: protocols::match::downstream::AtomGeometrySecMatchRPE::evaluate_residues(const class core::conformation::Residue &, const class core::conformation::Residue &) const –> bool

highval(self: pyrosetta.rosetta.protocols.match.downstream.AtomGeometrySecMatchRPE) → float

C++: protocols::match::downstream::AtomGeometrySecMatchRPE::highval() const –> double

lowval(self: pyrosetta.rosetta.protocols.match.downstream.AtomGeometrySecMatchRPE) → float

C++: protocols::match::downstream::AtomGeometrySecMatchRPE::lowval() const –> double

max_separation_dist_to_target_atom(self: pyrosetta.rosetta.protocols.match.downstream.SecMatchResiduePairEvaluator, target_atom_id: int) → float

Return the maximum separation distance that any of the match-residue

atoms identified by the function match_atoms_reqd_near_target_atom may be from a particular atom on the target residue. Returns a negative value if there is no requirement that any atom be within a certain radius of the target atom. The base class implementation returns -1.0.

C++: protocols::match::downstream::SecMatchResiduePairEvaluator::max_separation_dist_to_target_atom(unsigned long) const –> double

print(self: pyrosetta.rosetta.protocols.match.downstream.AtomGeometrySecMatchRPE, candidate_restype: pyrosetta.rosetta.core.chemical.ResidueType, target_restype: pyrosetta.rosetta.core.chemical.ResidueType) → str

C++: protocols::match::downstream::AtomGeometrySecMatchRPE::print(class std::shared_ptr<const class core::chemical::ResidueType>, class std::shared_ptr<const class core::chemical::ResidueType>) const –> std::string

require_all_target_residue_atom_coordinates(self: pyrosetta.rosetta.protocols.match.downstream.AtomGeometrySecMatchRPE) → bool

C++: protocols::match::downstream::AtomGeometrySecMatchRPE::require_all_target_residue_atom_coordinates() const –> bool

require_candidate_residue_atoms_to_lie_near_target_atom(self: pyrosetta.rosetta.protocols.match.downstream.SecMatchResiduePairEvaluator, target_atom_id: int) → bool

Are there atoms of the candidate residue that must be within

some cutoff distance of a given atom on the target residue? Base class implementation returns false.

C++: protocols::match::downstream::SecMatchResiduePairEvaluator::require_candidate_residue_atoms_to_lie_near_target_atom(unsigned long) const –> bool

require_target_atom_coordinate(self: pyrosetta.rosetta.protocols.match.downstream.AtomGeometrySecMatchRPE, target_atom_id: int) → bool

C++: protocols::match::downstream::AtomGeometrySecMatchRPE::require_target_atom_coordinate(unsigned long) const –> bool

class pyrosetta.rosetta.protocols.match.downstream.ClassicMatchAlgorithm

Bases: DownstreamAlgorithm

Produce hits by hashing building the coordinates of the downstream partner The downstream partner is responsible for building itself from the coordinate frame of three of its atoms. The ExternalGeomSampler describes the ways to orient the downstream partner given the coordinates of the upstream partner.

add_external_geom_sampler(self: pyrosetta.rosetta.protocols.match.downstream.ClassicMatchAlgorithm, sampler: pyrosetta.rosetta.utility.vector1_protocols_toolbox_match_enzdes_util_ExternalGeomSampler, exgeom_id: int, atom1: str, atom2: str, atom3: str, downstream_builder: protocols::match::downstream::DownstreamBuilder) → None

C++: protocols::match::downstream::ClassicMatchAlgorithm::add_external_geom_sampler(const class utility::vector1<class protocols::toolbox::match_enzdes_util::ExternalGeomSampler, class std::allocator<class protocols::toolbox::match_enzdes_util::ExternalGeomSampler> > &, const unsigned long, const std::string &, const std::string &, const std::string &, class std::shared_ptr<const class protocols::match::downstream::DownstreamBuilder>) –> void

are_colliding(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm, us_res: pyrosetta.rosetta.core.conformation.Residue, ds_res: pyrosetta.rosetta.core.conformation.Residue, ds_atoms: pyrosetta.rosetta.utility.vector1_core_id_AtomID, catalytic_atoms: pyrosetta.rosetta.utility.vector1_unsigned_long) → bool

C++: protocols::match::downstream::DownstreamAlgorithm::are_colliding(const class core::conformation::Residue &, const class core::conformation::Residue &, const class utility::vector1<class core::id::AtomID, class std::allocator<class core::id::AtomID> > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> bool

assign(self: pyrosetta.rosetta.protocols.match.downstream.ClassicMatchAlgorithm, : pyrosetta.rosetta.protocols.match.downstream.ClassicMatchAlgorithm) → pyrosetta.rosetta.protocols.match.downstream.ClassicMatchAlgorithm

C++: protocols::match::downstream::ClassicMatchAlgorithm::operator=(const class protocols::match::downstream::ClassicMatchAlgorithm &) –> class protocols::match::downstream::ClassicMatchAlgorithm &

build(self: pyrosetta.rosetta.protocols.match.downstream.ClassicMatchAlgorithm, scaffold_build_point_id: int, upstream_conf_id: int, upstream_residue: pyrosetta.rosetta.core.conformation.Residue) → pyrosetta.rosetta.std.list_protocols_match_Hit_t

Iterate across the external geom samplers that describe the rigid body orientations

of the downstream partner from the coordinates of the upstream partner.

C++: protocols::match::downstream::ClassicMatchAlgorithm::build(const unsigned long, const unsigned long, const class core::conformation::Residue &) const –> class std::list<class protocols::match::Hit, class std::allocator<class protocols::match::Hit> >

build_and_discard_first_round_hits_at_all_positions(self: pyrosetta.rosetta.protocols.match.downstream.ClassicMatchAlgorithm, matcher: pyrosetta.rosetta.protocols.match.Matcher) → pyrosetta.rosetta.std.list_protocols_match_Hit_t

C++: protocols::match::downstream::ClassicMatchAlgorithm::build_and_discard_first_round_hits_at_all_positions(class protocols::match::Matcher &) –> class std::list<class protocols::match::Hit, class std::allocator<class protocols::match::Hit> >

build_from_three_coords(self: pyrosetta.rosetta.protocols.match.downstream.ClassicMatchAlgorithm, which_external_sampler: int, scaffold_build_point_id: int, upstream_conf_id: int, upstream_residue: pyrosetta.rosetta.core.conformation.Residue) → pyrosetta.rosetta.std.list_protocols_match_Hit_t

This function completes the building of the downstream conformation

once the coordinates of the upstream conformation are known (and deemed non-colliding or, generally, pass any filter the upstream builder would use).

C++: protocols::match::downstream::ClassicMatchAlgorithm::build_from_three_coords(const unsigned long, const unsigned long, const unsigned long, const class core::conformation::Residue &) const –> class std::list<class protocols::match::Hit, class std::allocator<class protocols::match::Hit> >

build_hits_at_all_positions(self: pyrosetta.rosetta.protocols.match.downstream.ClassicMatchAlgorithm, matcher: pyrosetta.rosetta.protocols.match.Matcher) → pyrosetta.rosetta.std.list_protocols_match_Hit_t

C++: protocols::match::downstream::ClassicMatchAlgorithm::build_hits_at_all_positions(class protocols::match::Matcher &) –> class std::list<class protocols::match::Hit, class std::allocator<class protocols::match::Hit> >

clear_external_geom_samplers(self: pyrosetta.rosetta.protocols.match.downstream.ClassicMatchAlgorithm) → None

C++: protocols::match::downstream::ClassicMatchAlgorithm::clear_external_geom_samplers() –> void

clone(self: pyrosetta.rosetta.protocols.match.downstream.ClassicMatchAlgorithm) → pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm

C++: protocols::match::downstream::ClassicMatchAlgorithm::clone() const –> class std::shared_ptr<class protocols::match::downstream::DownstreamAlgorithm>

external_sampler(self: pyrosetta.rosetta.protocols.match.downstream.ClassicMatchAlgorithm, external_geom_id: int) → pyrosetta.rosetta.utility.vector1_protocols_toolbox_match_enzdes_util_ExternalGeomSampler

C++: protocols::match::downstream::ClassicMatchAlgorithm::external_sampler(unsigned long) const –> const class utility::vector1<class protocols::toolbox::match_enzdes_util::ExternalGeomSampler, class std::allocator<class protocols::toolbox::match_enzdes_util::ExternalGeomSampler> > &

generates_primary_hits(self: pyrosetta.rosetta.protocols.match.downstream.ClassicMatchAlgorithm) → bool

This method returns ‘true’ since the classic matcher builds the

downstream coordinates from scratch.

C++: protocols::match::downstream::ClassicMatchAlgorithm::generates_primary_hits() const –> bool

geom_cst_id(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm) → int

C++: protocols::match::downstream::DownstreamAlgorithm::geom_cst_id() const –> unsigned long

get_dsbuilder(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm) → protocols::match::downstream::DownstreamBuilder

C++: protocols::match::downstream::DownstreamAlgorithm::get_dsbuilder() const –> class std::shared_ptr<class protocols::match::downstream::DownstreamBuilder>

hits_to_include_with_partial_match(self: pyrosetta.rosetta.protocols.match.downstream.ClassicMatchAlgorithm, m: pyrosetta.rosetta.protocols.match.match_dspos1) → numeric::kdtree::WrappedPrimitive<std::list<protocols::match::Hit const*, std::allocator<protocols::match::Hit const*> > >

This method should not be invoked on the ClassicMatchAlgorithm,

since it returns “false” in its upstream_only method.

C++: protocols::match::downstream::ClassicMatchAlgorithm::hits_to_include_with_partial_match(const struct protocols::match::match_dspos1 &) const –> class std::shared_ptr<const class numeric::kdtree::WrappedPrimitive<class std::list<const class protocols::match::Hit *, class std::allocator<const class protocols::match::Hit *> > > >

launch_atom(self: pyrosetta.rosetta.protocols.match.downstream.ClassicMatchAlgorithm, external_geom_id: int, which_point: int) → int

C++: protocols::match::downstream::ClassicMatchAlgorithm::launch_atom(unsigned long, unsigned long) const –> unsigned long

n_external_samplers(self: pyrosetta.rosetta.protocols.match.downstream.ClassicMatchAlgorithm) → int

C++: protocols::match::downstream::ClassicMatchAlgorithm::n_external_samplers() const –> unsigned long

n_possible_hits_per_upstream_conformation(self: pyrosetta.rosetta.protocols.match.downstream.ClassicMatchAlgorithm) → int

C++: protocols::match::downstream::ClassicMatchAlgorithm::n_possible_hits_per_upstream_conformation() const –> unsigned long

prepare_for_match_enumeration(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm, : pyrosetta.rosetta.protocols.match.Matcher) → None

Called at the conclusion of matching, the Matcher signals

to the downstream algorithm that it’s time to prepare for match generation; if the downstream algorithm needs to enumerate compatible hits in response to the invokation of its hits_to_include_with_partial_match method, then now is the time to prepare for those calls. Base class has a noop implementation.

C++: protocols::match::downstream::DownstreamAlgorithm::prepare_for_match_enumeration(const class protocols::match::Matcher &) –> void

respond_to_peripheral_hitlist_change(self: pyrosetta.rosetta.protocols.match.downstream.ClassicMatchAlgorithm, matcher: pyrosetta.rosetta.protocols.match.Matcher) → None

Delete hits for this geometric constraint if they fall into

now-empty regions of 6D. This step can be avoided if the occupied-space-grid’s revision ID has not changed since the last time this function was invoked.

C++: protocols::match::downstream::ClassicMatchAlgorithm::respond_to_peripheral_hitlist_change(class protocols::match::Matcher &) –> void

respond_to_primary_hitlist_change(self: pyrosetta.rosetta.protocols.match.downstream.ClassicMatchAlgorithm, matcher: pyrosetta.rosetta.protocols.match.Matcher, round_just_completed: int) → None

Reset the occupied space grid for the matcher so that only those

regions which contain hits from this geometric constraint are marked as occupied.

C++: protocols::match::downstream::ClassicMatchAlgorithm::respond_to_primary_hitlist_change(class protocols::match::Matcher &, unsigned long) –> void

restype(self: pyrosetta.rosetta.protocols.match.downstream.ClassicMatchAlgorithm) → pyrosetta.rosetta.core.chemical.ResidueType

Accessors

C++: protocols::match::downstream::ClassicMatchAlgorithm::restype() const –> const class core::chemical::ResidueType &

set_active_site_grid(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm, active_site_grid: pyrosetta.rosetta.protocols.match.downstream.ActiveSiteGrid) → None

C++: protocols::match::downstream::DownstreamAlgorithm::set_active_site_grid(class std::shared_ptr<const class protocols::match::downstream::ActiveSiteGrid>) –> void

set_bb_grid(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm, bbgrid: pyrosetta.rosetta.protocols.match.BumpGrid) → None

C++: protocols::match::downstream::DownstreamAlgorithm::set_bb_grid(class std::shared_ptr<const class protocols::match::BumpGrid>) –> void

set_build_round1_hits_twice(self: pyrosetta.rosetta.protocols.match.downstream.ClassicMatchAlgorithm) → None

Enable a strategy where the first round hits are discarded after they are generated

and then, after the second round completes, they are regenerated but respecting the occ-space hash, thereby decreasing the memory use dramatically. That is, the hits for the first geometric constraint (round 1 hits) are discarded, but their presence in the occupied space hash is recorded. Then the hits for the second round are collected, but only the ones that fall into the regions of 6D where the hits from the first round fell. At the end of round 2, the occ-space hash is updated to reflect the regions of 6D where both rounds produced hits. Then the round 1 hits are generated a second time, and this time saved.

C++: protocols::match::downstream::ClassicMatchAlgorithm::set_build_round1_hits_twice() –> void

set_dsbuilder(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm, dsbuilder: protocols::match::downstream::DownstreamBuilder) → None

C++: protocols::match::downstream::DownstreamAlgorithm::set_dsbuilder(class std::shared_ptr<class protocols::match::downstream::DownstreamBuilder>) –> void

set_residue_type(self: pyrosetta.rosetta.protocols.match.downstream.ClassicMatchAlgorithm, restype: pyrosetta.rosetta.core.chemical.ResidueType) → None

C++: protocols::match::downstream::ClassicMatchAlgorithm::set_residue_type(class std::shared_ptr<const class core::chemical::ResidueType>) –> void

upstream_only(self: pyrosetta.rosetta.protocols.match.downstream.ClassicMatchAlgorithm) → bool

This method returns ‘false’ since the classic match algorithm

builds coordinates of the downstream partner and its hits should be hashed in 6D to generate matches

C++: protocols::match::downstream::ClassicMatchAlgorithm::upstream_only() const –> bool

class pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm

Bases: pybind11_object

A class for an algorithm. Given a conformation of the upstream partner, the algorithm is responsible for producing a set of hits.

are_colliding(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm, us_res: pyrosetta.rosetta.core.conformation.Residue, ds_res: pyrosetta.rosetta.core.conformation.Residue, ds_atoms: pyrosetta.rosetta.utility.vector1_core_id_AtomID, catalytic_atoms: pyrosetta.rosetta.utility.vector1_unsigned_long) → bool

C++: protocols::match::downstream::DownstreamAlgorithm::are_colliding(const class core::conformation::Residue &, const class core::conformation::Residue &, const class utility::vector1<class core::id::AtomID, class std::allocator<class core::id::AtomID> > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> bool

assign(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm, : pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm) → pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm

C++: protocols::match::downstream::DownstreamAlgorithm::operator=(const class protocols::match::downstream::DownstreamAlgorithm &) –> const class protocols::match::downstream::DownstreamAlgorithm &

build(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm, scaffold_build_point_id: int, upstream_conf_id: int, upstream_residue: pyrosetta.rosetta.core.conformation.Residue) → pyrosetta.rosetta.std.list_protocols_match_Hit_t

Return a set of hits given a conformation of an upstream residue.

This method must be bit-wise constant and parallelizable in derived classes.

C++: protocols::match::downstream::DownstreamAlgorithm::build(const unsigned long, const unsigned long, const class core::conformation::Residue &) const –> class std::list<class protocols::match::Hit, class std::allocator<class protocols::match::Hit> >

build_hits_at_all_positions(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm, matcher: pyrosetta.rosetta.protocols.match.Matcher) → pyrosetta.rosetta.std.list_protocols_match_Hit_t

Main driver function for hit generation. The algorithm

is responsible for generating hits at all scaffold build points that are valid for this geometric constraint. The base class provides an iterate-across-all-positions-and-splice-together-hit-lists implementation, however, derived classes may overload this function. The base class function is parallelizable with OpenMP. The returned hit list must be in sorted order by 1) hit.scaffold_build_id() and then by 2) hit.upstream_conf_id().

C++: protocols::match::downstream::DownstreamAlgorithm::build_hits_at_all_positions(class protocols::match::Matcher &) –> class std::list<class protocols::match::Hit, class std::allocator<class protocols::match::Hit> >

clone(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm) → pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm

C++: protocols::match::downstream::DownstreamAlgorithm::clone() const –> class std::shared_ptr<class protocols::match::downstream::DownstreamAlgorithm>

generates_primary_hits(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm) → bool

This method returns ‘true’ if the Real6 portion of the returned

hits are “original” descriptions of the downstream coordinates, and not merely duplicates of the downstream coordinates from previous rounds. This method returns ‘false’ if the downstream portion of the returned hits are duplications of previous-round geometries or if the hits returned by this class do not describe the geometry of the downstream coordinates

C++: protocols::match::downstream::DownstreamAlgorithm::generates_primary_hits() const –> bool

geom_cst_id(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm) → int

C++: protocols::match::downstream::DownstreamAlgorithm::geom_cst_id() const –> unsigned long

get_dsbuilder(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm) → protocols::match::downstream::DownstreamBuilder

C++: protocols::match::downstream::DownstreamAlgorithm::get_dsbuilder() const –> class std::shared_ptr<class protocols::match::downstream::DownstreamBuilder>

hits_to_include_with_partial_match(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm, m: pyrosetta.rosetta.protocols.match.match_dspos1) → numeric::kdtree::WrappedPrimitive<std::list<protocols::match::Hit const*, std::allocator<protocols::match::Hit const*> > >

This method is invoked by the Matcher as it enumerates matches should

this class return “true” in it’s upstream_only. method. The Matcher will enumerate matches placing hits into the match for all of the geometric-constraints which describe the downstream partner’s 6D coordinates in their hits, and then for all other geometric constraints in ascending order. The hits for upstream residues 1 to geom_cst_id() - 1 are all valid; the hit for geom-cst i, given that i > geom_cst_id() - 1 is valid if and only if the downstream algorithm for geom-cst i returns true in it’s upstream_only(). The Hit const * list should point at the Matcher’s hits. Between prepare-for-match enumeration and note_match_enumeration_completed, the Matcher provides a guarantee to the downstream algorithm that it’s hit lists have not changed, and therefore all Hit *’s remain valid. The Matcher is providing a “match_dspos1 const &” instead of a “match const &” because this DownstreamAlgorithm should not be examining the 6D coordinates of the downstream partner according to other geometric constraints, and because the Matcher’s match_dspos1-enumeration technique could not readily construct a match, the Matcher’s match-enumeration technique can readily construct a match_dspos1. Data in the input match_dspos1 relating to the downstream partner is undefined.

C++: protocols::match::downstream::DownstreamAlgorithm::hits_to_include_with_partial_match(const struct protocols::match::match_dspos1 &) const –> class std::shared_ptr<const class numeric::kdtree::WrappedPrimitive<class std::list<const class protocols::match::Hit *, class std::allocator<const class protocols::match::Hit *> > > >

n_possible_hits_per_upstream_conformation(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm) → int

C++: protocols::match::downstream::DownstreamAlgorithm::n_possible_hits_per_upstream_conformation() const –> unsigned long

prepare_for_match_enumeration(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm, : pyrosetta.rosetta.protocols.match.Matcher) → None

Called at the conclusion of matching, the Matcher signals

to the downstream algorithm that it’s time to prepare for match generation; if the downstream algorithm needs to enumerate compatible hits in response to the invokation of its hits_to_include_with_partial_match method, then now is the time to prepare for those calls. Base class has a noop implementation.

C++: protocols::match::downstream::DownstreamAlgorithm::prepare_for_match_enumeration(const class protocols::match::Matcher &) –> void

respond_to_peripheral_hitlist_change(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm, matcher: pyrosetta.rosetta.protocols.match.Matcher) → None

Following the change in the number of hits of some other round – either

from the conclusion of that round in which a new set of hits has been generated, or from the cascading change to the hits from round A which were deleted after the conclusion of round B.

C++: protocols::match::downstream::DownstreamAlgorithm::respond_to_peripheral_hitlist_change(class protocols::match::Matcher &) –> void

respond_to_primary_hitlist_change(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm, matcher: pyrosetta.rosetta.protocols.match.Matcher, round_just_completed: int) → None

Reset appropriate Matcher data to spawn the deletion of hits from other rounds

following either hit generation by this geometric constraint, or following hit generation by another geometric constraint which caused the deletion of hits from this geometric constraint. The classic match algorithm, for example, resets the occupied-space hash so that other classic-match algorithms can delete their non-viable hits in subsequent calls to respond_to_peripheral_hitlist_change.

C++: protocols::match::downstream::DownstreamAlgorithm::respond_to_primary_hitlist_change(class protocols::match::Matcher &, unsigned long) –> void

set_active_site_grid(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm, active_site_grid: pyrosetta.rosetta.protocols.match.downstream.ActiveSiteGrid) → None

C++: protocols::match::downstream::DownstreamAlgorithm::set_active_site_grid(class std::shared_ptr<const class protocols::match::downstream::ActiveSiteGrid>) –> void

set_bb_grid(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm, bbgrid: pyrosetta.rosetta.protocols.match.BumpGrid) → None

C++: protocols::match::downstream::DownstreamAlgorithm::set_bb_grid(class std::shared_ptr<const class protocols::match::BumpGrid>) –> void

set_dsbuilder(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm, dsbuilder: protocols::match::downstream::DownstreamBuilder) → None

C++: protocols::match::downstream::DownstreamAlgorithm::set_dsbuilder(class std::shared_ptr<class protocols::match::downstream::DownstreamBuilder>) –> void

upstream_only(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm) → bool

This method returns ‘false’ if the hits generated by this

DownstreamAlgorithm store the 6-dimensional coordinate of the downstream partner in hit.second(), and therefore intend for the Matcher to find matches for this algorithm’s hits by hashing the 6-dimensional coordinate. This method returns ‘true’ if the DownstreamAlgorithm does not use hit.second to store a point in 6D and instead intends the Matcher to find matches by querying this DownstreamAlgorithm’s hits_to_include_with_partial_match method.

C++: protocols::match::downstream::DownstreamAlgorithm::upstream_only() const –> bool

class pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder

Bases: pybind11_object

assign(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder, : pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder) → pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder

C++: protocols::match::downstream::DownstreamBuilder::operator=(const class protocols::match::downstream::DownstreamBuilder &) –> class protocols::match::downstream::DownstreamBuilder &

atom1_atom2_atom3_angle(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder) → float

Returns an angle in degrees between the three downstream atoms.

C++: protocols::match::downstream::DownstreamBuilder::atom1_atom2_atom3_angle() const –> double

atom1_atom2_distance(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder) → float

C++: protocols::match::downstream::DownstreamBuilder::atom1_atom2_distance() const –> double

atom1_belongs_in_active_site(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder) → bool

C++: protocols::match::downstream::DownstreamBuilder::atom1_belongs_in_active_site() const –> bool

atom1_radius(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder) → pyrosetta.rosetta.protocols.match.ProbeRadius

C++: protocols::match::downstream::DownstreamBuilder::atom1_radius() const –> enum protocols::match::ProbeRadius

atom2_atom3_distance(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder) → float

C++: protocols::match::downstream::DownstreamBuilder::atom2_atom3_distance() const –> double

atom2_belongs_in_active_site(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder) → bool

C++: protocols::match::downstream::DownstreamBuilder::atom2_belongs_in_active_site() const –> bool

atom2_radius(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder) → pyrosetta.rosetta.protocols.match.ProbeRadius

C++: protocols::match::downstream::DownstreamBuilder::atom2_radius() const –> enum protocols::match::ProbeRadius

atom3_belongs_in_active_site(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder) → bool

C++: protocols::match::downstream::DownstreamBuilder::atom3_belongs_in_active_site() const –> bool

atom3_radius(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder) → pyrosetta.rosetta.protocols.match.ProbeRadius

C++: protocols::match::downstream::DownstreamBuilder::atom3_radius() const –> enum protocols::match::ProbeRadius

build(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder, atom6_frame: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, scaffold_build_point_id: int, upstream_conf_id: int, external_geometry_id: int, upstream_residue: pyrosetta.rosetta.core.conformation.Residue) → pyrosetta.rosetta.std.list_protocols_match_Hit_t

C++: protocols::match::downstream::DownstreamBuilder::build(const class numeric::HomogeneousTransform<double> &, const unsigned long, const unsigned long, const unsigned long, const class core::conformation::Residue &) const –> class std::list<class protocols::match::Hit, class std::allocator<class protocols::match::Hit> >

clone(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder) → pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder

C++: protocols::match::downstream::DownstreamBuilder::clone() const –> class std::shared_ptr<class protocols::match::downstream::DownstreamBuilder>

compatible(*args, **kwargs)

Overloaded function.

1. compatible(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder, my_hit: pyrosetta.rosetta.protocols.match.Hit, other: pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder, other_hit: pyrosetta.rosetta.protocols.match.Hit) -> bool

2. compatible(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder, my_hit: pyrosetta.rosetta.protocols.match.Hit, other: pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder, other_hit: pyrosetta.rosetta.protocols.match.Hit, first_dispatch: bool) -> bool

C++: protocols::match::downstream::DownstreamBuilder::compatible(const class protocols::match::Hit &, const class protocols::match::downstream::DownstreamBuilder &, const class protocols::match::Hit &, bool) const –> bool

3. compatible(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder, my_hit: pyrosetta.rosetta.protocols.match.Hit, other: protocols::match::downstream::RigidLigandBuilder, other_hit: pyrosetta.rosetta.protocols.match.Hit) -> bool

4. compatible(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder, my_hit: pyrosetta.rosetta.protocols.match.Hit, other: protocols::match::downstream::RigidLigandBuilder, other_hit: pyrosetta.rosetta.protocols.match.Hit, first_dispatch: bool) -> bool

C++: protocols::match::downstream::DownstreamBuilder::compatible(const class protocols::match::Hit &, const class protocols::match::downstream::RigidLigandBuilder &, const class protocols::match::Hit &, bool) const –> bool

5. compatible(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder, my_hit: pyrosetta.rosetta.protocols.match.Hit, other: protocols::match::downstream::LigandConformerBuilder, other_hit: pyrosetta.rosetta.protocols.match.Hit) -> bool

6. compatible(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder, my_hit: pyrosetta.rosetta.protocols.match.Hit, other: protocols::match::downstream::LigandConformerBuilder, other_hit: pyrosetta.rosetta.protocols.match.Hit, first_dispatch: bool) -> bool

C++: protocols::match::downstream::DownstreamBuilder::compatible(const class protocols::match::Hit &, const class protocols::match::downstream::LigandConformerBuilder &, const class protocols::match::Hit &, bool) const –> bool

coordinates_from_hit(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder, hit: pyrosetta.rosetta.protocols.match.Hit, atom_indices: pyrosetta.rosetta.utility.vector1_core_id_AtomID, atom_coords: pyrosetta.rosetta.utility.vector1_numeric_xyzVector_double_t) → None

C++: protocols::match::downstream::DownstreamBuilder::coordinates_from_hit(const class protocols::match::Hit &, const class utility::vector1<class core::id::AtomID, class std::allocator<class core::id::AtomID> > &, class utility::vector1<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &) const –> void

downstream_pose_from_hit(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder, hit: pyrosetta.rosetta.protocols.match.Hit) → pyrosetta.rosetta.core.pose.Pose

C++: protocols::match::downstream::DownstreamBuilder::downstream_pose_from_hit(const class protocols::match::Hit &) const –> class std::shared_ptr<const class core::pose::Pose>

get_lig_conformers(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder, conf_id: int) → protocols::toolbox::match_enzdes_util::LigandConformer

C++: protocols::match::downstream::DownstreamBuilder::get_lig_conformers(unsigned long) const –> class std::shared_ptr<class protocols::toolbox::match_enzdes_util::LigandConformer>

get_upstream_restype(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder) → pyrosetta.rosetta.core.chemical.ResidueType

C++: protocols::match::downstream::DownstreamBuilder::get_upstream_restype() const –> class std::shared_ptr<const class core::chemical::ResidueType>

hits_potentially_incompatible(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder) → bool

In case downstream builders can return hits that

are incompatible with each other (e.g. different ligand conformations ) the matcher needs to know about this to allow for speedy match enumeration

C++: protocols::match::downstream::DownstreamBuilder::hits_potentially_incompatible() const –> bool

n_possible_hits_per_at3frame(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder) → int

C++: protocols::match::downstream::DownstreamBuilder::n_possible_hits_per_at3frame() const –> unsigned long

require_atom_to_reside_in_active_site(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder, id: pyrosetta.rosetta.core.id.AtomID) → None

C++: protocols::match::downstream::DownstreamBuilder::require_atom_to_reside_in_active_site(const class core::id::AtomID &) –> void

set_active_site_grid(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder, active_site_grid: pyrosetta.rosetta.protocols.match.downstream.ActiveSiteGrid) → None

C++: protocols::match::downstream::DownstreamBuilder::set_active_site_grid(class std::shared_ptr<const class protocols::match::downstream::ActiveSiteGrid>) –> void

set_bb_grid(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder, bbgrid: pyrosetta.rosetta.protocols.match.BumpGrid) → None

C++: protocols::match::downstream::DownstreamBuilder::set_bb_grid(class std::shared_ptr<const class protocols::match::BumpGrid>) –> void

set_occupied_space_hash(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder, occ_space: pyrosetta.rosetta.protocols.match.OccupiedSpaceHash) → None

C++: protocols::match::downstream::DownstreamBuilder::set_occupied_space_hash(class std::shared_ptr<const class protocols::match::OccupiedSpaceHash>) –> void

class pyrosetta.rosetta.protocols.match.downstream.GeometrySecMatchRPE

Bases: SecMatchResiduePairEvaluator

holds a list of AtomGeometrySecMatchRPEs, that get evaluated in sequence when an instance of this class is asked to evaluate two residues.

add_atomgeom_evaluator(self: pyrosetta.rosetta.protocols.match.downstream.GeometrySecMatchRPE, evaluator: pyrosetta.rosetta.protocols.match.downstream.AtomGeometrySecMatchRPE) → None

C++: protocols::match::downstream::GeometrySecMatchRPE::add_atomgeom_evaluator(class std::shared_ptr<const class protocols::match::downstream::AtomGeometrySecMatchRPE>) –> void

assign(self: pyrosetta.rosetta.protocols.match.downstream.GeometrySecMatchRPE, : pyrosetta.rosetta.protocols.match.downstream.GeometrySecMatchRPE) → pyrosetta.rosetta.protocols.match.downstream.GeometrySecMatchRPE

C++: protocols::match::downstream::GeometrySecMatchRPE::operator=(const class protocols::match::downstream::GeometrySecMatchRPE &) –> class protocols::match::downstream::GeometrySecMatchRPE &

atom_geom_rpes(self: pyrosetta.rosetta.protocols.match.downstream.GeometrySecMatchRPE) → pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_protocols_match_downstream_AtomGeometrySecMatchRPE_t

C++: protocols::match::downstream::GeometrySecMatchRPE::atom_geom_rpes() const –> const class utility::vector1<class std::shared_ptr<const class protocols::match::downstream::AtomGeometrySecMatchRPE>, class std::allocator<class std::shared_ptr<const class protocols::match::downstream::AtomGeometrySecMatchRPE> > > &

candidate_res_atoms_reqd_near_target_atom(self: pyrosetta.rosetta.protocols.match.downstream.GeometrySecMatchRPE, target_atom_id: int) → pyrosetta.rosetta.utility.vector1_unsigned_long

C++: protocols::match::downstream::GeometrySecMatchRPE::candidate_res_atoms_reqd_near_target_atom(unsigned long) const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

evaluate_residues(self: pyrosetta.rosetta.protocols.match.downstream.GeometrySecMatchRPE, candidate_res: pyrosetta.rosetta.core.conformation.Residue, target_res: pyrosetta.rosetta.core.conformation.Residue) → bool

performs a logical AND for all of the AtomGeometry evaluators.

C++: protocols::match::downstream::GeometrySecMatchRPE::evaluate_residues(const class core::conformation::Residue &, const class core::conformation::Residue &) const –> bool

max_separation_dist_to_target_atom(self: pyrosetta.rosetta.protocols.match.downstream.GeometrySecMatchRPE, target_atom_id: int) → float

C++: protocols::match::downstream::GeometrySecMatchRPE::max_separation_dist_to_target_atom(unsigned long) const –> double

require_all_target_residue_atom_coordinates(self: pyrosetta.rosetta.protocols.match.downstream.GeometrySecMatchRPE) → bool

C++: protocols::match::downstream::GeometrySecMatchRPE::require_all_target_residue_atom_coordinates() const –> bool

require_candidate_residue_atoms_to_lie_near_target_atom(self: pyrosetta.rosetta.protocols.match.downstream.GeometrySecMatchRPE, target_atom_id: int) → bool

C++: protocols::match::downstream::GeometrySecMatchRPE::require_candidate_residue_atoms_to_lie_near_target_atom(unsigned long) const –> bool

require_target_atom_coordinate(self: pyrosetta.rosetta.protocols.match.downstream.GeometrySecMatchRPE, target_atom_id: int) → bool

C++: protocols::match::downstream::GeometrySecMatchRPE::require_target_atom_coordinate(unsigned long) const –> bool

class pyrosetta.rosetta.protocols.match.downstream.LigandConformerBuilder

Bases: DownstreamBuilder

assign(self: pyrosetta.rosetta.protocols.match.downstream.LigandConformerBuilder, : pyrosetta.rosetta.protocols.match.downstream.LigandConformerBuilder) → pyrosetta.rosetta.protocols.match.downstream.LigandConformerBuilder

C++: protocols::match::downstream::LigandConformerBuilder::operator=(const class protocols::match::downstream::LigandConformerBuilder &) –> class protocols::match::downstream::LigandConformerBuilder &

assign_conformer_group_to_residue(self: pyrosetta.rosetta.protocols.match.downstream.LigandConformerBuilder, residue: pyrosetta.rosetta.core.conformation.Residue, relevant_atom_indices: pyrosetta.rosetta.utility.vector1_unsigned_long) → int

C++: protocols::match::downstream::LigandConformerBuilder::assign_conformer_group_to_residue(const class core::conformation::Residue &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> unsigned long

atom1_atom2_atom3_angle(self: pyrosetta.rosetta.protocols.match.downstream.LigandConformerBuilder) → float

Returns an angle in degrees between the three downstream atoms.

C++: protocols::match::downstream::LigandConformerBuilder::atom1_atom2_atom3_angle() const –> double

atom1_atom2_distance(self: pyrosetta.rosetta.protocols.match.downstream.LigandConformerBuilder) → float

C++: protocols::match::downstream::LigandConformerBuilder::atom1_atom2_distance() const –> double

atom1_belongs_in_active_site(self: pyrosetta.rosetta.protocols.match.downstream.LigandConformerBuilder) → bool

C++: protocols::match::downstream::LigandConformerBuilder::atom1_belongs_in_active_site() const –> bool

atom1_radius(self: pyrosetta.rosetta.protocols.match.downstream.LigandConformerBuilder) → pyrosetta.rosetta.protocols.match.ProbeRadius

C++: protocols::match::downstream::LigandConformerBuilder::atom1_radius() const –> enum protocols::match::ProbeRadius

atom2_atom3_distance(self: pyrosetta.rosetta.protocols.match.downstream.LigandConformerBuilder) → float

C++: protocols::match::downstream::LigandConformerBuilder::atom2_atom3_distance() const –> double

atom2_belongs_in_active_site(self: pyrosetta.rosetta.protocols.match.downstream.LigandConformerBuilder) → bool

C++: protocols::match::downstream::LigandConformerBuilder::atom2_belongs_in_active_site() const –> bool

atom2_radius(self: pyrosetta.rosetta.protocols.match.downstream.LigandConformerBuilder) → pyrosetta.rosetta.protocols.match.ProbeRadius

C++: protocols::match::downstream::LigandConformerBuilder::atom2_radius() const –> enum protocols::match::ProbeRadius

atom3_belongs_in_active_site(self: pyrosetta.rosetta.protocols.match.downstream.LigandConformerBuilder) → bool

C++: protocols::match::downstream::LigandConformerBuilder::atom3_belongs_in_active_site() const –> bool

atom3_radius(self: pyrosetta.rosetta.protocols.match.downstream.LigandConformerBuilder) → pyrosetta.rosetta.protocols.match.ProbeRadius

C++: protocols::match::downstream::LigandConformerBuilder::atom3_radius() const –> enum protocols::match::ProbeRadius

build(self: pyrosetta.rosetta.protocols.match.downstream.LigandConformerBuilder, atom3_frame: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, scaffold_build_point_id: int, upstream_conf_id: int, external_geometry_id: int, upstream_residue: pyrosetta.rosetta.core.conformation.Residue) → pyrosetta.rosetta.std.list_protocols_match_Hit_t

C++: protocols::match::downstream::LigandConformerBuilder::build(const class numeric::HomogeneousTransform<double> &, const unsigned long, const unsigned long, const unsigned long, const class core::conformation::Residue &) const –> class std::list<class protocols::match::Hit, class std::allocator<class protocols::match::Hit> >

clone(self: pyrosetta.rosetta.protocols.match.downstream.LigandConformerBuilder) → pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder

C++: protocols::match::downstream::LigandConformerBuilder::clone() const –> class std::shared_ptr<class protocols::match::downstream::DownstreamBuilder>

compatible(*args, **kwargs)

Overloaded function.

1. compatible(self: pyrosetta.rosetta.protocols.match.downstream.LigandConformerBuilder, my_hit: pyrosetta.rosetta.protocols.match.Hit, other: pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder, other_hit: pyrosetta.rosetta.protocols.match.Hit) -> bool

2. compatible(self: pyrosetta.rosetta.protocols.match.downstream.LigandConformerBuilder, my_hit: pyrosetta.rosetta.protocols.match.Hit, other: pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder, other_hit: pyrosetta.rosetta.protocols.match.Hit, first_dispatch: bool) -> bool

C++: protocols::match::downstream::LigandConformerBuilder::compatible(const class protocols::match::Hit &, const class protocols::match::downstream::DownstreamBuilder &, const class protocols::match::Hit &, bool) const –> bool

3. compatible(self: pyrosetta.rosetta.protocols.match.downstream.LigandConformerBuilder, my_hit: pyrosetta.rosetta.protocols.match.Hit, other: pyrosetta.rosetta.protocols.match.downstream.LigandConformerBuilder, other_hit: pyrosetta.rosetta.protocols.match.Hit) -> bool

4. compatible(self: pyrosetta.rosetta.protocols.match.downstream.LigandConformerBuilder, my_hit: pyrosetta.rosetta.protocols.match.Hit, other: pyrosetta.rosetta.protocols.match.downstream.LigandConformerBuilder, other_hit: pyrosetta.rosetta.protocols.match.Hit, first_dispatch: bool) -> bool

C++: protocols::match::downstream::LigandConformerBuilder::compatible(const class protocols::match::Hit &, const class protocols::match::downstream::LigandConformerBuilder &, const class protocols::match::Hit &, bool) const –> bool

coordinates_from_hit(self: pyrosetta.rosetta.protocols.match.downstream.LigandConformerBuilder, hit: pyrosetta.rosetta.protocols.match.Hit, atom_indices: pyrosetta.rosetta.utility.vector1_core_id_AtomID, atom_coords: pyrosetta.rosetta.utility.vector1_numeric_xyzVector_double_t) → None

C++: protocols::match::downstream::LigandConformerBuilder::coordinates_from_hit(const class protocols::match::Hit &, const class utility::vector1<class core::id::AtomID, class std::allocator<class core::id::AtomID> > &, class utility::vector1<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &) const –> void

determine_redundant_conformer_groups(self: pyrosetta.rosetta.protocols.match.downstream.LigandConformerBuilder, relevant_atom_indices: pyrosetta.rosetta.utility.vector1_unsigned_long) → None

goes through the list of conformers and does rms calculations (overlaid

on the relevant_atom_indices) between them. any conformers that have an rms < rmsd_unique_cutoff_ will be grouped together in a conformer_group

C++: protocols::match::downstream::LigandConformerBuilder::determine_redundant_conformer_groups(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> void

downstream_pose_from_hit(self: pyrosetta.rosetta.protocols.match.downstream.LigandConformerBuilder, hit: pyrosetta.rosetta.protocols.match.Hit) → pyrosetta.rosetta.core.pose.Pose

C++: protocols::match::downstream::LigandConformerBuilder::downstream_pose_from_hit(const class protocols::match::Hit &) const –> class std::shared_ptr<const class core::pose::Pose>

get_lig_conformers(self: pyrosetta.rosetta.protocols.match.downstream.LigandConformerBuilder, conf_id: int) → protocols::toolbox::match_enzdes_util::LigandConformer

C++: protocols::match::downstream::LigandConformerBuilder::get_lig_conformers(unsigned long) const –> class std::shared_ptr<class protocols::toolbox::match_enzdes_util::LigandConformer>

get_upstream_restype(self: pyrosetta.rosetta.protocols.match.downstream.LigandConformerBuilder) → pyrosetta.rosetta.core.chemical.ResidueType

C++: protocols::match::downstream::LigandConformerBuilder::get_upstream_restype() const –> class std::shared_ptr<const class core::chemical::ResidueType>

hits_potentially_incompatible(self: pyrosetta.rosetta.protocols.match.downstream.LigandConformerBuilder) → bool

C++: protocols::match::downstream::LigandConformerBuilder::hits_potentially_incompatible() const –> bool

ignore_h_collisions(self: pyrosetta.rosetta.protocols.match.downstream.LigandConformerBuilder, setting: bool) → None

C++: protocols::match::downstream::LigandConformerBuilder::ignore_h_collisions(bool) –> void

initialize_from_residue(self: pyrosetta.rosetta.protocols.match.downstream.LigandConformerBuilder, atom1: int, atom2: int, atom3: int, orientation_atom1: int, orientation_atom2: int, orientation_atom3: int, residue: pyrosetta.rosetta.core.conformation.Residue) → None

Specify the residue, with coordinates, that’s being used as the downstream

partner. This class is meant to be used in conjuction with the ClassicMatchAglrotihm, and therefore the initialization routines are specific for that algorithm. In this initialization function, one must list atoms “D1, D2 and D3” in the convention of describing the rigid-body orientation between three atoms of the upstream partner (atoms U3, U2 & U1) and three atoms of the downstream partner (atoms D1, D2 & D3) in terms of 2 angles, 1 distance, and 3 dihedrals. The user must also list the 3 atoms used to define the orientation frame of the downstream ligand. It is essential to the matching algorithm that the same three orientation atoms are used for all LigandConformerBuilders.

C++: protocols::match::downstream::LigandConformerBuilder::initialize_from_residue(unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, const class core::conformation::Residue &) –> void

initialize_upstream_residue(*args, **kwargs)

Overloaded function.

1. initialize_upstream_residue(self: pyrosetta.rosetta.protocols.match.downstream.LigandConformerBuilder, upstream_res: pyrosetta.rosetta.core.chemical.ResidueType) -> None

2. initialize_upstream_residue(self: pyrosetta.rosetta.protocols.match.downstream.LigandConformerBuilder, upstream_res: pyrosetta.rosetta.core.chemical.ResidueType, count_pair: pyrosetta.rosetta.core.scoring.etable.count_pair.CountPairFunction) -> None

C++: protocols::match::downstream::LigandConformerBuilder::initialize_upstream_residue(class std::shared_ptr<const class core::chemical::ResidueType>, class std::shared_ptr<const class core::scoring::etable::count_pair::CountPairFunction>) –> void

n_possible_hits_per_at3frame(self: pyrosetta.rosetta.protocols.match.downstream.LigandConformerBuilder) → int

C++: protocols::match::downstream::LigandConformerBuilder::n_possible_hits_per_at3frame() const –> unsigned long

require_atom_to_reside_in_active_site(self: pyrosetta.rosetta.protocols.match.downstream.LigandConformerBuilder, id: pyrosetta.rosetta.core.id.AtomID) → None

C++: protocols::match::downstream::LigandConformerBuilder::require_atom_to_reside_in_active_site(const class core::id::AtomID &) –> void

set_active_site_grid(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder, active_site_grid: pyrosetta.rosetta.protocols.match.downstream.ActiveSiteGrid) → None

C++: protocols::match::downstream::DownstreamBuilder::set_active_site_grid(class std::shared_ptr<const class protocols::match::downstream::ActiveSiteGrid>) –> void

set_bb_grid(self: pyrosetta.rosetta.protocols.match.downstream.LigandConformerBuilder, bbgrid: pyrosetta.rosetta.protocols.match.BumpGrid) → None

C++: protocols::match::downstream::LigandConformerBuilder::set_bb_grid(class std::shared_ptr<const class protocols::match::BumpGrid>) –> void

set_idealize_conformers(self: pyrosetta.rosetta.protocols.match.downstream.LigandConformerBuilder, setting: bool) → None

C++: protocols::match::downstream::LigandConformerBuilder::set_idealize_conformers(bool) –> void

set_occupied_space_hash(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder, occ_space: pyrosetta.rosetta.protocols.match.OccupiedSpaceHash) → None

C++: protocols::match::downstream::DownstreamBuilder::set_occupied_space_hash(class std::shared_ptr<const class protocols::match::OccupiedSpaceHash>) –> void

set_rmsd_unique_cutoff(self: pyrosetta.rosetta.protocols.match.downstream.LigandConformerBuilder, setting: float) → None

C++: protocols::match::downstream::LigandConformerBuilder::set_rmsd_unique_cutoff(double) –> void

class pyrosetta.rosetta.protocols.match.downstream.RigidLigandBuilder

Bases: DownstreamBuilder

assign(self: pyrosetta.rosetta.protocols.match.downstream.RigidLigandBuilder, : pyrosetta.rosetta.protocols.match.downstream.RigidLigandBuilder) → pyrosetta.rosetta.protocols.match.downstream.RigidLigandBuilder

C++: protocols::match::downstream::RigidLigandBuilder::operator=(const class protocols::match::downstream::RigidLigandBuilder &) –> class protocols::match::downstream::RigidLigandBuilder &

atom1_atom2_atom3_angle(self: pyrosetta.rosetta.protocols.match.downstream.RigidLigandBuilder) → float

Returns an angle in degrees between the three downstream atoms.

C++: protocols::match::downstream::RigidLigandBuilder::atom1_atom2_atom3_angle() const –> double

atom1_atom2_distance(self: pyrosetta.rosetta.protocols.match.downstream.RigidLigandBuilder) → float

C++: protocols::match::downstream::RigidLigandBuilder::atom1_atom2_distance() const –> double

atom1_belongs_in_active_site(self: pyrosetta.rosetta.protocols.match.downstream.RigidLigandBuilder) → bool

C++: protocols::match::downstream::RigidLigandBuilder::atom1_belongs_in_active_site() const –> bool

atom1_radius(self: pyrosetta.rosetta.protocols.match.downstream.RigidLigandBuilder) → pyrosetta.rosetta.protocols.match.ProbeRadius

C++: protocols::match::downstream::RigidLigandBuilder::atom1_radius() const –> enum protocols::match::ProbeRadius

atom2_atom3_distance(self: pyrosetta.rosetta.protocols.match.downstream.RigidLigandBuilder) → float

C++: protocols::match::downstream::RigidLigandBuilder::atom2_atom3_distance() const –> double

atom2_belongs_in_active_site(self: pyrosetta.rosetta.protocols.match.downstream.RigidLigandBuilder) → bool

C++: protocols::match::downstream::RigidLigandBuilder::atom2_belongs_in_active_site() const –> bool

atom2_radius(self: pyrosetta.rosetta.protocols.match.downstream.RigidLigandBuilder) → pyrosetta.rosetta.protocols.match.ProbeRadius

C++: protocols::match::downstream::RigidLigandBuilder::atom2_radius() const –> enum protocols::match::ProbeRadius

atom3_belongs_in_active_site(self: pyrosetta.rosetta.protocols.match.downstream.RigidLigandBuilder) → bool

C++: protocols::match::downstream::RigidLigandBuilder::atom3_belongs_in_active_site() const –> bool

atom3_radius(self: pyrosetta.rosetta.protocols.match.downstream.RigidLigandBuilder) → pyrosetta.rosetta.protocols.match.ProbeRadius

C++: protocols::match::downstream::RigidLigandBuilder::atom3_radius() const –> enum protocols::match::ProbeRadius

build(self: pyrosetta.rosetta.protocols.match.downstream.RigidLigandBuilder, atom3_frame: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, scaffold_build_point_id: int, upstream_conf_id: int, external_geometry_id: int, upstream_residue: pyrosetta.rosetta.core.conformation.Residue) → pyrosetta.rosetta.std.list_protocols_match_Hit_t

C++: protocols::match::downstream::RigidLigandBuilder::build(const class numeric::HomogeneousTransform<double> &, const unsigned long, const unsigned long, const unsigned long, const class core::conformation::Residue &) const –> class std::list<class protocols::match::Hit, class std::allocator<class protocols::match::Hit> >

clone(self: pyrosetta.rosetta.protocols.match.downstream.RigidLigandBuilder) → pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder

C++: protocols::match::downstream::RigidLigandBuilder::clone() const –> class std::shared_ptr<class protocols::match::downstream::DownstreamBuilder>

compatible(*args, **kwargs)

Overloaded function.

1. compatible(self: pyrosetta.rosetta.protocols.match.downstream.RigidLigandBuilder, my_hit: pyrosetta.rosetta.protocols.match.Hit, other: pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder, other_hit: pyrosetta.rosetta.protocols.match.Hit) -> bool

2. compatible(self: pyrosetta.rosetta.protocols.match.downstream.RigidLigandBuilder, my_hit: pyrosetta.rosetta.protocols.match.Hit, other: pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder, other_hit: pyrosetta.rosetta.protocols.match.Hit, first_dispatch: bool) -> bool

C++: protocols::match::downstream::RigidLigandBuilder::compatible(const class protocols::match::Hit &, const class protocols::match::downstream::DownstreamBuilder &, const class protocols::match::Hit &, bool) const –> bool

3. compatible(self: pyrosetta.rosetta.protocols.match.downstream.RigidLigandBuilder, my_hit: pyrosetta.rosetta.protocols.match.Hit, other: pyrosetta.rosetta.protocols.match.downstream.RigidLigandBuilder, other_hit: pyrosetta.rosetta.protocols.match.Hit) -> bool

4. compatible(self: pyrosetta.rosetta.protocols.match.downstream.RigidLigandBuilder, my_hit: pyrosetta.rosetta.protocols.match.Hit, other: pyrosetta.rosetta.protocols.match.downstream.RigidLigandBuilder, other_hit: pyrosetta.rosetta.protocols.match.Hit, first_dispatch: bool) -> bool

C++: protocols::match::downstream::RigidLigandBuilder::compatible(const class protocols::match::Hit &, const class protocols::match::downstream::RigidLigandBuilder &, const class protocols::match::Hit &, bool) const –> bool

coordinates_from_hit(self: pyrosetta.rosetta.protocols.match.downstream.RigidLigandBuilder, hit: pyrosetta.rosetta.protocols.match.Hit, atom_indices: pyrosetta.rosetta.utility.vector1_core_id_AtomID, atom_coords: pyrosetta.rosetta.utility.vector1_numeric_xyzVector_double_t) → None

C++: protocols::match::downstream::RigidLigandBuilder::coordinates_from_hit(const class protocols::match::Hit &, const class utility::vector1<class core::id::AtomID, class std::allocator<class core::id::AtomID> > &, class utility::vector1<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &) const –> void

downstream_pose_from_hit(self: pyrosetta.rosetta.protocols.match.downstream.RigidLigandBuilder, hit: pyrosetta.rosetta.protocols.match.Hit) → pyrosetta.rosetta.core.pose.Pose

C++: protocols::match::downstream::RigidLigandBuilder::downstream_pose_from_hit(const class protocols::match::Hit &) const –> class std::shared_ptr<const class core::pose::Pose>

get_lig_conformers(self: pyrosetta.rosetta.protocols.match.downstream.RigidLigandBuilder, conf_id: int) → protocols::toolbox::match_enzdes_util::LigandConformer

C++: protocols::match::downstream::RigidLigandBuilder::get_lig_conformers(unsigned long) const –> class std::shared_ptr<class protocols::toolbox::match_enzdes_util::LigandConformer>

get_upstream_restype(self: pyrosetta.rosetta.protocols.match.downstream.RigidLigandBuilder) → pyrosetta.rosetta.core.chemical.ResidueType

C++: protocols::match::downstream::RigidLigandBuilder::get_upstream_restype() const –> class std::shared_ptr<const class core::chemical::ResidueType>

hits_potentially_incompatible(self: pyrosetta.rosetta.protocols.match.downstream.RigidLigandBuilder) → bool

C++: protocols::match::downstream::RigidLigandBuilder::hits_potentially_incompatible() const –> bool

ignore_h_collisions(self: pyrosetta.rosetta.protocols.match.downstream.RigidLigandBuilder, setting: bool) → None

C++: protocols::match::downstream::RigidLigandBuilder::ignore_h_collisions(bool) –> void

initialize_from_residue(self: pyrosetta.rosetta.protocols.match.downstream.RigidLigandBuilder, atom1: int, atom2: int, atom3: int, orientation_atom1: int, orientation_atom2: int, orientation_atom3: int, residue: pyrosetta.rosetta.core.conformation.Residue) → None

Specify the residue, with coordinates, that’s being used as the downstream

partner. This class is meant to be used in conjuction with the ClassicMatchAglrotihm, and therefore the initialization routines are specific for that algorithm. In this initialization function, one must list atoms “D1, D2 and D3” in the convention of describing the rigid-body orientation between three atoms of the upstream partner (atoms U3, U2 & U1) and three atoms of the downstream partner (atoms D1, D2 & D3) in terms of 2 angles, 1 distance, and 3 dihedrals. The user must also list the 3 atoms used to define the orientation frame of the downstream ligand. It is essential to the matching algorithm that the same three orientation atoms are used for all RigidLigandBuilders.

C++: protocols::match::downstream::RigidLigandBuilder::initialize_from_residue(unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, const class core::conformation::Residue &) –> void

initialize_upstream_residue(*args, **kwargs)

Overloaded function.

1. initialize_upstream_residue(self: pyrosetta.rosetta.protocols.match.downstream.RigidLigandBuilder, upstream_res: pyrosetta.rosetta.core.chemical.ResidueType) -> None

2. initialize_upstream_residue(self: pyrosetta.rosetta.protocols.match.downstream.RigidLigandBuilder, upstream_res: pyrosetta.rosetta.core.chemical.ResidueType, count_pair: pyrosetta.rosetta.core.scoring.etable.count_pair.CountPairFunction) -> None

C++: protocols::match::downstream::RigidLigandBuilder::initialize_upstream_residue(class std::shared_ptr<const class core::chemical::ResidueType>, class std::shared_ptr<const class core::scoring::etable::count_pair::CountPairFunction>) –> void

n_possible_hits_per_at3frame(self: pyrosetta.rosetta.protocols.match.downstream.RigidLigandBuilder) → int

C++: protocols::match::downstream::RigidLigandBuilder::n_possible_hits_per_at3frame() const –> unsigned long

require_atom_to_reside_in_active_site(self: pyrosetta.rosetta.protocols.match.downstream.RigidLigandBuilder, id: pyrosetta.rosetta.core.id.AtomID) → None

C++: protocols::match::downstream::RigidLigandBuilder::require_atom_to_reside_in_active_site(const class core::id::AtomID &) –> void

set_active_site_grid(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder, active_site_grid: pyrosetta.rosetta.protocols.match.downstream.ActiveSiteGrid) → None

C++: protocols::match::downstream::DownstreamBuilder::set_active_site_grid(class std::shared_ptr<const class protocols::match::downstream::ActiveSiteGrid>) –> void

set_bb_grid(self: pyrosetta.rosetta.protocols.match.downstream.RigidLigandBuilder, bbgrid: pyrosetta.rosetta.protocols.match.BumpGrid) → None

C++: protocols::match::downstream::RigidLigandBuilder::set_bb_grid(class std::shared_ptr<const class protocols::match::BumpGrid>) –> void

set_occupied_space_hash(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamBuilder, occ_space: pyrosetta.rosetta.protocols.match.OccupiedSpaceHash) → None

C++: protocols::match::downstream::DownstreamBuilder::set_occupied_space_hash(class std::shared_ptr<const class protocols::match::OccupiedSpaceHash>) –> void

class pyrosetta.rosetta.protocols.match.downstream.ScoringSecMatchRPE

Bases: SecMatchResiduePairEvaluator

assign(self: pyrosetta.rosetta.protocols.match.downstream.ScoringSecMatchRPE, : pyrosetta.rosetta.protocols.match.downstream.ScoringSecMatchRPE) → pyrosetta.rosetta.protocols.match.downstream.ScoringSecMatchRPE

C++: protocols::match::downstream::ScoringSecMatchRPE::operator=(const class protocols::match::downstream::ScoringSecMatchRPE &) –> class protocols::match::downstream::ScoringSecMatchRPE &

candidate_res_atoms_reqd_near_target_atom(self: pyrosetta.rosetta.protocols.match.downstream.SecMatchResiduePairEvaluator, target_atom_id: int) → pyrosetta.rosetta.utility.vector1_unsigned_long

Return a list of atom indices on the candidate residue; if all atoms

in this list are further than max_separation_dist_to_target_atom() away from the target_atom_id atom for a given pair of conformations of the target_residue and the candidate_residue, then this evaluator will return false in the call to evaluate( candidate_residue, target_residue ). This list will allow the SecondaryMatcher to (conservatively!) prune conformations of the candidate_residue from consideration. The base class implements a noop – it returns an empty list.

C++: protocols::match::downstream::SecMatchResiduePairEvaluator::candidate_res_atoms_reqd_near_target_atom(unsigned long) const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

check2bsc(self: pyrosetta.rosetta.protocols.match.downstream.ScoringSecMatchRPE, sType: pyrosetta.rosetta.core.scoring.ScoreType, wts: float) → bool

C++: protocols::match::downstream::ScoringSecMatchRPE::check2bsc(enum core::scoring::ScoreType, double) –> bool

eval_cd_2b_residues(self: pyrosetta.rosetta.protocols.match.downstream.ScoringSecMatchRPE, match_res: pyrosetta.rosetta.core.conformation.Residue, target_res: pyrosetta.rosetta.core.conformation.Residue) → bool

C++: protocols::match::downstream::ScoringSecMatchRPE::eval_cd_2b_residues(const class core::conformation::Residue &, const class core::conformation::Residue &) const –> bool

eval_longRange_2b_residue(self: pyrosetta.rosetta.protocols.match.downstream.ScoringSecMatchRPE, match_res: pyrosetta.rosetta.core.conformation.Residue, target_res: pyrosetta.rosetta.core.conformation.Residue) → bool

C++: protocols::match::downstream::ScoringSecMatchRPE::eval_longRange_2b_residue(const class core::conformation::Residue &, const class core::conformation::Residue &) const –> bool

evaluate_residues(self: pyrosetta.rosetta.protocols.match.downstream.ScoringSecMatchRPE, match_res: pyrosetta.rosetta.core.conformation.Residue, target_res: pyrosetta.rosetta.core.conformation.Residue) → bool

C++: protocols::match::downstream::ScoringSecMatchRPE::evaluate_residues(const class core::conformation::Residue &, const class core::conformation::Residue &) const –> bool

getCutoff(self: pyrosetta.rosetta.protocols.match.downstream.ScoringSecMatchRPE) → float

C++: protocols::match::downstream::ScoringSecMatchRPE::getCutoff() const –> double

get_score_function(self: pyrosetta.rosetta.protocols.match.downstream.ScoringSecMatchRPE) → pyrosetta.rosetta.core.scoring.ScoreFunction

C++: protocols::match::downstream::ScoringSecMatchRPE::get_score_function() –> class std::shared_ptr<class core::scoring::ScoreFunction>

max_separation_dist_to_target_atom(self: pyrosetta.rosetta.protocols.match.downstream.SecMatchResiduePairEvaluator, target_atom_id: int) → float

Return the maximum separation distance that any of the match-residue

atoms identified by the function match_atoms_reqd_near_target_atom may be from a particular atom on the target residue. Returns a negative value if there is no requirement that any atom be within a certain radius of the target atom. The base class implementation returns -1.0.

C++: protocols::match::downstream::SecMatchResiduePairEvaluator::max_separation_dist_to_target_atom(unsigned long) const –> double

require_all_target_residue_atom_coordinates(self: pyrosetta.rosetta.protocols.match.downstream.ScoringSecMatchRPE) → bool

C++: protocols::match::downstream::ScoringSecMatchRPE::require_all_target_residue_atom_coordinates() const –> bool

require_candidate_residue_atoms_to_lie_near_target_atom(self: pyrosetta.rosetta.protocols.match.downstream.SecMatchResiduePairEvaluator, target_atom_id: int) → bool

Are there atoms of the candidate residue that must be within

some cutoff distance of a given atom on the target residue? Base class implementation returns false.

C++: protocols::match::downstream::SecMatchResiduePairEvaluator::require_candidate_residue_atoms_to_lie_near_target_atom(unsigned long) const –> bool

require_target_atom_coordinate(self: pyrosetta.rosetta.protocols.match.downstream.ScoringSecMatchRPE, target_atom_id: int) → bool

C++: protocols::match::downstream::ScoringSecMatchRPE::require_target_atom_coordinate(unsigned long) const –> bool

property scoringEval_counter

setPose(self: pyrosetta.rosetta.protocols.match.downstream.ScoringSecMatchRPE, ref_pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::match::downstream::ScoringSecMatchRPE::setPose(const class core::pose::Pose &) –> void

class pyrosetta.rosetta.protocols.match.downstream.SecMatchEvaluatorFactory

Bases: pybind11_object

a collection of functions making a single score_function

static create_SecMatchResiduePairEvaluatorOP(mcfi: protocols::toolbox::match_enzdes_util::MatchConstraintFileInfo, downstream_inds: pyrosetta.rosetta.utility.vector1_unsigned_long, upstream_inds: pyrosetta.rosetta.utility.vector1_unsigned_long, SecMatchStr: str, upstream_pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.protocols.match.downstream.SecMatchResiduePairEvaluator

C++: protocols::match::downstream::SecMatchEvaluatorFactory::create_SecMatchResiduePairEvaluatorOP(const class protocols::toolbox::match_enzdes_util::MatchConstraintFileInfo &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, std::string, const class core::pose::Pose &) –> class std::shared_ptr<class protocols::match::downstream::SecMatchResiduePairEvaluator>

class pyrosetta.rosetta.protocols.match.downstream.SecMatchResiduePairEvaluator

Bases: pybind11_object

base for class used by secondary matcher to determine whether a given residue to be matched interacts satisfactorily with a target residue

assign(self: pyrosetta.rosetta.protocols.match.downstream.SecMatchResiduePairEvaluator, : pyrosetta.rosetta.protocols.match.downstream.SecMatchResiduePairEvaluator) → pyrosetta.rosetta.protocols.match.downstream.SecMatchResiduePairEvaluator

C++: protocols::match::downstream::SecMatchResiduePairEvaluator::operator=(const class protocols::match::downstream::SecMatchResiduePairEvaluator &) –> class protocols::match::downstream::SecMatchResiduePairEvaluator &

candidate_res_atoms_reqd_near_target_atom(self: pyrosetta.rosetta.protocols.match.downstream.SecMatchResiduePairEvaluator, target_atom_id: int) → pyrosetta.rosetta.utility.vector1_unsigned_long

Return a list of atom indices on the candidate residue; if all atoms

in this list are further than max_separation_dist_to_target_atom() away from the target_atom_id atom for a given pair of conformations of the target_residue and the candidate_residue, then this evaluator will return false in the call to evaluate( candidate_residue, target_residue ). This list will allow the SecondaryMatcher to (conservatively!) prune conformations of the candidate_residue from consideration. The base class implements a noop – it returns an empty list.

C++: protocols::match::downstream::SecMatchResiduePairEvaluator::candidate_res_atoms_reqd_near_target_atom(unsigned long) const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

evaluate_residues(self: pyrosetta.rosetta.protocols.match.downstream.SecMatchResiduePairEvaluator, candidate_res: pyrosetta.rosetta.core.conformation.Residue, target_res: pyrosetta.rosetta.core.conformation.Residue) → bool

Returns true if the interaction between the two residues satisifies the

secondary match requirement. candidate_res: the rotamer of the residue trying to be placed target_res: the previously placed residue

C++: protocols::match::downstream::SecMatchResiduePairEvaluator::evaluate_residues(const class core::conformation::Residue &, const class core::conformation::Residue &) const –> bool

max_separation_dist_to_target_atom(self: pyrosetta.rosetta.protocols.match.downstream.SecMatchResiduePairEvaluator, target_atom_id: int) → float

Return the maximum separation distance that any of the match-residue

atoms identified by the function match_atoms_reqd_near_target_atom may be from a particular atom on the target residue. Returns a negative value if there is no requirement that any atom be within a certain radius of the target atom. The base class implementation returns -1.0.

C++: protocols::match::downstream::SecMatchResiduePairEvaluator::max_separation_dist_to_target_atom(unsigned long) const –> double

require_all_target_residue_atom_coordinates(self: pyrosetta.rosetta.protocols.match.downstream.SecMatchResiduePairEvaluator) → bool

Returns true if all coordinates of the target residue are required

in order to evaluate the interaction between the candidate and the target residues.

C++: protocols::match::downstream::SecMatchResiduePairEvaluator::require_all_target_residue_atom_coordinates() const –> bool

require_candidate_residue_atoms_to_lie_near_target_atom(self: pyrosetta.rosetta.protocols.match.downstream.SecMatchResiduePairEvaluator, target_atom_id: int) → bool

Are there atoms of the candidate residue that must be within

some cutoff distance of a given atom on the target residue? Base class implementation returns false.

C++: protocols::match::downstream::SecMatchResiduePairEvaluator::require_candidate_residue_atoms_to_lie_near_target_atom(unsigned long) const –> bool

require_target_atom_coordinate(self: pyrosetta.rosetta.protocols.match.downstream.SecMatchResiduePairEvaluator, target_atom_id: int) → bool

If require_all_target_residue_atom_coordinates() returns false, then

this method should return true for the atoms on the target residue that the evaluator requires.

C++: protocols::match::downstream::SecMatchResiduePairEvaluator::require_target_atom_coordinate(unsigned long) const –> bool

class pyrosetta.rosetta.protocols.match.downstream.SecondaryMatchUpstreamResProcessor

Bases: UpstreamResidueProcessor

A simple class to respond to the UpstreamBuilder’s process_hit method and pass on the coordinates to its “owning” SecondaryMatcherToUpstreamResidue object.

assign(self: pyrosetta.rosetta.protocols.match.upstream.UpstreamResidueProcessor, : pyrosetta.rosetta.protocols.match.upstream.UpstreamResidueProcessor) → pyrosetta.rosetta.protocols.match.upstream.UpstreamResidueProcessor

C++: protocols::match::upstream::UpstreamResidueProcessor::operator=(const class protocols::match::upstream::UpstreamResidueProcessor &) –> class protocols::match::upstream::UpstreamResidueProcessor &

process_hit(self: pyrosetta.rosetta.protocols.match.downstream.SecondaryMatchUpstreamResProcessor, hit: pyrosetta.rosetta.protocols.match.Hit, upstream_conformation: pyrosetta.rosetta.core.conformation.Residue) → None

C++: protocols::match::downstream::SecondaryMatchUpstreamResProcessor::process_hit(const class protocols::match::Hit &, const class core::conformation::Residue &) –> void

class pyrosetta.rosetta.protocols.match.downstream.SecondaryMatcherToDownstreamResidue

Bases: DownstreamAlgorithm

A class for an algorithm. Given a conformation of the downstream partner, the algorithm is responsible for producing a set of hits.

add_evaluator(self: pyrosetta.rosetta.protocols.match.downstream.SecondaryMatcherToDownstreamResidue, evaluator: pyrosetta.rosetta.protocols.match.downstream.SecMatchResiduePairEvaluator, mcfi_id: int) → None

C++: protocols::match::downstream::SecondaryMatcherToDownstreamResidue::add_evaluator(class std::shared_ptr<const class protocols::match::downstream::SecMatchResiduePairEvaluator>, unsigned long) –> void

are_colliding(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm, us_res: pyrosetta.rosetta.core.conformation.Residue, ds_res: pyrosetta.rosetta.core.conformation.Residue, ds_atoms: pyrosetta.rosetta.utility.vector1_core_id_AtomID, catalytic_atoms: pyrosetta.rosetta.utility.vector1_unsigned_long) → bool

C++: protocols::match::downstream::DownstreamAlgorithm::are_colliding(const class core::conformation::Residue &, const class core::conformation::Residue &, const class utility::vector1<class core::id::AtomID, class std::allocator<class core::id::AtomID> > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> bool

assign(self: pyrosetta.rosetta.protocols.match.downstream.SecondaryMatcherToDownstreamResidue, : pyrosetta.rosetta.protocols.match.downstream.SecondaryMatcherToDownstreamResidue) → pyrosetta.rosetta.protocols.match.downstream.SecondaryMatcherToDownstreamResidue

C++: protocols::match::downstream::SecondaryMatcherToDownstreamResidue::operator=(const class protocols::match::downstream::SecondaryMatcherToDownstreamResidue &) –> class protocols::match::downstream::SecondaryMatcherToDownstreamResidue &

build(self: pyrosetta.rosetta.protocols.match.downstream.SecondaryMatcherToDownstreamResidue, scaffold_build_point_id: int, upstream_conf_id: int, upstream_residue: pyrosetta.rosetta.core.conformation.Residue) → pyrosetta.rosetta.std.list_protocols_match_Hit_t

Iterate across the conformations of the downstream residue coming from hits

generated in previous rounds, and add hits for each upstream residue that (Also, see comments for the build_at_all_positions method.)

C++: protocols::match::downstream::SecondaryMatcherToDownstreamResidue::build(const unsigned long, const unsigned long, const class core::conformation::Residue &) const –> class std::list<class protocols::match::Hit, class std::allocator<class protocols::match::Hit> >

build_hits_at_all_positions(self: pyrosetta.rosetta.protocols.match.downstream.SecondaryMatcherToDownstreamResidue, matcher: pyrosetta.rosetta.protocols.match.Matcher) → pyrosetta.rosetta.std.list_protocols_match_Hit_t

Main driver function for hit generation. This DownstreamAlgorithm

structures it’s iteration over the hits from previous rounds as follows: for i = 1:this->geom_cst_id() - 1

if ( ! matcher->representative_downstream_algorithm( i )->generates_primary_hits() ) continue; for j = 1:n_build_points_for_geomcst( i )

recover_downstream_coordinates_from_previous_round( hit_subset_j ); initialize TaretRotamerCoords data for all downstream algorithms with the same geom_cst_id #omp parallel for /// All class access below this point is const and parallelizable for k = 1:n_build_positions

/// call this function to start l loop: matcher.upstream_builder[ geom_cst_id() ]->build( k )

for l = 1:n_rotamers_k /// call to start m loop: downstream_algorithm->build( k, l, rotamer_l ) ) for m = 1:n_hits_in_block_j

if ( respair_evaluator_->evaluate_residues( rotamer_l, rotamer_m )

hit_list.append( Hit( k, l, i, 1, hit[ m ].second() ));

return hit_list

There are two important consequences to this hit-generation layout. 1. The coordinates for rotamer_l are computed sum( i, n_build_points_for_geomcst( i )) times. 2. The number of downstream target coordinates that live in memory at the same time is bound by some constant (10K). This is a clear trade-off between performance and memory NOTE: the most time consuming portion will likely be the m loop, and not the repeated construction of coordinates in the j loop. Reguardless of how many times we rebuild coordinates for rotamer j, the expense will primarily lie in the same place: the call to evaluate_residues( rotamer_l, rotamer_m ). NOTE: if there are ways to iterate across the j loop differently, it likely possible to prune m/l combinations early and thereby improve running time.

C++: protocols::match::downstream::SecondaryMatcherToDownstreamResidue::build_hits_at_all_positions(class protocols::match::Matcher &) –> class std::list<class protocols::match::Hit, class std::allocator<class protocols::match::Hit> >

clone(self: pyrosetta.rosetta.protocols.match.downstream.SecondaryMatcherToDownstreamResidue) → pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm

C++: protocols::match::downstream::SecondaryMatcherToDownstreamResidue::clone() const –> class std::shared_ptr<class protocols::match::downstream::DownstreamAlgorithm>

generates_primary_hits(self: pyrosetta.rosetta.protocols.match.downstream.SecondaryMatcherToDownstreamResidue) → bool

This method returns ‘false’ since this matcher does not describe

the coordinates of the downstream partner at all.

C++: protocols::match::downstream::SecondaryMatcherToDownstreamResidue::generates_primary_hits() const –> bool

geom_cst_id(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm) → int

C++: protocols::match::downstream::DownstreamAlgorithm::geom_cst_id() const –> unsigned long

get_dsbuilder(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm) → protocols::match::downstream::DownstreamBuilder

C++: protocols::match::downstream::DownstreamAlgorithm::get_dsbuilder() const –> class std::shared_ptr<class protocols::match::downstream::DownstreamBuilder>

hits_to_include_with_partial_match(self: pyrosetta.rosetta.protocols.match.downstream.SecondaryMatcherToDownstreamResidue, : pyrosetta.rosetta.protocols.match.match_dspos1) → numeric::kdtree::WrappedPrimitive<std::list<protocols::match::Hit const*, std::allocator<protocols::match::Hit const*> > >

C++: protocols::match::downstream::SecondaryMatcherToDownstreamResidue::hits_to_include_with_partial_match(const struct protocols::match::match_dspos1 &) const –> class std::shared_ptr<const class numeric::kdtree::WrappedPrimitive<class std::list<const class protocols::match::Hit *, class std::allocator<const class protocols::match::Hit *> > > >

n_possible_hits_per_upstream_conformation(self: pyrosetta.rosetta.protocols.match.downstream.SecondaryMatcherToDownstreamResidue) → int

C++: protocols::match::downstream::SecondaryMatcherToDownstreamResidue::n_possible_hits_per_upstream_conformation() const –> unsigned long

prepare_for_match_enumeration(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm, : pyrosetta.rosetta.protocols.match.Matcher) → None

Called at the conclusion of matching, the Matcher signals

to the downstream algorithm that it’s time to prepare for match generation; if the downstream algorithm needs to enumerate compatible hits in response to the invokation of its hits_to_include_with_partial_match method, then now is the time to prepare for those calls. Base class has a noop implementation.

C++: protocols::match::downstream::DownstreamAlgorithm::prepare_for_match_enumeration(const class protocols::match::Matcher &) –> void

respond_to_peripheral_hitlist_change(self: pyrosetta.rosetta.protocols.match.downstream.SecondaryMatcherToDownstreamResidue, matcher: pyrosetta.rosetta.protocols.match.Matcher) → None

Remove my hits if they fall into a volume of the occupied space hash

that is no longer occupied.

C++: protocols::match::downstream::SecondaryMatcherToDownstreamResidue::respond_to_peripheral_hitlist_change(class protocols::match::Matcher &) –> void

respond_to_primary_hitlist_change(self: pyrosetta.rosetta.protocols.match.downstream.SecondaryMatcherToDownstreamResidue, matcher: pyrosetta.rosetta.protocols.match.Matcher, round_just_completed: int) → None

mimic the classic matcher’s reset of the Occupied space hash.

C++: protocols::match::downstream::SecondaryMatcherToDownstreamResidue::respond_to_primary_hitlist_change(class protocols::match::Matcher &, unsigned long) –> void

set_active_site_grid(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm, active_site_grid: pyrosetta.rosetta.protocols.match.downstream.ActiveSiteGrid) → None

C++: protocols::match::downstream::DownstreamAlgorithm::set_active_site_grid(class std::shared_ptr<const class protocols::match::downstream::ActiveSiteGrid>) –> void

set_bb_grid(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm, bbgrid: pyrosetta.rosetta.protocols.match.BumpGrid) → None

C++: protocols::match::downstream::DownstreamAlgorithm::set_bb_grid(class std::shared_ptr<const class protocols::match::BumpGrid>) –> void

set_catalytic_atoms(self: pyrosetta.rosetta.protocols.match.downstream.SecondaryMatcherToDownstreamResidue, catalytic_atoms: pyrosetta.rosetta.utility.vector1_unsigned_long) → None

C++: protocols::match::downstream::SecondaryMatcherToDownstreamResidue::set_catalytic_atoms(class utility::vector1<unsigned long, class std::allocator<unsigned long> >) –> void

set_downstream_restype(self: pyrosetta.rosetta.protocols.match.downstream.SecondaryMatcherToDownstreamResidue, downstream_restype: pyrosetta.rosetta.core.chemical.ResidueType) → None

C++: protocols::match::downstream::SecondaryMatcherToDownstreamResidue::set_downstream_restype(class std::shared_ptr<const class core::chemical::ResidueType>) –> void

set_dsbuilder(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm, dsbuilder: protocols::match::downstream::DownstreamBuilder) → None

C++: protocols::match::downstream::DownstreamAlgorithm::set_dsbuilder(class std::shared_ptr<class protocols::match::downstream::DownstreamBuilder>) –> void

set_focused_geomcst_id(self: pyrosetta.rosetta.protocols.match.downstream.SecondaryMatcherToDownstreamResidue, focused_geomcst_id: int) → None

C++: protocols::match::downstream::SecondaryMatcherToDownstreamResidue::set_focused_geomcst_id(unsigned long) –> void

upstream_only(self: pyrosetta.rosetta.protocols.match.downstream.SecondaryMatcherToDownstreamResidue) → bool

returns false; this secondary matcher describes the location

of the downstream partner even though it does not generate that location itself. Matches may be found by hashing the 6D coordinate of the downstream partner.

C++: protocols::match::downstream::SecondaryMatcherToDownstreamResidue::upstream_only() const –> bool

class pyrosetta.rosetta.protocols.match.downstream.SecondaryMatcherToUpstreamResidue

Bases: DownstreamAlgorithm

A class for an algorithm. Given a conformation of the upstream partner, the algorithm is responsible for producing a set of hits.

add_evaluator_for_target_restype(self: pyrosetta.rosetta.protocols.match.downstream.SecondaryMatcherToUpstreamResidue, target_restype: pyrosetta.rosetta.core.chemical.ResidueType, evaluator: pyrosetta.rosetta.protocols.match.downstream.SecMatchResiduePairEvaluator, mcfi_id_for_evaluator: int) → None

C++: protocols::match::downstream::SecondaryMatcherToUpstreamResidue::add_evaluator_for_target_restype(class std::shared_ptr<const class core::chemical::ResidueType>, class std::shared_ptr<const class protocols::match::downstream::SecMatchResiduePairEvaluator>, unsigned long) –> void

add_target_restype(self: pyrosetta.rosetta.protocols.match.downstream.SecondaryMatcherToUpstreamResidue, target_restype: pyrosetta.rosetta.core.chemical.ResidueType) → None

C++: protocols::match::downstream::SecondaryMatcherToUpstreamResidue::add_target_restype(class std::shared_ptr<const class core::chemical::ResidueType>) –> void

are_colliding(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm, us_res: pyrosetta.rosetta.core.conformation.Residue, ds_res: pyrosetta.rosetta.core.conformation.Residue, ds_atoms: pyrosetta.rosetta.utility.vector1_core_id_AtomID, catalytic_atoms: pyrosetta.rosetta.utility.vector1_unsigned_long) → bool

C++: protocols::match::downstream::DownstreamAlgorithm::are_colliding(const class core::conformation::Residue &, const class core::conformation::Residue &, const class utility::vector1<class core::id::AtomID, class std::allocator<class core::id::AtomID> > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> bool

assign(self: pyrosetta.rosetta.protocols.match.downstream.SecondaryMatcherToUpstreamResidue, : pyrosetta.rosetta.protocols.match.downstream.SecondaryMatcherToUpstreamResidue) → pyrosetta.rosetta.protocols.match.downstream.SecondaryMatcherToUpstreamResidue

C++: protocols::match::downstream::SecondaryMatcherToUpstreamResidue::operator=(const class protocols::match::downstream::SecondaryMatcherToUpstreamResidue &) –> class protocols::match::downstream::SecondaryMatcherToUpstreamResidue &

build(self: pyrosetta.rosetta.protocols.match.downstream.SecondaryMatcherToUpstreamResidue, scaffold_build_point_id: int, upstream_conf_id: int, upstream_residue: pyrosetta.rosetta.core.conformation.Residue) → pyrosetta.rosetta.std.list_protocols_match_Hit_t

Iterate across the hits from a particular upstream build point i

that were generated in a previous round, and see if the geometry of the input upstream_residue has “satisfactory interactions” with the hits from upstream-build-point i; if so, it appends a Hit to the hitlist returned at the end of the method. (Also, see comments for the build_at_all_positions method.)

C++: protocols::match::downstream::SecondaryMatcherToUpstreamResidue::build(const unsigned long, const unsigned long, const class core::conformation::Residue &) const –> class std::list<class protocols::match::Hit, class std::allocator<class protocols::match::Hit> >

build_hits_at_all_positions(self: pyrosetta.rosetta.protocols.match.downstream.SecondaryMatcherToUpstreamResidue, matcher: pyrosetta.rosetta.protocols.match.Matcher) → pyrosetta.rosetta.std.list_protocols_match_Hit_t

Main driver function for hit generation. This DownstreamAlgorithm

structures it’s iteration over the hits from previous rounds as follows: for i = 1:n_build_positions

recover_rotamer_coordinates_from_previous_round( hits_for_build_point_i ); initialize rotcoord data for all downstream algorithms with the same geom_cst_id #omp parallel for /// All class access below this point is const and parallelizable for j = 1:n_build_positions

/// call this function to start k loop: matcher.upstream_builder[ geom_cst_id() ]->build( j ) for k = 1:n_rotamers_j

/// call to start l loop: downstream_algorithm->build( j, k, rotamer_k ) ) for l = 1:n_rotamers_from_build_point_i

if ( respair_evaluator_->evaluate_residues( rotamer_k, rotamer_l )

hit_list.append( Hit( j, k, … ));

return hit_list

There are two important consequences to this hit-generation layout. 1. The coordinates for rotamer_k are computed n_build_position times. 2. Only a single build-position i has it’s hit coordinates in memory at any point in time. This is a clear trade-off between performance and memory with a few caveats: A. It is very easy to bound the volume of space where build-point i’s rotamers lie, so it should be easy to prune rotamer building, so rotamer k will be build many fewer than n_build_position times. B. By not trying to store all rotamers in memory at once, we do not impose any undue restrictions on the number of rotamers that can be enumerated. This is especially important if we’re using backbone flexibility to search a wider region of conformation space.

C++: protocols::match::downstream::SecondaryMatcherToUpstreamResidue::build_hits_at_all_positions(class protocols::match::Matcher &) –> class std::list<class protocols::match::Hit, class std::allocator<class protocols::match::Hit> >

clone(self: pyrosetta.rosetta.protocols.match.downstream.SecondaryMatcherToUpstreamResidue) → pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm

C++: protocols::match::downstream::SecondaryMatcherToUpstreamResidue::clone() const –> class std::shared_ptr<class protocols::match::downstream::DownstreamAlgorithm>

generates_primary_hits(self: pyrosetta.rosetta.protocols.match.downstream.SecondaryMatcherToUpstreamResidue) → bool

This method returns ‘false’ since this matcher does not describe

the coordinates of the downstream partner at all.

C++: protocols::match::downstream::SecondaryMatcherToUpstreamResidue::generates_primary_hits() const –> bool

geom_cst_id(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm) → int

C++: protocols::match::downstream::DownstreamAlgorithm::geom_cst_id() const –> unsigned long

get_dsbuilder(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm) → protocols::match::downstream::DownstreamBuilder

C++: protocols::match::downstream::DownstreamAlgorithm::get_dsbuilder() const –> class std::shared_ptr<class protocols::match::downstream::DownstreamBuilder>

hits_to_include_with_partial_match(self: pyrosetta.rosetta.protocols.match.downstream.SecondaryMatcherToUpstreamResidue, m: pyrosetta.rosetta.protocols.match.match_dspos1) → numeric::kdtree::WrappedPrimitive<std::list<protocols::match::Hit const*, std::allocator<protocols::match::Hit const*> > >

Return the set of hits to be iterated across

C++: protocols::match::downstream::SecondaryMatcherToUpstreamResidue::hits_to_include_with_partial_match(const struct protocols::match::match_dspos1 &) const –> class std::shared_ptr<const class numeric::kdtree::WrappedPrimitive<class std::list<const class protocols::match::Hit *, class std::allocator<const class protocols::match::Hit *> > > >

n_possible_hits_per_upstream_conformation(self: pyrosetta.rosetta.protocols.match.downstream.SecondaryMatcherToUpstreamResidue) → int

C++: protocols::match::downstream::SecondaryMatcherToUpstreamResidue::n_possible_hits_per_upstream_conformation() const –> unsigned long

prepare_for_match_enumeration(self: pyrosetta.rosetta.protocols.match.downstream.SecondaryMatcherToUpstreamResidue, matcher: pyrosetta.rosetta.protocols.match.Matcher) → None

Prepare a map between upstream hits of the target-geomcst and

a list of Hit const *’s of this geom_cst_id(). This map will be used in the function hits_to_include_with_partial_match.

C++: protocols::match::downstream::SecondaryMatcherToUpstreamResidue::prepare_for_match_enumeration(const class protocols::match::Matcher &) –> void

process_hit(self: pyrosetta.rosetta.protocols.match.downstream.SecondaryMatcherToUpstreamResidue, hit: pyrosetta.rosetta.protocols.match.Hit, upstream_conformation: pyrosetta.rosetta.core.conformation.Residue) → None

Invoked by SecondaryMatchUpstreamResProcessor; avoids multiple inherritance,

while letting the SecondaryMatcherToUpstreamResidue

C++: protocols::match::downstream::SecondaryMatcherToUpstreamResidue::process_hit(const class protocols::match::Hit &, const class core::conformation::Residue &) –> void

respond_to_peripheral_hitlist_change(self: pyrosetta.rosetta.protocols.match.downstream.SecondaryMatcherToUpstreamResidue, matcher: pyrosetta.rosetta.protocols.match.Matcher) → None

Remove my hits if my target_geomcst’s hit list has been shortened. This

will not trigger a round of peripheral-hitlist-change responses.

C++: protocols::match::downstream::SecondaryMatcherToUpstreamResidue::respond_to_peripheral_hitlist_change(class protocols::match::Matcher &) –> void

respond_to_primary_hitlist_change(self: pyrosetta.rosetta.protocols.match.downstream.SecondaryMatcherToUpstreamResidue, matcher: pyrosetta.rosetta.protocols.match.Matcher, round_just_completed: int) → None

Prune hits away from the target_geomcst’s hit list following a change to the

hits for my geom_cst_id(). Pruning hits from the target_geomcst’s hit list will trigger a round of peripheral-hitlist-change responses.

C++: protocols::match::downstream::SecondaryMatcherToUpstreamResidue::respond_to_primary_hitlist_change(class protocols::match::Matcher &, unsigned long) –> void

set_active_site_grid(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm, active_site_grid: pyrosetta.rosetta.protocols.match.downstream.ActiveSiteGrid) → None

C++: protocols::match::downstream::DownstreamAlgorithm::set_active_site_grid(class std::shared_ptr<const class protocols::match::downstream::ActiveSiteGrid>) –> void

set_bb_grid(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm, bbgrid: pyrosetta.rosetta.protocols.match.BumpGrid) → None

C++: protocols::match::downstream::DownstreamAlgorithm::set_bb_grid(class std::shared_ptr<const class protocols::match::BumpGrid>) –> void

set_dsbuilder(self: pyrosetta.rosetta.protocols.match.downstream.DownstreamAlgorithm, dsbuilder: protocols::match::downstream::DownstreamBuilder) → None

C++: protocols::match::downstream::DownstreamAlgorithm::set_dsbuilder(class std::shared_ptr<class protocols::match::downstream::DownstreamBuilder>) –> void

set_target_geomcst_id(self: pyrosetta.rosetta.protocols.match.downstream.SecondaryMatcherToUpstreamResidue, target_geomcst_id: int) → None

C++: protocols::match::downstream::SecondaryMatcherToUpstreamResidue::set_target_geomcst_id(unsigned long) –> void

upstream_only(self: pyrosetta.rosetta.protocols.match.downstream.SecondaryMatcherToUpstreamResidue) → bool

returns true; this secondary matcher does not describe the location

of the downstream partner

C++: protocols::match::downstream::SecondaryMatcherToUpstreamResidue::upstream_only() const –> bool

class pyrosetta.rosetta.protocols.match.downstream.TargetRotamerCoords

Bases: pybind11_object

assign(self: pyrosetta.rosetta.protocols.match.downstream.TargetRotamerCoords, : pyrosetta.rosetta.protocols.match.downstream.TargetRotamerCoords) → pyrosetta.rosetta.protocols.match.downstream.TargetRotamerCoords

C++: protocols::match::downstream::TargetRotamerCoords::operator=(const class protocols::match::downstream::TargetRotamerCoords &) –> class protocols::match::downstream::TargetRotamerCoords &

coord(self: pyrosetta.rosetta.protocols.match.downstream.TargetRotamerCoords, restype_index: int, rotamer_index: int, which_atom: int) → pyrosetta.rosetta.numeric.xyzVector_double_t

C++: protocols::match::downstream::TargetRotamerCoords::coord(unsigned long, unsigned long, unsigned long) const –> const class numeric::xyzVector<double> &

get_clash_checking(self: pyrosetta.rosetta.protocols.match.downstream.TargetRotamerCoords, rotamer_index: int) → bool

C++: protocols::match::downstream::TargetRotamerCoords::get_clash_checking(unsigned long) –> bool

get_coords_for_clash_check(self: pyrosetta.rosetta.protocols.match.downstream.TargetRotamerCoords, rotamer_index: int) → pyrosetta.rosetta.utility.vector1_numeric_xyzVector_double_t

C++: protocols::match::downstream::TargetRotamerCoords::get_coords_for_clash_check(unsigned long) –> class utility::vector1<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > >

get_ds_atom_ids_needed(self: pyrosetta.rosetta.protocols.match.downstream.TargetRotamerCoords) → pyrosetta.rosetta.utility.vector1_core_id_AtomID

C++: protocols::match::downstream::TargetRotamerCoords::get_ds_atom_ids_needed() –> class utility::vector1<class core::id::AtomID, class std::allocator<class core::id::AtomID> >

hit(self: pyrosetta.rosetta.protocols.match.downstream.TargetRotamerCoords, restype_index: int, rotamer_index: int) → pyrosetta.rosetta.protocols.match.Hit

C++: protocols::match::downstream::TargetRotamerCoords::hit(unsigned long, unsigned long) const –> const class protocols::match::Hit &

n_atoms_for_restype(self: pyrosetta.rosetta.protocols.match.downstream.TargetRotamerCoords, restype_id: int) → int

C++: protocols::match::downstream::TargetRotamerCoords::n_atoms_for_restype(unsigned long) const –> unsigned long

n_restypes(self: pyrosetta.rosetta.protocols.match.downstream.TargetRotamerCoords) → int

C++: protocols::match::downstream::TargetRotamerCoords::n_restypes() const –> unsigned long

n_rotamers_for_restype(self: pyrosetta.rosetta.protocols.match.downstream.TargetRotamerCoords, restype_id: int) → int

C++: protocols::match::downstream::TargetRotamerCoords::n_rotamers_for_restype(unsigned long) const –> unsigned long

n_rots_total(self: pyrosetta.rosetta.protocols.match.downstream.TargetRotamerCoords) → int

C++: protocols::match::downstream::TargetRotamerCoords::n_rots_total() const –> unsigned long

restype(self: pyrosetta.rosetta.protocols.match.downstream.TargetRotamerCoords, restype_index: int) → pyrosetta.rosetta.core.chemical.ResidueType

C++: protocols::match::downstream::TargetRotamerCoords::restype(unsigned long) const –> class std::shared_ptr<const class core::chemical::ResidueType>

restype_atomno(self: pyrosetta.rosetta.protocols.match.downstream.TargetRotamerCoords, restype_index: int, which_atom: int) → int

C++: protocols::match::downstream::TargetRotamerCoords::restype_atomno(unsigned long, unsigned long) const –> unsigned long

set_clash_check_types(self: pyrosetta.rosetta.protocols.match.downstream.TargetRotamerCoords, n_rotamers: int) → None

C++: protocols::match::downstream::TargetRotamerCoords::set_clash_check_types(unsigned long) –> void

set_clash_checking(self: pyrosetta.rosetta.protocols.match.downstream.TargetRotamerCoords, rotamer_index: int) → None

C++: protocols::match::downstream::TargetRotamerCoords::set_clash_checking(unsigned long) –> void

set_coordinates_for_rotamer(self: pyrosetta.rosetta.protocols.match.downstream.TargetRotamerCoords, restype_index: int, rotamer_index: int, hit: pyrosetta.rosetta.protocols.match.Hit, rescoords: pyrosetta.rosetta.core.conformation.Residue) → None

C++: protocols::match::downstream::TargetRotamerCoords::set_coordinates_for_rotamer(unsigned long, unsigned long, const class protocols::match::Hit &, const class core::conformation::Residue &) –> void

set_coords_for_clash_check(self: pyrosetta.rosetta.protocols.match.downstream.TargetRotamerCoords, rotamer_index: int, coords: pyrosetta.rosetta.utility.vector1_numeric_xyzVector_double_t) → None

C++: protocols::match::downstream::TargetRotamerCoords::set_coords_for_clash_check(unsigned long, class utility::vector1<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &) –> void

set_ds_atom_ids_needed(self: pyrosetta.rosetta.protocols.match.downstream.TargetRotamerCoords, atom_ids: pyrosetta.rosetta.utility.vector1_core_id_AtomID) → None

C++: protocols::match::downstream::TargetRotamerCoords::set_ds_atom_ids_needed(class utility::vector1<class core::id::AtomID, class std::allocator<class core::id::AtomID> >) –> void

set_num_restypes(self: pyrosetta.rosetta.protocols.match.downstream.TargetRotamerCoords, n_restypes: int) → None

C++: protocols::match::downstream::TargetRotamerCoords::set_num_restypes(unsigned long) –> void

set_num_target_rotamers(*args, **kwargs)

Overloaded function.

1. set_num_target_rotamers(self: pyrosetta.rosetta.protocols.match.downstream.TargetRotamerCoords, n_rotamers_per_target_restype: pyrosetta.rosetta.utility.vector1_unsigned_long) -> None

C++: protocols::match::downstream::TargetRotamerCoords::set_num_target_rotamers(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> void

2. set_num_target_rotamers(self: pyrosetta.rosetta.protocols.match.downstream.TargetRotamerCoords, target_restype_id: int, n_rotamers: int) -> None

C++: protocols::match::downstream::TargetRotamerCoords::set_num_target_rotamers(unsigned long, unsigned long) –> void

set_required_atoms(self: pyrosetta.rosetta.protocols.match.downstream.TargetRotamerCoords, restype_index: int, atom_required: pyrosetta.rosetta.utility.vector1_bool) → None

C++: protocols::match::downstream::TargetRotamerCoords::set_required_atoms(unsigned long, const class utility::vector1<bool, class std::allocator<bool> > &) –> void

set_restype(self: pyrosetta.rosetta.protocols.match.downstream.TargetRotamerCoords, restype_index: int, restype: pyrosetta.rosetta.core.chemical.ResidueType) → None

C++: protocols::match::downstream::TargetRotamerCoords::set_restype(unsigned long, class std::shared_ptr<const class core::chemical::ResidueType>) –> void

class pyrosetta.rosetta.protocols.match.downstream.us_secmatch_hit_compare

Bases: pybind11_object

A simple struct to use in list.sort() to ensure that the hits returned by a secondary matcher which has possibly generated upstream hits out-of-order, will return an ordered-hit-list in its build_hits_at_all_positions() method.

This struct compares the upstream portion of the hits it’s returning ensuring that the rotamer indices (the upstream_conf_ids()) are in ascending order for each scaffold build point.