match

• downstream
• output
• upstream

Bindings for protocols::match namespace

class pyrosetta.rosetta.protocols.match.AddAllPositionsMPM

Bases: MatchPositionModifier

MPM that returns a vector of all protein positions in the pose i.e. allowing matching everywhere

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

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

modified_match_positions(self: pyrosetta.rosetta.protocols.match.AddAllPositionsMPM, original_positions: pyrosetta.rosetta.utility.vector1_unsigned_long, match_pose: pyrosetta.rosetta.core.pose.Pose, mtask: protocols::match::MatcherTask) → pyrosetta.rosetta.utility.vector1_unsigned_long

C++: protocols::match::AddAllPositionsMPM::modified_match_positions(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class core::pose::Pose &, class std::shared_ptr<const class protocols::match::MatcherTask>) const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

class pyrosetta.rosetta.protocols.match.BfactorMPM

Bases: MatchPositionModifier

removes positions at which the bfactors for c-alpha atoms are above a desired cutoff. bfactors stored in the pose pdbinfo are taken. if relative bfactors are used, all bfactors are divided by the largest observed bfactor

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

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

get_ca_bfactors(self: pyrosetta.rosetta.protocols.match.BfactorMPM, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.utility.vector1_double

C++: protocols::match::BfactorMPM::get_ca_bfactors(const class core::pose::Pose &) const –> class utility::vector1<double, class std::allocator<double> >

modified_match_positions(self: pyrosetta.rosetta.protocols.match.BfactorMPM, original_positions: pyrosetta.rosetta.utility.vector1_unsigned_long, match_pose: pyrosetta.rosetta.core.pose.Pose, mtask: protocols::match::MatcherTask) → pyrosetta.rosetta.utility.vector1_unsigned_long

C++: protocols::match::BfactorMPM::modified_match_positions(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class core::pose::Pose &, class std::shared_ptr<const class protocols::match::MatcherTask>) const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

class pyrosetta.rosetta.protocols.match.Bool3DGrid

Bases: pybind11_object

actual_bb(self: pyrosetta.rosetta.protocols.match.Bool3DGrid) → pyrosetta.rosetta.numeric.geometry.BoundingBox_numeric_xyzVector_double_t

C++: protocols::match::Bool3DGrid::actual_bb() const –> class numeric::geometry::BoundingBox<class numeric::xyzVector<double> >

and_with(self: pyrosetta.rosetta.protocols.match.Bool3DGrid, other: pyrosetta.rosetta.protocols.match.Bool3DGrid) → None

Performs a boolean AND on the voxels shared by the two grids,

and ignores all voxels that are not shared by the two grids. These grids must be “compatible”, in that the lower corner of other must lie on a grid point of this.

C++: protocols::match::Bool3DGrid::and_with(const class protocols::match::Bool3DGrid &) –> void

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

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

bin_center(self: pyrosetta.rosetta.protocols.match.Bool3DGrid, bin: pyrosetta.rosetta.utility.fixedsizearray1_unsigned_long_3_t) → pyrosetta.rosetta.numeric.xyzVector_double_t

C++: protocols::match::Bool3DGrid::bin_center(const class utility::fixedsizearray1<unsigned long, 3> &) const –> class numeric::xyzVector<double>

bin_extrema(self: pyrosetta.rosetta.protocols.match.Bool3DGrid, bin: pyrosetta.rosetta.utility.fixedsizearray1_unsigned_long_3_t) → pyrosetta.rosetta.numeric.geometry.BoundingBox_numeric_xyzVector_double_t

bounding box points for a bin.

C++: protocols::match::Bool3DGrid::bin_extrema(const class utility::fixedsizearray1<unsigned long, 3> &) const –> class numeric::geometry::BoundingBox<class numeric::xyzVector<double> >

bin_width(self: pyrosetta.rosetta.protocols.match.Bool3DGrid) → float

C++: protocols::match::Bool3DGrid::bin_width() const –> double

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

Set all values in all bins to false

C++: protocols::match::Bool3DGrid::clear() –> void

create_grid_for_bb(self: pyrosetta.rosetta.protocols.match.Bool3DGrid, bb: pyrosetta.rosetta.numeric.geometry.BoundingBox_numeric_xyzVector_double_t) → pyrosetta.rosetta.protocols.match.Bool3DGrid

create a grid for the input bounding box that aligns to this grid

C++: protocols::match::Bool3DGrid::create_grid_for_bb(const class numeric::geometry::BoundingBox<class numeric::xyzVector<double> > &) –> class protocols::match::Bool3DGrid

create_grid_for_sphere(self: pyrosetta.rosetta.protocols.match.Bool3DGrid, center: pyrosetta.rosetta.numeric.xyzVector_double_t, radius: float) → pyrosetta.rosetta.protocols.match.Bool3DGrid

create a grid for the input sphere that aligns to this grid,

such that it is large enough to hold a particular sphere.

C++: protocols::match::Bool3DGrid::create_grid_for_sphere(const class numeric::xyzVector<double> &, double) const –> class protocols::match::Bool3DGrid

dimsizes(self: pyrosetta.rosetta.protocols.match.Bool3DGrid) → pyrosetta.rosetta.utility.fixedsizearray1_unsigned_long_3_t

Accessors

C++: protocols::match::Bool3DGrid::dimsizes() const –> class utility::fixedsizearray1<unsigned long, 3>

occupied(*args, **kwargs)

Overloaded function.

1. occupied(self: pyrosetta.rosetta.protocols.match.Bool3DGrid, : pyrosetta.rosetta.numeric.xyzVector_double_t) -> bool

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

2. occupied(self: pyrosetta.rosetta.protocols.match.Bool3DGrid, bin: pyrosetta.rosetta.utility.fixedsizearray1_unsigned_long_3_t) -> bool

C++: protocols::match::Bool3DGrid::occupied(const class utility::fixedsizearray1<unsigned long, 3> &) const –> bool

or_by_box_liberal(self: pyrosetta.rosetta.protocols.match.Bool3DGrid, bb: pyrosetta.rosetta.numeric.geometry.BoundingBox_numeric_xyzVector_double_t) → None

/

Turn the values of all the bins that overlap with the volume in this bounding box to true.

C++: protocols::match::Bool3DGrid::or_by_box_liberal(const class numeric::geometry::BoundingBox<class numeric::xyzVector<double> > &) –> void

or_by_sphere_conservative(self: pyrosetta.rosetta.protocols.match.Bool3DGrid, center: pyrosetta.rosetta.numeric.xyzVector_double_t, radius: float) → None

Set the value to true for any voxel that is wholy contained

by the given sphere. A voxel is wholy contained iff all 8 corners of the voxel are within the sphere.

C++: protocols::match::Bool3DGrid::or_by_sphere_conservative(const class numeric::xyzVector<double> &, double) –> void

or_by_sphere_liberal(self: pyrosetta.rosetta.protocols.match.Bool3DGrid, center: pyrosetta.rosetta.numeric.xyzVector_double_t, radius: float) → None

Set the value to true for any voxel that is partially contained

by a given sphere. A voxel is partially contained iff any of the 8 corners of the voxel are within the sphere.

C++: protocols::match::Bool3DGrid::or_by_sphere_liberal(const class numeric::xyzVector<double> &, double) –> void

or_by_spheres_conservative(self: pyrosetta.rosetta.protocols.match.Bool3DGrid, spheres: pyrosetta.rosetta.utility.vector1_std_pair_numeric_xyzVector_double_double_t) → None

Consider a voxel filled if each of its corners are covered,

even if they are covered by seperate spheres. Dangerous, in that some voxels will be counted as being fully occupied when they are only partially occupied.

C++: protocols::match::Bool3DGrid::or_by_spheres_conservative(const class utility::vector1<struct std::pair<class numeric::xyzVector<double>, double>, class std::allocator<struct std::pair<class numeric::xyzVector<double>, double> > > &) –> void

or_with(self: pyrosetta.rosetta.protocols.match.Bool3DGrid, other: pyrosetta.rosetta.protocols.match.Bool3DGrid) → None

Performs a boolean OR on the voxels shared by the two grids,

and ignores all voxels that are not shared by the two grids. These grids must be “compatible”, in that the lower corner of other must lie on a grid point of this.

C++: protocols::match::Bool3DGrid::or_with(const class protocols::match::Bool3DGrid &) –> void

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

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

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

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

set_value_for_bin(self: pyrosetta.rosetta.protocols.match.Bool3DGrid, bin: pyrosetta.rosetta.utility.fixedsizearray1_unsigned_long_3_t, setting: bool) → None

set the boolean value for a particular bin.

The bin dimensions are indexed from 0 to nbins-1.

C++: protocols::match::Bool3DGrid::set_value_for_bin(const class utility::fixedsizearray1<unsigned long, 3> &, bool) –> void

subtract(self: pyrosetta.rosetta.protocols.match.Bool3DGrid, other: pyrosetta.rosetta.protocols.match.Bool3DGrid) → None

Sets any voxel on this grid to “false” which is true on the other grid.

but does not set any voxel to “true” on this grid – even if the other voxel is “false”.

C++: protocols::match::Bool3DGrid::subtract(const class protocols::match::Bool3DGrid &) –> void

class pyrosetta.rosetta.protocols.match.Bool3DGridKinemageWriter

Bases: pybind11_object

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

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

set_empty_voxel_color(self: pyrosetta.rosetta.protocols.match.Bool3DGridKinemageWriter, empty_voxel_color_: str) → None

C++: protocols::match::Bool3DGridKinemageWriter::set_empty_voxel_color(const std::string &) –> void

set_facet_alpha(self: pyrosetta.rosetta.protocols.match.Bool3DGridKinemageWriter, facet_alpha: float) → None

C++: protocols::match::Bool3DGridKinemageWriter::set_facet_alpha(double) –> void

set_facet_color(self: pyrosetta.rosetta.protocols.match.Bool3DGridKinemageWriter, facet_color: str) → None

C++: protocols::match::Bool3DGridKinemageWriter::set_facet_color(const std::string &) –> void

set_facet_master(self: pyrosetta.rosetta.protocols.match.Bool3DGridKinemageWriter, facet_master: str) → None

C++: protocols::match::Bool3DGridKinemageWriter::set_facet_master(const std::string &) –> void

set_line_color(self: pyrosetta.rosetta.protocols.match.Bool3DGridKinemageWriter, line_color: str) → None

C++: protocols::match::Bool3DGridKinemageWriter::set_line_color(const std::string &) –> void

set_master(self: pyrosetta.rosetta.protocols.match.Bool3DGridKinemageWriter, master: str) → None

C++: protocols::match::Bool3DGridKinemageWriter::set_master(const std::string &) –> void

set_shrink_factor(self: pyrosetta.rosetta.protocols.match.Bool3DGridKinemageWriter, shrink_factor: float) → None

C++: protocols::match::Bool3DGridKinemageWriter::set_shrink_factor(double) –> void

set_skip_completely_buried_positions(self: pyrosetta.rosetta.protocols.match.Bool3DGridKinemageWriter, skip_completely_buried_positions: bool) → None

C++: protocols::match::Bool3DGridKinemageWriter::set_skip_completely_buried_positions(bool) –> void

set_transparent_facets(self: pyrosetta.rosetta.protocols.match.Bool3DGridKinemageWriter, transparent_facets: bool) → None

C++: protocols::match::Bool3DGridKinemageWriter::set_transparent_facets(bool) –> void

set_unselectable(self: pyrosetta.rosetta.protocols.match.Bool3DGridKinemageWriter, unselectable: bool) → None

C++: protocols::match::Bool3DGridKinemageWriter::set_unselectable(bool) –> void

set_write_empty_voxels(self: pyrosetta.rosetta.protocols.match.Bool3DGridKinemageWriter, write_empty_voxels_: bool) → None

C++: protocols::match::Bool3DGridKinemageWriter::set_write_empty_voxels(bool) –> void

set_write_facets(self: pyrosetta.rosetta.protocols.match.Bool3DGridKinemageWriter, write_facets: bool) → None

C++: protocols::match::Bool3DGridKinemageWriter::set_write_facets(bool) –> void

write_grid_to_file(self: pyrosetta.rosetta.protocols.match.Bool3DGridKinemageWriter, fname: str, group_name: str, grid: pyrosetta.rosetta.protocols.match.Bool3DGrid) → None

C++: protocols::match::Bool3DGridKinemageWriter::write_grid_to_file(const std::string &, const std::string &, const class protocols::match::Bool3DGrid &) const –> void

write_grid_to_kinemage(self: pyrosetta.rosetta.protocols.match.Bool3DGridKinemageWriter, ostr: pyrosetta.rosetta.std.ostream, group_name: str, grid: pyrosetta.rosetta.protocols.match.Bool3DGrid) → None

C++: protocols::match::Bool3DGridKinemageWriter::write_grid_to_kinemage(std::ostream &, const std::string &, const class protocols::match::Bool3DGrid &) const –> void

class pyrosetta.rosetta.protocols.match.BumpGrid

Bases: pybind11_object

and_with(self: pyrosetta.rosetta.protocols.match.BumpGrid, : pyrosetta.rosetta.protocols.match.BumpGrid) → None

C++: protocols::match::BumpGrid::and_with(const class protocols::match::BumpGrid &) –> void

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

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

create_bump_grid_for_bb(self: pyrosetta.rosetta.protocols.match.BumpGrid, bb: pyrosetta.rosetta.numeric.geometry.BoundingBox_numeric_xyzVector_double_t) → pyrosetta.rosetta.protocols.match.BumpGrid

C++: protocols::match::BumpGrid::create_bump_grid_for_bb(const class numeric::geometry::BoundingBox<class numeric::xyzVector<double> > &) const –> class protocols::match::BumpGrid

create_new_bump_grid_for_bb(self: pyrosetta.rosetta.protocols.match.BumpGrid, bb: pyrosetta.rosetta.numeric.geometry.BoundingBox_numeric_xyzVector_double_t) → pyrosetta.rosetta.protocols.match.BumpGrid

C++: protocols::match::BumpGrid::create_new_bump_grid_for_bb(const class numeric::geometry::BoundingBox<class numeric::xyzVector<double> > &) const –> class std::shared_ptr<class protocols::match::BumpGrid>

grid(self: pyrosetta.rosetta.protocols.match.BumpGrid, radtype: pyrosetta.rosetta.protocols.match.ProbeRadius) → pyrosetta.rosetta.protocols.match.Bool3DGrid

C++: protocols::match::BumpGrid::grid(enum protocols::match::ProbeRadius) const –> const class protocols::match::Bool3DGrid &

occupied(self: pyrosetta.rosetta.protocols.match.BumpGrid, radius_type: pyrosetta.rosetta.protocols.match.ProbeRadius, p: pyrosetta.rosetta.numeric.xyzVector_double_t) → bool

Collision detection by a point p with a given (fixed) radius type.

Collision detection is performed in “configuration space”, where the obstacles have been convolved with a spherical probe of a given radius. This collision detection is conservative: it will not report a collision to exist that does not, but may miss a collision that does exist.

C++: protocols::match::BumpGrid::occupied(enum protocols::match::ProbeRadius, const class numeric::xyzVector<double> &) const –> bool

or_by_sphere(*args, **kwargs)

Overloaded function.

1. or_by_sphere(self: pyrosetta.rosetta.protocols.match.BumpGrid, : Tuple[pyrosetta.rosetta.numeric.xyzVector_double_t, float]) -> None

C++: protocols::match::BumpGrid::or_by_sphere(const struct std::pair<class numeric::xyzVector<double>, double> &) –> void

2. or_by_sphere(self: pyrosetta.rosetta.protocols.match.BumpGrid, center: pyrosetta.rosetta.numeric.xyzVector_double_t, radius_type: pyrosetta.rosetta.protocols.match.ProbeRadius) -> None

C++: protocols::match::BumpGrid::or_by_sphere(const class numeric::xyzVector<double> &, enum protocols::match::ProbeRadius) –> void

or_with(self: pyrosetta.rosetta.protocols.match.BumpGrid, : pyrosetta.rosetta.protocols.match.BumpGrid) → None

C++: protocols::match::BumpGrid::or_with(const class protocols::match::BumpGrid &) –> void

overlaps(self: pyrosetta.rosetta.protocols.match.BumpGrid, : pyrosetta.rosetta.protocols.match.BumpGrid) → bool

C++: protocols::match::BumpGrid::overlaps(const class protocols::match::BumpGrid &) const –> bool

pair_overlap_tolerance(self: pyrosetta.rosetta.protocols.match.BumpGrid, rad1: pyrosetta.rosetta.protocols.match.ProbeRadius, rad2: pyrosetta.rosetta.protocols.match.ProbeRadius) → float

C++: protocols::match::BumpGrid::pair_overlap_tolerance(enum protocols::match::ProbeRadius, enum protocols::match::ProbeRadius) const –> double

static probe_radius(radtype: pyrosetta.rosetta.protocols.match.ProbeRadius) → float

C++: protocols::match::BumpGrid::probe_radius(enum protocols::match::ProbeRadius) –> double

required_separation_distance(self: pyrosetta.rosetta.protocols.match.BumpGrid, rad1: pyrosetta.rosetta.protocols.match.ProbeRadius, rad2: pyrosetta.rosetta.protocols.match.ProbeRadius) → float

C++: protocols::match::BumpGrid::required_separation_distance(enum protocols::match::ProbeRadius, enum protocols::match::ProbeRadius) const –> double

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

Initialization

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

set_general_overlap_tolerance(self: pyrosetta.rosetta.protocols.match.BumpGrid, tolerated_overlap: float) → None

/

Set the tolerance for sphere overlap between all sphere types. All tolerances must be set before any spheres are ORed into the grid.

C++: protocols::match::BumpGrid::set_general_overlap_tolerance(double) –> void

set_pair_overlap_tolerance(self: pyrosetta.rosetta.protocols.match.BumpGrid, rad1: pyrosetta.rosetta.protocols.match.ProbeRadius, rad2: pyrosetta.rosetta.protocols.match.ProbeRadius, tolerated_overlap: float) → None

/

Set the overlap tolerance for a specific pair of sphere types (e.g. OXY/NIT) The specific tolerance is combined with the general overlap tolerance. All tolerances must be set before any spheres are ORed into the grid.

C++: protocols::match::BumpGrid::set_pair_overlap_tolerance(enum protocols::match::ProbeRadius, enum protocols::match::ProbeRadius, double) –> void

class pyrosetta.rosetta.protocols.match.Hit

Bases: pybind11_object

downstream_conf_id(self: pyrosetta.rosetta.protocols.match.Hit) → int

C++: protocols::match::Hit::downstream_conf_id() const –> unsigned long

external_geom_id(self: pyrosetta.rosetta.protocols.match.Hit) → int

C++: protocols::match::Hit::external_geom_id() const –> unsigned long

first(self: pyrosetta.rosetta.protocols.match.Hit) → pyrosetta.rosetta.utility.fixedsizearray1_unsigned_long_4_t

C++: protocols::match::Hit::first() –> class utility::fixedsizearray1<unsigned long, 4> &

scaffold_build_id(self: pyrosetta.rosetta.protocols.match.Hit) → int

C++: protocols::match::Hit::scaffold_build_id() const –> unsigned long

second(self: pyrosetta.rosetta.protocols.match.Hit) → pyrosetta.rosetta.utility.fixedsizearray1_double_6_t

C++: protocols::match::Hit::second() –> class utility::fixedsizearray1<double, 6> &

upstream_conf_id(self: pyrosetta.rosetta.protocols.match.Hit) → int

C++: protocols::match::Hit::upstream_conf_id() const –> unsigned long

class pyrosetta.rosetta.protocols.match.HitHasher

Bases: pybind11_object

This object hashes hits into 6D voxels. This hash can then be traversed to retrieve the hits that hash to the same voxel (matches!). There are 64 hashes representing the 2^6 ways to perturb the bins in 6D by 1/2 of their bin width.

The hit hasher expects someone else to own the hits. It takes as input constant pointers to the hits that exist and uses their addresses to hash upon. The hit hasher should only be used if you can guarantee that the hits it points to will outlive the hasher.

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

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

binner(self: pyrosetta.rosetta.protocols.match.HitHasher, which_hash_map: int) → pyrosetta.rosetta.numeric.geometry.hashing.SixDCoordinateBinner

C++: protocols::match::HitHasher::binner(unsigned long) const –> const class numeric::geometry::hashing::SixDCoordinateBinner &

clear_hash_map(self: pyrosetta.rosetta.protocols.match.HitHasher, which_hash_map: int) → None

C++: protocols::match::HitHasher::clear_hash_map(unsigned long) –> void

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

C++: protocols::match::HitHasher::initialize() –> void

insert_hit(*args, **kwargs)

Overloaded function.

1. insert_hit(self: pyrosetta.rosetta.protocols.match.HitHasher, geometric_constraint_id: int, hit: pyrosetta.rosetta.protocols.match.Hit) -> None

Insert a hits into all 64 hash maps

C++: protocols::match::HitHasher::insert_hit(unsigned long, const class protocols::match::Hit *) –> void

2. insert_hit(self: pyrosetta.rosetta.protocols.match.HitHasher, which_hash_map: int, geometric_constraint_id: int, hit: pyrosetta.rosetta.protocols.match.Hit) -> None

Insert a hits into a particular hash maps

C++: protocols::match::HitHasher::insert_hit(unsigned long, unsigned long, const class protocols::match::Hit *) –> void

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

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

set_euler_bin_widths(self: pyrosetta.rosetta.protocols.match.HitHasher, euler_bin_widths: pyrosetta.rosetta.numeric.xyzVector_double_t) → None

C++: protocols::match::HitHasher::set_euler_bin_widths(const class numeric::xyzVector<double> &) –> void

set_nhits_per_match(self: pyrosetta.rosetta.protocols.match.HitHasher, num_geometric_constraints: int) → None

C++: protocols::match::HitHasher::set_nhits_per_match(unsigned long) –> void

set_uniform_euler_angle_bin_width(self: pyrosetta.rosetta.protocols.match.HitHasher, bin_width_degrees: float) → None

C++: protocols::match::HitHasher::set_uniform_euler_angle_bin_width(double) –> void

set_uniform_xyz_bin_width(self: pyrosetta.rosetta.protocols.match.HitHasher, bin_width: float) → None

C++: protocols::match::HitHasher::set_uniform_xyz_bin_width(double) –> void

set_xyz_bin_widths(self: pyrosetta.rosetta.protocols.match.HitHasher, bin_widths: pyrosetta.rosetta.numeric.xyzVector_double_t) → None

C++: protocols::match::HitHasher::set_xyz_bin_widths(const class numeric::xyzVector<double> &) –> void

class pyrosetta.rosetta.protocols.match.HitNeighborFinder

Bases: pybind11_object

Class for finding hit neighbors in 6D considering all 64 origin definitions (but without forming all 64 hashes).

add_hits(*args, **kwargs)

Overloaded function.

1. add_hits(self: pyrosetta.rosetta.protocols.match.HitNeighborFinder, hitlist: pyrosetta.rosetta.std.list_protocols_match_Hit_t) -> None

Add all hits (using hit pointers!) from one list of hits

C++: protocols::match::HitNeighborFinder::add_hits(const class std::list<class protocols::match::Hit, class std::allocator<class protocols::match::Hit> > &) –> void

2. add_hits(self: pyrosetta.rosetta.protocols.match.HitNeighborFinder, hitptrlist: pyrosetta.rosetta.std.list_const_protocols_match_Hit__star__t) -> None

Add hit pointers from the input list

C++: protocols::match::HitNeighborFinder::add_hits(const class std::list<const class protocols::match::Hit *, class std::allocator<const class protocols::match::Hit *> > &) –> void

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

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

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

Call this after the bounding-box and the bin-widths have been set up. Must

be called before “add_hits” it called. This initializes the SixDCoordinateBinner.

C++: protocols::match::HitNeighborFinder::initialize() –> void

neighbor_hits(self: pyrosetta.rosetta.protocols.match.HitNeighborFinder, queryhits: pyrosetta.rosetta.std.list_const_protocols_match_Hit__star__t) → pyrosetta.rosetta.std.list_const_protocols_match_Hit__star__t

Find the neighbors of the given set of query hits. This search iterates

across both the upper and the lower neighbors of the query hits (3^6 neighbors).

C++: protocols::match::HitNeighborFinder::neighbor_hits(const class std::list<const class protocols::match::Hit *, class std::allocator<const class protocols::match::Hit *> > &) const –> class std::list<const class protocols::match::Hit *, class std::allocator<const class protocols::match::Hit *> >

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

Use the same bounding box as the HitHasher / OccupiedSpaceHash

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

set_euler_bin_widths(self: pyrosetta.rosetta.protocols.match.HitNeighborFinder, euler_bin_widths: pyrosetta.rosetta.numeric.xyzVector_double_t) → None

Give the same euler-angle bin witdhs given to the HitHasher / OccupiedSpaceHash.

C++: protocols::match::HitNeighborFinder::set_euler_bin_widths(const class numeric::xyzVector<double> &) –> void

set_uniform_euler_angle_bin_width(self: pyrosetta.rosetta.protocols.match.HitNeighborFinder, bin_width_degrees: float) → None

Give the same euler-angle bin witdh given to the HitHasher / OccupiedSpaceHash.

C++: protocols::match::HitNeighborFinder::set_uniform_euler_angle_bin_width(double) –> void

set_uniform_xyz_bin_width(self: pyrosetta.rosetta.protocols.match.HitNeighborFinder, bin_width: float) → None

Give the same xyz bin witdh given to the HitHasher / OccupiedSpaceHash.

C++: protocols::match::HitNeighborFinder::set_uniform_xyz_bin_width(double) –> void

set_xyz_bin_widths(self: pyrosetta.rosetta.protocols.match.HitNeighborFinder, bin_widths: pyrosetta.rosetta.numeric.xyzVector_double_t) → None

Give the same xyz bin witdhs given to the HitHasher / OccupiedSpaceHash.

C++: protocols::match::HitNeighborFinder::set_xyz_bin_widths(const class numeric::xyzVector<double> &) –> void

class pyrosetta.rosetta.protocols.match.MatchCounter

Bases: pybind11_object

Class for counting the number of matches given a particular discretization level.

add_hits(*args, **kwargs)

Overloaded function.

1. add_hits(self: pyrosetta.rosetta.protocols.match.MatchCounter, geomcst_id: int, hitlist: pyrosetta.rosetta.std.list_protocols_match_Hit_t) -> None

Add hits from a list of hits for a particular geometric constraint.

C++: protocols::match::MatchCounter::add_hits(unsigned long, const class std::list<class protocols::match::Hit, class std::allocator<class protocols::match::Hit> > &) –> void

2. add_hits(self: pyrosetta.rosetta.protocols.match.MatchCounter, geomcst_id: int, hitptrlist: pyrosetta.rosetta.std.list_const_protocols_match_Hit__star__t) -> None

Add hit from the input list of hits for a particular geometric constraint.

C++: protocols::match::MatchCounter::add_hits(unsigned long, const class std::list<const class protocols::match::Hit *, class std::allocator<const class protocols::match::Hit *> > &) –> void

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

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

count_n_matches(self: pyrosetta.rosetta.protocols.match.MatchCounter) → int

Possibly slow method to predict the total number of matches given a set of

hits and a particular grid resolution. (The main function that this class provides).

C++: protocols::match::MatchCounter::count_n_matches() const –> unsigned long

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

Call this after the bounding-box and the bin-widths have been set up. Must

be called before “add_hits” it called. This initializes the SixDCoordinateBinner.

C++: protocols::match::MatchCounter::initialize() –> void

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

Use the same bounding box as the HitHasher / OccupiedSpaceHash

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

set_euler_bin_widths(self: pyrosetta.rosetta.protocols.match.MatchCounter, euler_bin_widths: pyrosetta.rosetta.numeric.xyzVector_double_t) → None

Give the same euler-angle bin witdhs given to the HitHasher / OccupiedSpaceHash.

C++: protocols::match::MatchCounter::set_euler_bin_widths(const class numeric::xyzVector<double> &) –> void

set_n_geometric_constraints(self: pyrosetta.rosetta.protocols.match.MatchCounter, ngeomcsts: int) → None

C++: protocols::match::MatchCounter::set_n_geometric_constraints(unsigned long) –> void

set_uniform_euler_angle_bin_width(self: pyrosetta.rosetta.protocols.match.MatchCounter, bin_width_degrees: float) → None

Give the same euler-angle bin witdh given to the HitHasher / OccupiedSpaceHash.

C++: protocols::match::MatchCounter::set_uniform_euler_angle_bin_width(double) –> void

set_uniform_xyz_bin_width(self: pyrosetta.rosetta.protocols.match.MatchCounter, bin_width: float) → None

Give the same xyz bin witdh given to the HitHasher / OccupiedSpaceHash.

C++: protocols::match::MatchCounter::set_uniform_xyz_bin_width(double) –> void

set_xyz_bin_widths(self: pyrosetta.rosetta.protocols.match.MatchCounter, bin_widths: pyrosetta.rosetta.numeric.xyzVector_double_t) → None

Give the same xyz bin witdhs given to the HitHasher / OccupiedSpaceHash.

C++: protocols::match::MatchCounter::set_xyz_bin_widths(const class numeric::xyzVector<double> &) –> void

class pyrosetta.rosetta.protocols.match.MatchOutputTracker

Bases: pybind11_object

match_has_been_output(self: pyrosetta.rosetta.protocols.match.MatchOutputTracker, m: pyrosetta.rosetta.utility.vector1_const_protocols_match_Hit_*) → bool

C++: protocols::match::MatchOutputTracker::match_has_been_output(const class utility::vector1<const class protocols::match::Hit *, class std::allocator<const class protocols::match::Hit *> > &) const –> bool

note_output_match(self: pyrosetta.rosetta.protocols.match.MatchOutputTracker, : pyrosetta.rosetta.utility.vector1_const_protocols_match_Hit_*) → None

C++: protocols::match::MatchOutputTracker::note_output_match(const class utility::vector1<const class protocols::match::Hit *, class std::allocator<const class protocols::match::Hit *> > &) –> void

class pyrosetta.rosetta.protocols.match.MatchPositionModifier

Bases: pybind11_object

base class for objects that modify the match positions based on some criterion

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

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

modified_match_positions(self: pyrosetta.rosetta.protocols.match.MatchPositionModifier, original_positions: pyrosetta.rosetta.utility.vector1_unsigned_long, match_pose: pyrosetta.rosetta.core.pose.Pose, mtask: protocols::match::MatcherTask) → pyrosetta.rosetta.utility.vector1_unsigned_long

the positions in the vector1< core::Size > that is returned

by this function will replace the match positions in the MatcherTask.

C++: protocols::match::MatchPositionModifier::modified_match_positions(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class core::pose::Pose &, class std::shared_ptr<const class protocols::match::MatcherTask>) const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

class pyrosetta.rosetta.protocols.match.Matcher

Bases: pybind11_object

Overview: The matcher algorithm was originally concieved of within the domain of enzyme design. The transition state for the desired reqction is contacted by several amino acids each with a particular geometry. The goal of the matcher is to find a set of backbone positions on a given protein-backbone scaffold where those amino acids could be grafted such that they would contact the ligand in the desired geometry.

Consider a case where the transition state is contacted by an asparagine, an aspartate and a histadine. The user designing an enzyme for this transition state knows the geometry that describes the orientation of the transition state with respect to each of these side chains; what they do not know is into what protein and at what positions they should introduce these amino acids. The user will give the matcher a description of the geometry between the amind acids and the transition state. This geometry is in the form of 6 parameters: 3 diherals, 2 angles, and 1 distance (more on these later). Given the coordinates of a particular side chain and the geometry describing the transition state relative to the side chain, the coordinates of the transition state may be computed. In a sense, the transition state may be grown off of the end of a side chain in the desired geoemtry.

(Usually, the user will specify many different possible values for each of the 6 parameters, and the matcher will then consider all combinations of those values. E.g. the ideal distance might be 2.0 A, but the user might ask the matcher to consider the values 1.95 and 2.05 A additionally. Each assignment of values to these 6 parameters fully specifies the coordinates of the transition state.)

The matcher examines each geometric constraint one at a time. It builds rotamers for one or more amino acids capable of satisfying a desired geometry (e.g. both ASP and GLU if an acid group is needed) at each of several active-site positions, and for each rotamer, it grows the transition state. The matcher does a quick collision check between the atoms of the transition state and the backbone of the protein, rejecting transition-state conformations that collide. If the conformation is collision-free, then the matcher measures the coordinates of the transition state as a point in a 6-dimensional space. (It is no coincidence that there are 6 geometric parameters and that there are 6 dimensions in the space describing the transition state’s coordinates). With this 6-dimensional coordinate, the matcher can recover the coordinates for the transition state – the 6-D coordinate and the full euclidean coordinates of the transition state are interconvertable. The matcher can also bin the coordinate. If two coordinates in 6-D are close, they will be assigned to the same bin. This is the fundamental insight of the matching algorithm: the matcher will grow the transition state from different catalytic residues, and when the 6-d coordinates from different catalytic residues are assigned to the same bin, then the matcher has found a set of conformations of the transition state that are compatible with more than one catalytic geometry.

Each collision-free placement of the transition state is called a “hit”. If there are N geometric-constrains that the matcher is asked to satisfy, then a set of N hits, one per constraint, that fall into the same bin are called a “match”.

In the general case, the Matcher builds hits for each of several geometric constraints. The protein scaffold in the enzyme-design example generalizes to any macro-molecular polymer scaffold. The protein rotamers in the enzyme-design example generalizes to a set of conformations for the “upstream” partner. The transition state gene in the enzyme-design example generalizes to a “downstream” partner, which itself may have multiple conformations. “Upstream” and “Downstream” refer to the order in which the coordinates of the two partners are computed. The upstream coordinates are built first, the downstream coordinates second. Changes to the coordinates of the upstream partner propagate to the coordinates of the downstream partner. In the enzyme-design example, the transition state is considered to be rigid; in the general case the transition state may have multiple conformations. The downstream partner could also be an entire protein – and may have it’s own set of rotameric states. E.G. one might want to match a hydrogen-bond donor on the scaffold to a serine side-chain on the target (downstream) protein. The downstream partner should then be able to examine many serine rotamers for each conformation of the upstream rotamer.

A hit is represented in two parts: a discrete part and a continuous part. The discrete portion consists of four integers: 1. the build-point index on the scaffold, 2. the rotamer index on the upstream partner, 3. the external-geometry index, and 4. the rotamer index on the downstream partner. The continuous portion consists of 6 double-precision values representing the coordinate of the downstream partner in 6D. The first three values are the x,y and z coordinates of a particular atom in the downstream partner. The second three values are the phi, psi, and theta values describing the coordinate frame at this atom. These three “Euler angle” parameters describe three rotations: Z(psi) * X(theta) * Z(phi) * I. They are described in greater detail in src/numeric/HomogeneousTransform.hh. “Phi” and “psi” here have nothing to do with the protein-backbone angles. When a hit is binned, there are two sets of parameters that describe how wide the bins in each dimension should be: the Euclidean bin widths are for the xyz coordinates, and the Euler bin widths are for the Euler angles. The Euclidean bin widths are in Angstroms and the Euler bin widths are in degrees.

A Matcher object should be initialized from a MatcherTask object through the intialize_from_task() method. A MatcherTask will contain an EnzConstraintIO object, and the function Matcher::initialize_from_file() will be invoked as the Matcher is intialied from a MatcherTask. The documentation for Matcher::inialize_from_file() describes the format of extra data that may be included in the enzyme-design constraint file. This data should live within a ALGORITHM_INFO:: match … ALGORITHM::END block inside a CST::BEGIN … CST::END block in the constraint file.

find_hits() is the main worker function. After the matcher finishes find_hits(), the matches can be read by a MatchProcessor in a call to process_matches.

add_external_geometry_samples_for_constraint(*args, **kwargs)

Overloaded function.

1. add_external_geometry_samples_for_constraint(self: pyrosetta.rosetta.protocols.match.Matcher, cst_id: int, restype: pyrosetta.rosetta.core.chemical.ResidueType, upstream_launch_atoms: pyrosetta.rosetta.utility.vector1_std_string, downstream_3atoms: pyrosetta.rosetta.utility.vector1_core_id_AtomID, exgeom_list: pyrosetta.rosetta.utility.vector1_protocols_toolbox_match_enzdes_util_ExternalGeomSampler, exgeom_id: int) -> None

2. add_external_geometry_samples_for_constraint(self: pyrosetta.rosetta.protocols.match.Matcher, cst_id: int, restype: pyrosetta.rosetta.core.chemical.ResidueType, upstream_launch_atoms: pyrosetta.rosetta.utility.vector1_std_string, downstream_3atoms: pyrosetta.rosetta.utility.vector1_core_id_AtomID, exgeom_list: pyrosetta.rosetta.utility.vector1_protocols_toolbox_match_enzdes_util_ExternalGeomSampler, exgeom_id: int, enumerate_ligand_rotamers: bool) -> None

3. add_external_geometry_samples_for_constraint(self: pyrosetta.rosetta.protocols.match.Matcher, cst_id: int, restype: pyrosetta.rosetta.core.chemical.ResidueType, upstream_launch_atoms: pyrosetta.rosetta.utility.vector1_std_string, downstream_3atoms: pyrosetta.rosetta.utility.vector1_core_id_AtomID, exgeom_list: pyrosetta.rosetta.utility.vector1_protocols_toolbox_match_enzdes_util_ExternalGeomSampler, exgeom_id: int, enumerate_ligand_rotamers: bool, catalytic_bond: bool) -> None

4. add_external_geometry_samples_for_constraint(self: pyrosetta.rosetta.protocols.match.Matcher, cst_id: int, restype: pyrosetta.rosetta.core.chemical.ResidueType, upstream_launch_atoms: pyrosetta.rosetta.utility.vector1_std_string, downstream_3atoms: pyrosetta.rosetta.utility.vector1_core_id_AtomID, exgeom_list: pyrosetta.rosetta.utility.vector1_protocols_toolbox_match_enzdes_util_ExternalGeomSampler, exgeom_id: int, enumerate_ligand_rotamers: bool, catalytic_bond: bool, build_round1_hits_twice: bool) -> None

C++: protocols::match::Matcher::add_external_geometry_samples_for_constraint(unsigned long, class std::shared_ptr<const class core::chemical::ResidueType>, const class utility::vector1<std::string, class std::allocator<std::string > > &, const class utility::vector1<class core::id::AtomID, class std::allocator<class core::id::AtomID> > &, const class utility::vector1<class protocols::toolbox::match_enzdes_util::ExternalGeomSampler, class std::allocator<class protocols::toolbox::match_enzdes_util::ExternalGeomSampler> > &, const unsigned long, bool, bool, bool) –> void

add_secondary_downstream_match_geometry_for_constraint(self: pyrosetta.rosetta.protocols.match.Matcher, geom_cst_id: int, candidate_restype: pyrosetta.rosetta.core.chemical.ResidueType, downstream_restype: pyrosetta.rosetta.core.chemical.ResidueType, candidate_atids: pyrosetta.rosetta.utility.vector1_unsigned_long, target_atids: pyrosetta.rosetta.utility.vector1_unsigned_long, mcfi: protocols::toolbox::match_enzdes_util::MatchConstraintFileInfo, SecMatchStr: str, upstream_pose: pyrosetta.rosetta.core.pose.Pose, catalytic_bond: bool) → None

C++: protocols::match::Matcher::add_secondary_downstream_match_geometry_for_constraint(unsigned long, class std::shared_ptr<const class core::chemical::ResidueType>, class std::shared_ptr<const class core::chemical::ResidueType>, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, class std::shared_ptr<const class protocols::toolbox::match_enzdes_util::MatchConstraintFileInfo>, std::string, const class core::pose::Pose &, bool) –> void

add_secondary_upstream_match_geometry_for_constraint(self: pyrosetta.rosetta.protocols.match.Matcher, geom_cst_id: int, target_geom_cst_id: int, candidate_restype: pyrosetta.rosetta.core.chemical.ResidueType, target_restype: pyrosetta.rosetta.core.chemical.ResidueType, candidate_atids: pyrosetta.rosetta.utility.vector1_unsigned_long, target_atids: pyrosetta.rosetta.utility.vector1_unsigned_long, mcfi: protocols::toolbox::match_enzdes_util::MatchConstraintFileInfo, SecMatchStr: str, upstream_pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::match::Matcher::add_secondary_upstream_match_geometry_for_constraint(unsigned long, unsigned long, class std::shared_ptr<const class core::chemical::ResidueType>, class std::shared_ptr<const class core::chemical::ResidueType>, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, class std::shared_ptr<const class protocols::toolbox::match_enzdes_util::MatchConstraintFileInfo>, std::string, const class core::pose::Pose &) –> void

add_upstream_restype_for_constraint(self: pyrosetta.rosetta.protocols.match.Matcher, cst_id: int, restype: pyrosetta.rosetta.core.chemical.ResidueType) → None

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

build_point(self: pyrosetta.rosetta.protocols.match.Matcher, index: int) → protocols::match::upstream::ScaffoldBuildPoint

Non-const access

C++: protocols::match::Matcher::build_point(unsigned long) –> class std::shared_ptr<class protocols::match::upstream::ScaffoldBuildPoint>

desymmeterize_upstream_restype_for_constraint(self: pyrosetta.rosetta.protocols.match.Matcher, cst_id: int) → None

C++: protocols::match::Matcher::desymmeterize_upstream_restype_for_constraint(unsigned long) –> void

downstream_builder(self: pyrosetta.rosetta.protocols.match.Matcher, : int) → protocols::match::downstream::DownstreamBuilder

Return non-const access to a representative downstream builder

for a particular geometric constraint

C++: protocols::match::Matcher::downstream_builder(unsigned long) –> class std::shared_ptr<class protocols::match::downstream::DownstreamBuilder>

downstream_builders(self: pyrosetta.rosetta.protocols.match.Matcher, cst_id: int) → pyrosetta.rosetta.std.list_std_shared_ptr_protocols_match_downstream_DownstreamBuilder_t

Return non-const access to all of the downstream builders

for a particular geometric constraint

C++: protocols::match::Matcher::downstream_builders(unsigned long) const –> const class std::list<class std::shared_ptr<class protocols::match::downstream::DownstreamBuilder>, class std::allocator<class std::shared_ptr<class protocols::match::downstream::DownstreamBuilder> > > &

downstream_pose(self: pyrosetta.rosetta.protocols.match.Matcher) → pyrosetta.rosetta.core.pose.Pose

C++: protocols::match::Matcher::downstream_pose() const –> class std::shared_ptr<const class core::pose::Pose>

find_hits(self: pyrosetta.rosetta.protocols.match.Matcher) → bool

Main worker function

C++: protocols::match::Matcher::find_hits() –> bool

get_pose_build_resids(self: pyrosetta.rosetta.protocols.match.Matcher) → pyrosetta.rosetta.utility.vector1_unsigned_long

C++: protocols::match::Matcher::get_pose_build_resids() const –> const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &

has_upstream_only_geomcsts(self: pyrosetta.rosetta.protocols.match.Matcher) → bool

C++: protocols::match::Matcher::has_upstream_only_geomcsts() const –> bool

hits(self: pyrosetta.rosetta.protocols.match.Matcher, cst_id: int) → pyrosetta.rosetta.std.list_protocols_match_Hit_t

C++: protocols::match::Matcher::hits(unsigned long) const –> const class std::list<class protocols::match::Hit, class std::allocator<class protocols::match::Hit> > &

initialize_from_file(self: pyrosetta.rosetta.protocols.match.Matcher, enz_data: pyrosetta.rosetta.protocols.toolbox.match_enzdes_util.EnzConstraintIO, task: protocols::match::MatcherTask) → None

Intialize the geometric constraints from the EnzConstraionIO object.

C++: protocols::match::Matcher::initialize_from_file(const class protocols::toolbox::match_enzdes_util::EnzConstraintIO &, const class protocols::match::MatcherTask &) –> void

initialize_from_task(self: pyrosetta.rosetta.protocols.match.Matcher, task: protocols::match::MatcherTask) → None

The primary way to initialize a Matcher is through a MatcherTask.

C++: protocols::match::Matcher::initialize_from_task(const class protocols::match::MatcherTask &) –> void

n_geometric_constraints(self: pyrosetta.rosetta.protocols.match.Matcher) → int

C++: protocols::match::Matcher::n_geometric_constraints() const –> unsigned long

nonconst_downstream_algorithms(self: pyrosetta.rosetta.protocols.match.Matcher, cst_id: int) → pyrosetta.rosetta.std.list_std_shared_ptr_protocols_match_downstream_DownstreamAlgorithm_t

Non-const access to the set of downstream algorithms for a

particular geometric constraint – note that the list containing these algorithms is itself const.

C++: protocols::match::Matcher::nonconst_downstream_algorithms(unsigned long) –> const class std::list<class std::shared_ptr<class protocols::match::downstream::DownstreamAlgorithm>, class std::allocator<class std::shared_ptr<class protocols::match::downstream::DownstreamAlgorithm> > > &

occ_space_hash(self: pyrosetta.rosetta.protocols.match.Matcher) → protocols::match::OccupiedSpaceHash

C++: protocols::match::Matcher::occ_space_hash() –> class std::shared_ptr<class protocols::match::OccupiedSpaceHash>

process_matches(self: pyrosetta.rosetta.protocols.match.Matcher, processor: protocols::match::output::MatchProcessor) → None

After find_hits completes, use this function to have the

Matcher enerate the hit-combinations (matches) and send those matches to the specified match-processor. The match processor may do what it pleases with the matches.

C++: protocols::match::Matcher::process_matches(class protocols::match::output::MatchProcessor &) const –> void

representative_downstream_algorithm(self: pyrosetta.rosetta.protocols.match.Matcher, cst_id: int) → protocols::match::downstream::DownstreamAlgorithm

C++: protocols::match::Matcher::representative_downstream_algorithm(unsigned long) const –> class std::shared_ptr<const class protocols::match::downstream::DownstreamAlgorithm>

set_bump_tolerance(self: pyrosetta.rosetta.protocols.match.Matcher, permitted_overlap: float) → None

C++: protocols::match::Matcher::set_bump_tolerance(double) –> void

set_downstream_pose(self: pyrosetta.rosetta.protocols.match.Matcher, pose: pyrosetta.rosetta.core.pose.Pose, orientation_atoms: pyrosetta.rosetta.utility.vector1_core_id_AtomID) → None

C++: protocols::match::Matcher::set_downstream_pose(const class core::pose::Pose &, class utility::vector1<class core::id::AtomID, class std::allocator<class core::id::AtomID> >) –> void

set_fa_dun_cutoff_for_constraint(self: pyrosetta.rosetta.protocols.match.Matcher, cst_id: int, restype: pyrosetta.rosetta.core.chemical.ResidueType, fa_dun_cutoff: float) → None

C++: protocols::match::Matcher::set_fa_dun_cutoff_for_constraint(unsigned long, class std::shared_ptr<const class core::chemical::ResidueType>, double) –> void

set_hash_euclidean_bin_width(self: pyrosetta.rosetta.protocols.match.Matcher, width: float) → None

C++: protocols::match::Matcher::set_hash_euclidean_bin_width(double) –> void

set_hash_euclidean_bin_widths(self: pyrosetta.rosetta.protocols.match.Matcher, widths: pyrosetta.rosetta.numeric.xyzVector_double_t) → None

C++: protocols::match::Matcher::set_hash_euclidean_bin_widths(class numeric::xyzVector<double>) –> void

set_hash_euler_bin_width(self: pyrosetta.rosetta.protocols.match.Matcher, width: float) → None

C++: protocols::match::Matcher::set_hash_euler_bin_width(double) –> void

set_hash_euler_bin_widths(self: pyrosetta.rosetta.protocols.match.Matcher, widths: pyrosetta.rosetta.numeric.xyzVector_double_t) → None

C++: protocols::match::Matcher::set_hash_euler_bin_widths(class numeric::xyzVector<double>) –> void

set_n_geometric_constraints(self: pyrosetta.rosetta.protocols.match.Matcher, n_constraints: int) → None

C++: protocols::match::Matcher::set_n_geometric_constraints(unsigned long) –> void

set_occupied_space_bounding_box(self: pyrosetta.rosetta.protocols.match.Matcher, bb: pyrosetta.rosetta.numeric.geometry.BoundingBox_numeric_xyzVector_double_t) → None

C++: protocols::match::Matcher::set_occupied_space_bounding_box(const class numeric::geometry::BoundingBox<class numeric::xyzVector<double> > &) –> void

set_original_scaffold_build_points(self: pyrosetta.rosetta.protocols.match.Matcher, resids: pyrosetta.rosetta.utility.vector1_unsigned_long) → None

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

set_original_scaffold_build_points_for_constraint(self: pyrosetta.rosetta.protocols.match.Matcher, cst_id: int, resids: pyrosetta.rosetta.utility.vector1_unsigned_long) → None

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

set_sample_startegy_for_constraint(self: pyrosetta.rosetta.protocols.match.Matcher, cst_id: int, restype: pyrosetta.rosetta.core.chemical.ResidueType, chi: int, strat: protocols::match::upstream::SampleStrategyData) → None

C++: protocols::match::Matcher::set_sample_startegy_for_constraint(unsigned long, class std::shared_ptr<const class core::chemical::ResidueType>, unsigned long, const class protocols::match::upstream::SampleStrategyData &) –> void

set_upstream_pose(self: pyrosetta.rosetta.protocols.match.Matcher, pose: pyrosetta.rosetta.core.pose.Pose) → None

Setup

C++: protocols::match::Matcher::set_upstream_pose(const class core::pose::Pose &) –> void

upstream_builder(self: pyrosetta.rosetta.protocols.match.Matcher, cst_id: int) → protocols::match::upstream::UpstreamBuilder

C++: protocols::match::Matcher::upstream_builder(unsigned long) –> class std::shared_ptr<class protocols::match::upstream::UpstreamBuilder>

upstream_pose(self: pyrosetta.rosetta.protocols.match.Matcher) → pyrosetta.rosetta.core.pose.Pose

Data accessors

C++: protocols::match::Matcher::upstream_pose() const –> class std::shared_ptr<const class core::pose::Pose>

class pyrosetta.rosetta.protocols.match.MatcherMover

Bases: MultiplePoseMover

apply(self: pyrosetta.rosetta.protocols.match.MatcherMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::match::MatcherMover::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.moves.Mover, : pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::moves::Mover::operator=(const class protocols::moves::Mover &) –> class protocols::moves::Mover &

clear_info(self: pyrosetta.rosetta.protocols.moves.Mover) → None

Strings container can be used to return miscellaneous info (as std::string) from a mover, such as notes about the results of apply(). The job distributor (Apr 09 vintage) will check this function to see if your protocol wants to add string info to the Job that ran this mover. One way this can be useful is that later, a JobOutputter may include/append this info to an output file.

clear_info is called by jd2 before calling apply

C++: protocols::moves::Mover::clear_info() –> void

clone(self: pyrosetta.rosetta.protocols.match.MatcherMover) → pyrosetta.rosetta.protocols.moves.Mover

clone this object

C++: protocols::match::MatcherMover::clone() const –> class std::shared_ptr<class protocols::moves::Mover>

create(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::moves::Mover::create() –> class std::shared_ptr<class protocols::moves::Mover>

fresh_instance(self: pyrosetta.rosetta.protocols.match.MatcherMover) → pyrosetta.rosetta.protocols.moves.Mover

create this type of object

C++: protocols::match::MatcherMover::fresh_instance() const –> class std::shared_ptr<class protocols::moves::Mover>

get_additional_output(self: pyrosetta.rosetta.protocols.rosetta_scripts.MultiplePoseMover) → pyrosetta.rosetta.core.pose.Pose

C++: protocols::rosetta_scripts::MultiplePoseMover::get_additional_output() –> class std::shared_ptr<class core::pose::Pose>

get_current_job(self: pyrosetta.rosetta.protocols.moves.Mover) → protocols::jobdist::BasicJob

C++: protocols::moves::Mover::get_current_job() const –> class std::shared_ptr<const class protocols::jobdist::BasicJob>

get_current_tag(self: pyrosetta.rosetta.protocols.moves.Mover) → str

A tag is a unique identifier used to identify structures produced

by this Mover. get_current_tag() returns the tag, and set_current_tag( std::string tag ) sets the tag. This functionality is not intended for use with the 2008 job distributor.

C++: protocols::moves::Mover::get_current_tag() const –> std::string

get_input_pose(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.core.pose.Pose

C++: protocols::moves::Mover::get_input_pose() const –> class std::shared_ptr<const class core::pose::Pose>

get_last_move_status(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.protocols.moves.MoverStatus

returns status after an apply(). The job distributor (august 08 vintage) will check this function to see if your protocol wants to filter its results - if your protocol wants to say “that run was no good, skip it” then use the protected last_move_status(MoverStatus) to change the value that this function will return.

C++: protocols::moves::Mover::get_last_move_status() const –> enum protocols::moves::MoverStatus

get_name(self: pyrosetta.rosetta.protocols.match.MatcherMover) → str

C++: protocols::match::MatcherMover::get_name() const –> std::string

get_native_pose(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.core.pose.Pose

C++: protocols::moves::Mover::get_native_pose() const –> class std::shared_ptr<const class core::pose::Pose>

get_self_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::moves::Mover::get_self_ptr() –> class std::shared_ptr<class protocols::moves::Mover>

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.weak_ptr_protocols_moves_Mover_t

C++: protocols::moves::Mover::get_self_weak_ptr() –> class std::weak_ptr<class protocols::moves::Mover>

get_type(self: pyrosetta.rosetta.protocols.moves.Mover) → str

C++: protocols::moves::Mover::get_type() const –> std::string

info(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.list_std_string_t

non-const accessor

C++: protocols::moves::Mover::info() –> class std::list<std::string, class std::allocator<std::string > > &

last_proposal_density_ratio(self: pyrosetta.rosetta.protocols.moves.Mover) → float

C++: protocols::moves::Mover::last_proposal_density_ratio() –> double

static mover_name() → str

C++: protocols::match::MatcherMover::mover_name() –> std::string

static name() → str

C++: protocols::moves::Mover::name() –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.match.MatcherMover, tag: pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None

C++: protocols::match::MatcherMover::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.moves.Mover, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None

Provide citations to the passed CitationCollectionList

Subclasses should add the info for themselves and any other classes they use.

The default implementation of this function does nothing. It may be overriden by movers wishing to provide citation information.

C++: protocols::moves::Mover::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None

C++: protocols::match::MatcherMover::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

static register_options() → None

Overload this static method if you access options within the mover.

These options will end up in -help of your application if users of this mover call register_options. Do this recursively! If you use movers within your mover, call their register_options in your register_options() method.

C++: protocols::moves::Mover::register_options() –> void

reinitialize_for_each_job(self: pyrosetta.rosetta.protocols.moves.Mover) → bool

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be freshly regenerated on

each use.

C++: protocols::moves::Mover::reinitialize_for_each_job() const –> bool

reinitialize_for_new_input(self: pyrosetta.rosetta.protocols.moves.Mover) → bool

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be regenerated when the input

pose is about to change, (for example, if the Mover has special code on the first apply() that is only valid for that one input pose).

C++: protocols::moves::Mover::reinitialize_for_new_input() const –> bool

reset_status(self: pyrosetta.rosetta.protocols.moves.Mover) → None

resets status to SUCCESS, meant to be used before an apply(). The job distributor (august 08 vintage) uses this to ensure non-accumulation of status across apply()s.

C++: protocols::moves::Mover::reset_status() –> void

set_current_job(self: pyrosetta.rosetta.protocols.moves.Mover, job: protocols::jobdist::BasicJob) → None

C++: protocols::moves::Mover::set_current_job(class std::shared_ptr<const class protocols::jobdist::BasicJob>) –> void

set_current_tag(self: pyrosetta.rosetta.protocols.moves.Mover, new_tag: str) → None

C++: protocols::moves::Mover::set_current_tag(const std::string &) –> void

set_input_pose(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None

setter for poses contained for rms

C++: protocols::moves::Mover::set_input_pose(class std::shared_ptr<const class core::pose::Pose>) –> void

set_ligres(self: pyrosetta.rosetta.protocols.match.MatcherMover, ligres: pyrosetta.rosetta.core.conformation.Residue) → None

C++: protocols::match::MatcherMover::set_ligres(class std::shared_ptr<const class core::conformation::Residue>) –> void

set_match_positions(self: pyrosetta.rosetta.protocols.match.MatcherMover, match_positions: pyrosetta.rosetta.utility.vector1_unsigned_long) → None

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

set_native_pose(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None

setter for native poses contained for rms —- we should get rid of this method? it is widely used, but a bit unsafe

C++: protocols::moves::Mover::set_native_pose(class std::shared_ptr<const class core::pose::Pose>) –> void

set_previous_mover(self: pyrosetta.rosetta.protocols.rosetta_scripts.MultiplePoseMover, m: pyrosetta.rosetta.protocols.moves.Mover) → None

Used by RosettaScripts to set the previous mover to pull poses from

C++: protocols::rosetta_scripts::MultiplePoseMover::set_previous_mover(const class std::shared_ptr<class protocols::moves::Mover>) –> void

set_return_single_random_match(self: pyrosetta.rosetta.protocols.match.MatcherMover, single_random: bool) → None

if set to true, a single random match will be returned.

The default behavior is to use the MultiplePoseMover framework to return all matches

C++: protocols::match::MatcherMover::set_return_single_random_match(const bool) –> void

set_rosetta_scripts_tag(self: pyrosetta.rosetta.protocols.rosetta_scripts.MultiplePoseMover, tag: pyrosetta.rosetta.utility.tag.Tag) → None

sets rosettascripts tag

C++: protocols::rosetta_scripts::MultiplePoseMover::set_rosetta_scripts_tag(class std::shared_ptr<const class utility::tag::Tag>) –> void

set_type(self: pyrosetta.rosetta.protocols.moves.Mover, setting: str) → None

Set the ‘type’ string

C++: protocols::moves::Mover::set_type(const std::string &) –> void

show(*args, **kwargs)

Overloaded function.

1. show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None

2. show(self: pyrosetta.rosetta.protocols.moves.Mover, output: pyrosetta.rosetta.std.ostream) -> None

Outputs details about the Mover, including current settings.

C++: protocols::moves::Mover::show(std::ostream &) const –> void

test_move(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None

: Unit test support function. Apply one move to a given pose.

Allows extra test specific functions to be called before applying

C++: protocols::moves::Mover::test_move(class core::pose::Pose &) –> void

type(*args, **kwargs)

Overloaded function.

1. type(self: pyrosetta.rosetta.protocols.moves.Mover, type_in: str) -> None

Set the ‘type’ string

C++: protocols::moves::Mover::type(const std::string &) –> void

2. type(self: pyrosetta.rosetta.protocols.moves.Mover) -> str

Get the set ‘type’ string

C++: protocols::moves::Mover::type() const –> const std::string &

class pyrosetta.rosetta.protocols.match.MatcherMoverCreator

Bases: MoverCreator

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

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

create_mover(self: pyrosetta.rosetta.protocols.match.MatcherMoverCreator) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::match::MatcherMoverCreator::create_mover() const –> class std::shared_ptr<class protocols::moves::Mover>

keyname(self: pyrosetta.rosetta.protocols.match.MatcherMoverCreator) → str

C++: protocols::match::MatcherMoverCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.match.MatcherMoverCreator, xsd: utility::tag::XMLSchemaDefinition) → None

C++: protocols::match::MatcherMoverCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.protocols.match.MatcherOutputStats

Bases: pybind11_object

property all_lex_states

property num_considered_muliple_origins

property num_ds_hit_incompatible

property num_empty_uplist

property num_non_up_only_incompatible

property num_potential_matches

property num_sent_to_proc

property num_up_only_incompatible

class pyrosetta.rosetta.protocols.match.MatcherTask

Bases: pybind11_object

add_filter(self: pyrosetta.rosetta.protocols.match.MatcherTask, filter_name: str) → None

Add a filter by name to the set of filters being included. If that filter requires

extra data (as, for example, the UpstreamCollisionFilter) then the task should be expanded to include all the data necessary to create and initialize that filter. No valid options currently.

C++: protocols::match::MatcherTask::add_filter(const std::string &) –> void

append_downstream_atom_to_active_site_required_list(self: pyrosetta.rosetta.protocols.match.MatcherTask, atid: pyrosetta.rosetta.core.id.AtomID) → None

C++: protocols::match::MatcherTask::append_downstream_atom_to_active_site_required_list(class core::id::AtomID) –> void

append_upstream_resiue_as_defining_active_site(self: pyrosetta.rosetta.protocols.match.MatcherTask, resid: int, radius: float) → None

C++: protocols::match::MatcherTask::append_upstream_resiue_as_defining_active_site(unsigned long, double) –> void

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

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

build_round1_hits_twice(self: pyrosetta.rosetta.protocols.match.MatcherTask) → bool

C++: protocols::match::MatcherTask::build_round1_hits_twice() const –> bool

clear_downstream_orientation_atoms(self: pyrosetta.rosetta.protocols.match.MatcherTask) → None

C++: protocols::match::MatcherTask::clear_downstream_orientation_atoms() –> void

consolidate_matches(*args, **kwargs)

Overloaded function.

1. consolidate_matches(self: pyrosetta.rosetta.protocols.match.MatcherTask, setting: bool) -> None

Matches may either be output as soon as they are generated, or they may be consolidated.

When consolidating matches, the MatchProcessor (the MatchEvaluator) waits until all matches are seen before outputting any; it groups matches and selects the top N matches from each group to output. This can require a lot of memory if there are very many possible matches. MatchConsolidation is on by default.

C++: protocols::match::MatcherTask::consolidate_matches(bool) –> void

2. consolidate_matches(self: pyrosetta.rosetta.protocols.match.MatcherTask) -> bool

C++: protocols::match::MatcherTask::consolidate_matches() const –> bool

cstfile_name(self: pyrosetta.rosetta.protocols.match.MatcherTask) → str

C++: protocols::match::MatcherTask::cstfile_name() const –> const std::string &

define_active_site_from_gridlig_file(self: pyrosetta.rosetta.protocols.match.MatcherTask, file_name: str) → None

C++: protocols::match::MatcherTask::define_active_site_from_gridlig_file(const std::string &) –> void

define_active_site_from_residue_radii_list(self: pyrosetta.rosetta.protocols.match.MatcherTask) → None

C++: protocols::match::MatcherTask::define_active_site_from_residue_radii_list() –> void

define_match_by_single_downstream_positioning(*args, **kwargs)

Overloaded function.

1. define_match_by_single_downstream_positioning(self: pyrosetta.rosetta.protocols.match.MatcherTask, setting: bool) -> None

C++: protocols::match::MatcherTask::define_match_by_single_downstream_positioning(bool) –> void

2. define_match_by_single_downstream_positioning(self: pyrosetta.rosetta.protocols.match.MatcherTask) -> bool

C++: protocols::match::MatcherTask::define_match_by_single_downstream_positioning() const –> bool

downstream_atoms_required_inside_active_site(self: pyrosetta.rosetta.protocols.match.MatcherTask) → pyrosetta.rosetta.std.list_core_id_AtomID_t

C++: protocols::match::MatcherTask::downstream_atoms_required_inside_active_site() const –> const class std::list<class core::id::AtomID, class std::allocator<class core::id::AtomID> > &

downstream_orientation_atoms(self: pyrosetta.rosetta.protocols.match.MatcherTask) → pyrosetta.rosetta.utility.vector1_core_id_AtomID

C++: protocols::match::MatcherTask::downstream_orientation_atoms() const –> const class utility::vector1<class core::id::AtomID, class std::allocator<class core::id::AtomID> > &

downstream_pose(self: pyrosetta.rosetta.protocols.match.MatcherTask) → pyrosetta.rosetta.core.pose.Pose

C++: protocols::match::MatcherTask::downstream_pose() const –> class std::shared_ptr<const class core::pose::Pose>

dynamic_grid_refinement(self: pyrosetta.rosetta.protocols.match.MatcherTask) → bool

C++: protocols::match::MatcherTask::dynamic_grid_refinement() const –> bool

enumerate_ligand_rotamers(self: pyrosetta.rosetta.protocols.match.MatcherTask) → bool

C++: protocols::match::MatcherTask::enumerate_ligand_rotamers() const –> bool

enz_input_data(self: pyrosetta.rosetta.protocols.match.MatcherTask) → pyrosetta.rosetta.protocols.toolbox.match_enzdes_util.EnzConstraintIO

C++: protocols::match::MatcherTask::enz_input_data() const –> class std::shared_ptr<const class protocols::toolbox::match_enzdes_util::EnzConstraintIO>

euclidean_bin_widths(self: pyrosetta.rosetta.protocols.match.MatcherTask) → pyrosetta.rosetta.numeric.xyzVector_double_t

C++: protocols::match::MatcherTask::euclidean_bin_widths() const –> class numeric::xyzVector<double>

euler_bin_widths(self: pyrosetta.rosetta.protocols.match.MatcherTask) → pyrosetta.rosetta.numeric.xyzVector_double_t

C++: protocols::match::MatcherTask::euler_bin_widths() const –> class numeric::xyzVector<double>

evaluator_name(*args, **kwargs)

Overloaded function.

1. evaluator_name(self: pyrosetta.rosetta.protocols.match.MatcherTask, setting: str) -> None

Specify the name of the match-consolidator related match-evaluator class.

This class will rank each of the matches so that the consolidator may pick the top N. Valid options include: DownstreamRMSEvaluator. More evaluator options will be implemented shortly.

C++: protocols::match::MatcherTask::evaluator_name(const std::string &) –> void

2. evaluator_name(self: pyrosetta.rosetta.protocols.match.MatcherTask) -> str

C++: protocols::match::MatcherTask::evaluator_name() const –> const std::string &

filter_names(self: pyrosetta.rosetta.protocols.match.MatcherTask) → pyrosetta.rosetta.std.list_std_string_t

C++: protocols::match::MatcherTask::filter_names() const –> const class std::list<std::string, class std::allocator<std::string > > &

filter_upstream_collisions_by_score(*args, **kwargs)

Overloaded function.

1. filter_upstream_collisions_by_score(self: pyrosetta.rosetta.protocols.match.MatcherTask, setting: bool) -> None

C++: protocols::match::MatcherTask::filter_upstream_collisions_by_score(bool) –> void

2. filter_upstream_collisions_by_score(self: pyrosetta.rosetta.protocols.match.MatcherTask) -> bool

C++: protocols::match::MatcherTask::filter_upstream_collisions_by_score() const –> bool

filter_upstream_downstream_collisions(*args, **kwargs)

Overloaded function.

1. filter_upstream_downstream_collisions(self: pyrosetta.rosetta.protocols.match.MatcherTask, setting: bool) -> None

C++: protocols::match::MatcherTask::filter_upstream_downstream_collisions(bool) –> void

2. filter_upstream_downstream_collisions(self: pyrosetta.rosetta.protocols.match.MatcherTask) -> bool

C++: protocols::match::MatcherTask::filter_upstream_downstream_collisions() const –> bool

filter_upstream_downstream_collisions_by_score(*args, **kwargs)

Overloaded function.

1. filter_upstream_downstream_collisions_by_score(self: pyrosetta.rosetta.protocols.match.MatcherTask, setting: bool) -> None

C++: protocols::match::MatcherTask::filter_upstream_downstream_collisions_by_score(bool) –> void

2. filter_upstream_downstream_collisions_by_score(self: pyrosetta.rosetta.protocols.match.MatcherTask) -> bool

C++: protocols::match::MatcherTask::filter_upstream_downstream_collisions_by_score() const –> bool

filter_upstream_residue_collisions(*args, **kwargs)

Overloaded function.

1. filter_upstream_residue_collisions(self: pyrosetta.rosetta.protocols.match.MatcherTask, setting: bool) -> None

C++: protocols::match::MatcherTask::filter_upstream_residue_collisions(bool) –> void

2. filter_upstream_residue_collisions(self: pyrosetta.rosetta.protocols.match.MatcherTask) -> bool

C++: protocols::match::MatcherTask::filter_upstream_residue_collisions() const –> bool

geom_csts_downstream_output(self: pyrosetta.rosetta.protocols.match.MatcherTask) → pyrosetta.rosetta.utility.vector1_unsigned_long

C++: protocols::match::MatcherTask::geom_csts_downstream_output() const –> const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &

get_self_ptr(self: pyrosetta.rosetta.protocols.match.MatcherTask) → pyrosetta.rosetta.protocols.match.MatcherTask

C++: protocols::match::MatcherTask::get_self_ptr() –> class std::shared_ptr<class protocols::match::MatcherTask>

gridlig_active_site_definition(self: pyrosetta.rosetta.protocols.match.MatcherTask) → bool

Define the active site through a gridlig file (true), or by listing residue/radii paris (false)?

C++: protocols::match::MatcherTask::gridlig_active_site_definition() const –> bool

gridlig_file_name(self: pyrosetta.rosetta.protocols.match.MatcherTask) → str

Accessor for the file name containing the active-site definition in gridlig format

C++: protocols::match::MatcherTask::gridlig_file_name() const –> const std::string &

grouper_ds_rmsd(self: pyrosetta.rosetta.protocols.match.MatcherTask) → float

C++: protocols::match::MatcherTask::grouper_ds_rmsd() const –> double

grouper_name(*args, **kwargs)

Overloaded function.

1. grouper_name(self: pyrosetta.rosetta.protocols.match.MatcherTask, setting: str) -> None

Specify the name of the match-consolidator related match-grouper class.

This class will group matches together; the consolidator will then pick the top N from each group for output. Valid options include: SameChiBinComboGrouper, SameSequenceGrouper, and SameRotamerComboGrouper.

C++: protocols::match::MatcherTask::grouper_name(const std::string &) –> void

2. grouper_name(self: pyrosetta.rosetta.protocols.match.MatcherTask) -> str

C++: protocols::match::MatcherTask::grouper_name() const –> const std::string &

initialize_from_command_line(self: pyrosetta.rosetta.protocols.match.MatcherTask) → None

Initialize many parameters from the command line options

C++: protocols::match::MatcherTask::initialize_from_command_line() –> void

initialize_with_mcfi_list(self: pyrosetta.rosetta.protocols.match.MatcherTask, mcfi_list_vec: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_toolbox_match_enzdes_util_MatchConstraintFileInfoList_t) → None

Initialize all parameters except for the MatchConstraints from the command line

C++: protocols::match::MatcherTask::initialize_with_mcfi_list(class utility::vector1<class std::shared_ptr<class protocols::toolbox::match_enzdes_util::MatchConstraintFileInfoList>, class std::allocator<class std::shared_ptr<class protocols::toolbox::match_enzdes_util::MatchConstraintFileInfoList> > >) –> void

modify_pose_build_resids_from_endes_input(self: pyrosetta.rosetta.protocols.match.MatcherTask) → None

modify the match positions according to what is specified

in the cstfile

C++: protocols::match::MatcherTask::modify_pose_build_resids_from_endes_input() –> void

n_to_output_per_group(*args, **kwargs)

Overloaded function.

1. n_to_output_per_group(self: pyrosetta.rosetta.protocols.match.MatcherTask, setting: int) -> None

For use with the match consolidator; specify the number of output matches that the

consolidator should select for each group.

C++: protocols::match::MatcherTask::n_to_output_per_group(unsigned long) –> void

2. n_to_output_per_group(self: pyrosetta.rosetta.protocols.match.MatcherTask) -> int

C++: protocols::match::MatcherTask::n_to_output_per_group() const –> unsigned long

occ_space_bounding_box(self: pyrosetta.rosetta.protocols.match.MatcherTask) → pyrosetta.rosetta.numeric.geometry.BoundingBox_numeric_xyzVector_double_t

C++: protocols::match::MatcherTask::occ_space_bounding_box() const –> const class numeric::geometry::BoundingBox<class numeric::xyzVector<double> > &

only_enumerate_non_match_redundant_ligand_rotamers(self: pyrosetta.rosetta.protocols.match.MatcherTask) → bool

C++: protocols::match::MatcherTask::only_enumerate_non_match_redundant_ligand_rotamers() const –> bool

output_file_name(*args, **kwargs)

Overloaded function.

1. output_file_name(self: pyrosetta.rosetta.protocols.match.MatcherTask, setting: str) -> None

Indicate the name of the single output file to which the matches will be written

C++: protocols::match::MatcherTask::output_file_name(const std::string &) –> void

2. output_file_name(self: pyrosetta.rosetta.protocols.match.MatcherTask) -> str

C++: protocols::match::MatcherTask::output_file_name() const –> const std::string &

output_matchres_only(self: pyrosetta.rosetta.protocols.match.MatcherTask) → bool

C++: protocols::match::MatcherTask::output_matchres_only() const –> bool

output_scores(self: pyrosetta.rosetta.protocols.match.MatcherTask) → bool

C++: protocols::match::MatcherTask::output_scores() const –> bool

output_writer_name(*args, **kwargs)

Overloaded function.

1. output_writer_name(self: pyrosetta.rosetta.protocols.match.MatcherTask, setting: str) -> None

Specify the name of the class that will write the output.

Valid options include: KinWriter. More output options will be implemented shortly.

C++: protocols::match::MatcherTask::output_writer_name(const std::string &) –> void

2. output_writer_name(self: pyrosetta.rosetta.protocols.match.MatcherTask) -> str

C++: protocols::match::MatcherTask::output_writer_name() const –> const std::string &

permitted_overlap(self: pyrosetta.rosetta.protocols.match.MatcherTask) → float

C++: protocols::match::MatcherTask::permitted_overlap() const –> double

relevant_downstream_atoms(self: pyrosetta.rosetta.protocols.match.MatcherTask) → pyrosetta.rosetta.utility.vector1_core_id_AtomID

C++: protocols::match::MatcherTask::relevant_downstream_atoms() const –> const class utility::vector1<class core::id::AtomID, class std::allocator<class core::id::AtomID> > &

score_output_file_name(*args, **kwargs)

Overloaded function.

1. score_output_file_name(self: pyrosetta.rosetta.protocols.match.MatcherTask, setting: str) -> None

Set the name of the single output file to which the scores of matches will be written

C++: protocols::match::MatcherTask::score_output_file_name(const std::string &) –> void

2. score_output_file_name(self: pyrosetta.rosetta.protocols.match.MatcherTask) -> str

C++: protocols::match::MatcherTask::score_output_file_name() const –> const std::string &

set_downstream_orientation_atoms(self: pyrosetta.rosetta.protocols.match.MatcherTask, orientation_atoms: pyrosetta.rosetta.utility.vector1_core_id_AtomID) → None

C++: protocols::match::MatcherTask::set_downstream_orientation_atoms(const class utility::vector1<class core::id::AtomID, class std::allocator<class core::id::AtomID> > &) –> void

set_downstream_pose(*args, **kwargs)

Overloaded function.

1. set_downstream_pose(self: pyrosetta.rosetta.protocols.match.MatcherTask, input_pose: pyrosetta.rosetta.core.pose.Pose) -> None

C++: protocols::match::MatcherTask::set_downstream_pose(const class core::pose::Pose &) –> void

2. set_downstream_pose(self: pyrosetta.rosetta.protocols.match.MatcherTask, pose: pyrosetta.rosetta.core.pose.Pose, orientation_atoms: pyrosetta.rosetta.utility.vector1_core_id_AtomID) -> None

C++: protocols::match::MatcherTask::set_downstream_pose(const class core::pose::Pose &, const class utility::vector1<class core::id::AtomID, class std::allocator<class core::id::AtomID> > &) –> void

set_enumerate_ligand_rotamers(self: pyrosetta.rosetta.protocols.match.MatcherTask, setting: bool) → None

C++: protocols::match::MatcherTask::set_enumerate_ligand_rotamers(bool) –> void

set_enz_input_data(self: pyrosetta.rosetta.protocols.match.MatcherTask, data: pyrosetta.rosetta.protocols.toolbox.match_enzdes_util.EnzConstraintIO) → None

Set the matcher-file input data. The Matcher will read this data when initializing itself.

C++: protocols::match::MatcherTask::set_enz_input_data(class std::shared_ptr<const class protocols::toolbox::match_enzdes_util::EnzConstraintIO>) –> void

set_hash_euclidean_bin_width(self: pyrosetta.rosetta.protocols.match.MatcherTask, width: float) → None

For the occupied space hash, set the euclidean-bin width to a uniform value for xy&z

C++: protocols::match::MatcherTask::set_hash_euclidean_bin_width(double) –> void

set_hash_euler_bin_width(self: pyrosetta.rosetta.protocols.match.MatcherTask, width: float) → None

For the occupeid space hash, set the euler-bin width to a uniform value for phi,psi&theta

C++: protocols::match::MatcherTask::set_hash_euler_bin_width(double) –> void

set_ignore_cmdline_for_build_points(self: pyrosetta.rosetta.protocols.match.MatcherTask, setting: bool) → None

C++: protocols::match::MatcherTask::set_ignore_cmdline_for_build_points(bool) –> void

set_occupied_space_bounding_box(self: pyrosetta.rosetta.protocols.match.MatcherTask, bb: pyrosetta.rosetta.numeric.geometry.BoundingBox_numeric_xyzVector_double_t) → None

Set the bounding box for the region of space that the OccupiedSpaceHash should accept hits

in side of. If the 3rd orientation atom of the downstream partner is outside of this bounding box, the hit will be rejected out of hand.

C++: protocols::match::MatcherTask::set_occupied_space_bounding_box(const class numeric::geometry::BoundingBox<class numeric::xyzVector<double> > &) –> void

set_only_enumerate_non_match_redundant_ligand_rotamers(self: pyrosetta.rosetta.protocols.match.MatcherTask, setting: bool) → None

C++: protocols::match::MatcherTask::set_only_enumerate_non_match_redundant_ligand_rotamers(bool) –> void

set_original_scaffold_build_points(self: pyrosetta.rosetta.protocols.match.MatcherTask, resids: pyrosetta.rosetta.utility.vector1_unsigned_long) → None

Uniformly consider the same set of build points for each of the geometric constrains

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

set_original_scaffold_build_points_for_geometric_constraint(self: pyrosetta.rosetta.protocols.match.MatcherTask, geom_cst_id: int, resids: pyrosetta.rosetta.utility.vector1_unsigned_long) → None

Set the build point id’s for a particular geometric constraint

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

set_permitted_overlap(self: pyrosetta.rosetta.protocols.match.MatcherTask, permitted_overlap: float) → None

For collision detection, select the amount of collision that should

be tolerated between heavy atoms. This should be a positive value in Angstroms.

C++: protocols::match::MatcherTask::set_permitted_overlap(double) –> void

set_upstream_pose(self: pyrosetta.rosetta.protocols.match.MatcherTask, pose: pyrosetta.rosetta.core.pose.Pose) → None

Setup

C++: protocols::match::MatcherTask::set_upstream_pose(const class core::pose::Pose &) –> void

upstream_downstream_atom_collision_tolerance(*args, **kwargs)

Overloaded function.

1. upstream_downstream_atom_collision_tolerance(self: pyrosetta.rosetta.protocols.match.MatcherTask, setting: float) -> None

C++: protocols::match::MatcherTask::upstream_downstream_atom_collision_tolerance(double) –> void

2. upstream_downstream_atom_collision_tolerance(self: pyrosetta.rosetta.protocols.match.MatcherTask) -> float

C++: protocols::match::MatcherTask::upstream_downstream_atom_collision_tolerance() const –> double

upstream_downstream_residue_collision_Wfa_atr(*args, **kwargs)

Overloaded function.

1. upstream_downstream_residue_collision_Wfa_atr(self: pyrosetta.rosetta.protocols.match.MatcherTask, setting: float) -> None

C++: protocols::match::MatcherTask::upstream_downstream_residue_collision_Wfa_atr(double) –> void

2. upstream_downstream_residue_collision_Wfa_atr(self: pyrosetta.rosetta.protocols.match.MatcherTask) -> float

C++: protocols::match::MatcherTask::upstream_downstream_residue_collision_Wfa_atr() const –> double

upstream_downstream_residue_collision_Wfa_rep(*args, **kwargs)

Overloaded function.

1. upstream_downstream_residue_collision_Wfa_rep(self: pyrosetta.rosetta.protocols.match.MatcherTask, setting: float) -> None

C++: protocols::match::MatcherTask::upstream_downstream_residue_collision_Wfa_rep(double) –> void

2. upstream_downstream_residue_collision_Wfa_rep(self: pyrosetta.rosetta.protocols.match.MatcherTask) -> float

C++: protocols::match::MatcherTask::upstream_downstream_residue_collision_Wfa_rep() const –> double

upstream_downstream_residue_collision_Wfa_sol(*args, **kwargs)

Overloaded function.

1. upstream_downstream_residue_collision_Wfa_sol(self: pyrosetta.rosetta.protocols.match.MatcherTask, setting: float) -> None

C++: protocols::match::MatcherTask::upstream_downstream_residue_collision_Wfa_sol(double) –> void

2. upstream_downstream_residue_collision_Wfa_sol(self: pyrosetta.rosetta.protocols.match.MatcherTask) -> float

C++: protocols::match::MatcherTask::upstream_downstream_residue_collision_Wfa_sol() const –> double

upstream_downstream_residue_collision_score_cutoff(*args, **kwargs)

Overloaded function.

1. upstream_downstream_residue_collision_score_cutoff(self: pyrosetta.rosetta.protocols.match.MatcherTask, setting: float) -> None

C++: protocols::match::MatcherTask::upstream_downstream_residue_collision_score_cutoff(double) –> void

2. upstream_downstream_residue_collision_score_cutoff(self: pyrosetta.rosetta.protocols.match.MatcherTask) -> float

C++: protocols::match::MatcherTask::upstream_downstream_residue_collision_score_cutoff() const –> double

upstream_only_geom_cst(self: pyrosetta.rosetta.protocols.match.MatcherTask) → pyrosetta.rosetta.std.map_unsigned_long_unsigned_long

C++: protocols::match::MatcherTask::upstream_only_geom_cst() const –> const class std::map<unsigned long, unsigned long, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, unsigned long> > > &

upstream_pose(self: pyrosetta.rosetta.protocols.match.MatcherTask) → pyrosetta.rosetta.core.pose.Pose

C++: protocols::match::MatcherTask::upstream_pose() const –> class std::shared_ptr<const class core::pose::Pose>

upstream_pose_build_resids_for_geometric_constraint(self: pyrosetta.rosetta.protocols.match.MatcherTask, cst_id: int) → pyrosetta.rosetta.utility.vector1_unsigned_long

C++: protocols::match::MatcherTask::upstream_pose_build_resids_for_geometric_constraint(unsigned long) const –> const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &

upstream_pose_name(self: pyrosetta.rosetta.protocols.match.MatcherTask) → str

C++: protocols::match::MatcherTask::upstream_pose_name() const –> const std::string &

upstream_resids_and_radii_defining_active_site(self: pyrosetta.rosetta.protocols.match.MatcherTask) → pyrosetta.rosetta.std.list_std_pair_unsigned_long_double_t

Accessor for the data defining the active site by-residue. This data is only

active if gridlig_active_site_definition() returns false.

C++: protocols::match::MatcherTask::upstream_resids_and_radii_defining_active_site() const –> const class std::list<struct std::pair<unsigned long, double>, class std::allocator<struct std::pair<unsigned long, double> > > &

upstream_residue_collision_Wfa_atr(*args, **kwargs)

Overloaded function.

1. upstream_residue_collision_Wfa_atr(self: pyrosetta.rosetta.protocols.match.MatcherTask, setting: float) -> None

C++: protocols::match::MatcherTask::upstream_residue_collision_Wfa_atr(double) –> void

2. upstream_residue_collision_Wfa_atr(self: pyrosetta.rosetta.protocols.match.MatcherTask) -> float

C++: protocols::match::MatcherTask::upstream_residue_collision_Wfa_atr() const –> double

upstream_residue_collision_Wfa_rep(*args, **kwargs)

Overloaded function.

1. upstream_residue_collision_Wfa_rep(self: pyrosetta.rosetta.protocols.match.MatcherTask, setting: float) -> None

C++: protocols::match::MatcherTask::upstream_residue_collision_Wfa_rep(double) –> void

2. upstream_residue_collision_Wfa_rep(self: pyrosetta.rosetta.protocols.match.MatcherTask) -> float

C++: protocols::match::MatcherTask::upstream_residue_collision_Wfa_rep() const –> double

upstream_residue_collision_Wfa_sol(*args, **kwargs)

Overloaded function.

1. upstream_residue_collision_Wfa_sol(self: pyrosetta.rosetta.protocols.match.MatcherTask, setting: float) -> None

C++: protocols::match::MatcherTask::upstream_residue_collision_Wfa_sol(double) –> void

2. upstream_residue_collision_Wfa_sol(self: pyrosetta.rosetta.protocols.match.MatcherTask) -> float

C++: protocols::match::MatcherTask::upstream_residue_collision_Wfa_sol() const –> double

upstream_residue_collision_score_cutoff(*args, **kwargs)

Overloaded function.

1. upstream_residue_collision_score_cutoff(self: pyrosetta.rosetta.protocols.match.MatcherTask, setting: float) -> None

C++: protocols::match::MatcherTask::upstream_residue_collision_score_cutoff(double) –> void

2. upstream_residue_collision_score_cutoff(self: pyrosetta.rosetta.protocols.match.MatcherTask) -> float

C++: protocols::match::MatcherTask::upstream_residue_collision_score_cutoff() const –> double

upstream_residue_collision_tolerance(*args, **kwargs)

Overloaded function.

1. upstream_residue_collision_tolerance(self: pyrosetta.rosetta.protocols.match.MatcherTask, setting: float) -> None

C++: protocols::match::MatcherTask::upstream_residue_collision_tolerance(double) –> void

2. upstream_residue_collision_tolerance(self: pyrosetta.rosetta.protocols.match.MatcherTask) -> float

C++: protocols::match::MatcherTask::upstream_residue_collision_tolerance() const –> double

use_different_build_points_for_each_geometric_constraint(self: pyrosetta.rosetta.protocols.match.MatcherTask, n_geometric_constraints: int) → None

Set up the task so that it keeps different backbone build points for each

geometric constraint – the task then needs to know how many geometric constraints there are.

C++: protocols::match::MatcherTask::use_different_build_points_for_each_geometric_constraint(unsigned long) –> void

use_input_sc(self: pyrosetta.rosetta.protocols.match.MatcherTask) → bool

C++: protocols::match::MatcherTask::use_input_sc() const –> bool

class pyrosetta.rosetta.protocols.match.NumNeighborsMPM

Bases: MatchPositionModifier

removes positions whose numer of neighbors below a 10A cutoff is not within the desired range. if either min_neighbors_ or max_neighbors_ are unspecified (0), this means that they won’t be taken into account, i.e. if min is 5 and max is 0, every position that has more than 4 neighbors will be allowed. also offers the possibility of combining the num neighbors cutoff with the angle between the CA->CB vector of the residue and the CA->protein_center_of_mass vector, for example to only allow positions that point inward

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

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

modified_match_positions(self: pyrosetta.rosetta.protocols.match.NumNeighborsMPM, original_positions: pyrosetta.rosetta.utility.vector1_unsigned_long, match_pose: pyrosetta.rosetta.core.pose.Pose, mtask: protocols::match::MatcherTask) → pyrosetta.rosetta.utility.vector1_unsigned_long

C++: protocols::match::NumNeighborsMPM::modified_match_positions(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class core::pose::Pose &, class std::shared_ptr<const class protocols::match::MatcherTask>) const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

passes_com_vector_criterion(self: pyrosetta.rosetta.protocols.match.NumNeighborsMPM, seqpos: int, pose: pyrosetta.rosetta.core.pose.Pose, com: pyrosetta.rosetta.numeric.xyzVector_double_t) → bool

C++: protocols::match::NumNeighborsMPM::passes_com_vector_criterion(unsigned long, const class core::pose::Pose &, const class numeric::xyzVector<double> &) const –> bool

class pyrosetta.rosetta.protocols.match.OccupiedSpaceHash

Bases: pybind11_object

This class keeps track of the active voxels “up until now” with 64 hashes.

Each hash has a slightly shifted definition of the origin, so that points which are close in 6D will end up in the same hash voxel in at least one of these 64 hashes. The amount of data held in this table is intentionally small: a single boolean (32 bits). The meaning is as follows: In the first round of matching constraints, “false” is inserted into each of the hashes for each non-colliding placement of the downstream partner. The map is not altered between the end of the first round and the beginning of the second round. At the end of all rounds besides the first round, the Matcher updates the OccupiedSpaceHash object for each non-colliding placement of the dowstream partner found during that round: for each non-colliding placement of the downstream partner and for each of the 64 hashes, the 6Dofs describing the downstream partner are hashed: if the hash finds an element in the hash table, that element’s value is set to “true”. At the end of each round past the second round, the entire hash is traversed. Any element whose value is “false” represents a voxel that failed to find a match during that round. Such elements are deleted from the hash. Any element whose value is “true” DID get a hit from that round and should remain in the hash. The element’s value is set to “false”. After the OccupiedSpaceHash has cleared out the elements which failed to find a match for the previous round, the Matcher may proceed to “clean up” its older hits (from rounds previous to this one) by querying them against the hash map. Any hit in the Matcher that does not have a corresponding element in any of the 64 hashes of the OccupiedSpaceHash may be deleted, since it cannot form a complete match.

This class is intended to be accessed by multiple threads but in a controlled way: read access function “match_possible_for_hit_geometry” is accessible to all threads during the “building” stage. However, the functions note_hit_geometry and drop_unsatisfied_voxels should be called by single thread only, and no other thread should try to access the ActiveVoxelHashes object at that time.

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

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

drop_unsatisfied_voxels(self: pyrosetta.rosetta.protocols.match.OccupiedSpaceHash) → None

C++: protocols::match::OccupiedSpaceHash::drop_unsatisfied_voxels() –> void

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

C++: protocols::match::OccupiedSpaceHash::initialize() –> void

insert_hit_geometry(self: pyrosetta.rosetta.protocols.match.OccupiedSpaceHash, geom: pyrosetta.rosetta.utility.fixedsizearray1_double_6_t) → None

C++: protocols::match::OccupiedSpaceHash::insert_hit_geometry(const class utility::fixedsizearray1<double, 6> &) –> void

match_possible_for_hit_geometry(self: pyrosetta.rosetta.protocols.match.OccupiedSpaceHash, : pyrosetta.rosetta.utility.fixedsizearray1_double_6_t) → bool

C++: protocols::match::OccupiedSpaceHash::match_possible_for_hit_geometry(const class utility::fixedsizearray1<double, 6> &) const –> bool

note_hit_geometry(self: pyrosetta.rosetta.protocols.match.OccupiedSpaceHash, : pyrosetta.rosetta.utility.fixedsizearray1_double_6_t) → None

C++: protocols::match::OccupiedSpaceHash::note_hit_geometry(const class utility::fixedsizearray1<double, 6> &) –> void

prepare_to_note_hits_for_completed_round(self: pyrosetta.rosetta.protocols.match.OccupiedSpaceHash) → None

C++: protocols::match::OccupiedSpaceHash::prepare_to_note_hits_for_completed_round() –> void

previous_round_geometry_still_matchable(self: pyrosetta.rosetta.protocols.match.OccupiedSpaceHash, : pyrosetta.rosetta.utility.fixedsizearray1_double_6_t) → bool

C++: protocols::match::OccupiedSpaceHash::previous_round_geometry_still_matchable(const class utility::fixedsizearray1<double, 6> &) –> bool

reset_3d_projection(self: pyrosetta.rosetta.protocols.match.OccupiedSpaceHash) → None

C++: protocols::match::OccupiedSpaceHash::reset_3d_projection() –> void

revision_id(self: pyrosetta.rosetta.protocols.match.OccupiedSpaceHash) → int

C++: protocols::match::OccupiedSpaceHash::revision_id() const –> unsigned long

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

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

set_euler_bin_widths(self: pyrosetta.rosetta.protocols.match.OccupiedSpaceHash, euler_bin_widths: pyrosetta.rosetta.numeric.xyzVector_double_t) → None

C++: protocols::match::OccupiedSpaceHash::set_euler_bin_widths(const class numeric::xyzVector<double> &) –> void

set_uniform_euler_angle_bin_width(self: pyrosetta.rosetta.protocols.match.OccupiedSpaceHash, bin_width_degrees: float) → None

C++: protocols::match::OccupiedSpaceHash::set_uniform_euler_angle_bin_width(double) –> void

set_uniform_xyz_bin_width(self: pyrosetta.rosetta.protocols.match.OccupiedSpaceHash, bin_width: float) → None

C++: protocols::match::OccupiedSpaceHash::set_uniform_xyz_bin_width(double) –> void

set_xyz_bin_widths(self: pyrosetta.rosetta.protocols.match.OccupiedSpaceHash, bin_widths: pyrosetta.rosetta.numeric.xyzVector_double_t) → None

C++: protocols::match::OccupiedSpaceHash::set_xyz_bin_widths(const class numeric::xyzVector<double> &) –> void

write_3Dprojection_kinemage(self: pyrosetta.rosetta.protocols.match.OccupiedSpaceHash, kin_file_name: str) → None

C++: protocols::match::OccupiedSpaceHash::write_3Dprojection_kinemage(const std::string &) –> void

class pyrosetta.rosetta.protocols.match.ProbeRadius

Bases: pybind11_object

The different radii types used in collision detection.

These values are taken from Probe / Reduce from the Richardson lab. Code inside BumpGrid.cc assumes the radii listed here being in non-decreasing order, and that ZERO is the 0th element of this enumeration.

Members:

ZERO

H_ARO

H_ALA

OXY

NIT

C_CAR

C_ALA

SULPH

n_probe_radii

C_ALA = <ProbeRadius.C_ALA: 6>

C_CAR = <ProbeRadius.C_CAR: 5>

H_ALA = <ProbeRadius.H_ALA: 2>

H_ARO = <ProbeRadius.H_ARO: 1>

NIT = <ProbeRadius.NIT: 4>

OXY = <ProbeRadius.OXY: 3>

SULPH = <ProbeRadius.SULPH: 7>

ZERO = <ProbeRadius.ZERO: 0>

n_probe_radii = <ProbeRadius.SULPH: 7>

property name

property value

class pyrosetta.rosetta.protocols.match.RemoveNorCTermMPM

Bases: MatchPositionModifier

added by olga and flo 1/2011 class to exclude positions at the n and c termini of proteins from matching

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

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

modified_match_positions(self: pyrosetta.rosetta.protocols.match.RemoveNorCTermMPM, original_positions: pyrosetta.rosetta.utility.vector1_unsigned_long, match_pose: pyrosetta.rosetta.core.pose.Pose, mtask: protocols::match::MatcherTask) → pyrosetta.rosetta.utility.vector1_unsigned_long

C++: protocols::match::RemoveNorCTermMPM::modified_match_positions(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class core::pose::Pose &, class std::shared_ptr<const class protocols::match::MatcherTask>) const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

class pyrosetta.rosetta.protocols.match.SecondaryStructureMPM

Bases: MatchPositionModifier

removes positions at which the pose does not have the desired secondary structure

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

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

modified_match_positions(self: pyrosetta.rosetta.protocols.match.SecondaryStructureMPM, original_positions: pyrosetta.rosetta.utility.vector1_unsigned_long, match_pose: pyrosetta.rosetta.core.pose.Pose, mtask: protocols::match::MatcherTask) → pyrosetta.rosetta.utility.vector1_unsigned_long

C++: protocols::match::SecondaryStructureMPM::modified_match_positions(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class core::pose::Pose &, class std::shared_ptr<const class protocols::match::MatcherTask>) const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

class pyrosetta.rosetta.protocols.match.TaskOperationMPM

Bases: MatchPositionModifier

mpm that will get a task operation as specified in the tag from the TaskOperationFactory, apply the task operation to the pose and every residue that is then set to designing in the task will be a match position

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

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

modified_match_positions(self: pyrosetta.rosetta.protocols.match.TaskOperationMPM, original_positions: pyrosetta.rosetta.utility.vector1_unsigned_long, match_pose: pyrosetta.rosetta.core.pose.Pose, mtask: protocols::match::MatcherTask) → pyrosetta.rosetta.utility.vector1_unsigned_long

C++: protocols::match::TaskOperationMPM::modified_match_positions(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class core::pose::Pose &, class std::shared_ptr<const class protocols::match::MatcherTask>) const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

class pyrosetta.rosetta.protocols.match.VoxelSetIterator

Bases: pybind11_object

Helper class for the OccupiedSpaceHasher which manages the logic for how to iterate across the 64 voxels that each 6-D point covers.

This class ensures that the bounding box for the hash is not walked outside of, that the phi and psi are wrapped at 360, and that when theta is near a gimbal-lock angle of 180 or 0, that phi and psi are appropriately wrapped to the negative rotation. This class may be rapidly allocated and deallocated on the stack – no calls to new are made anywhere.

at_end(self: pyrosetta.rosetta.protocols.match.VoxelSetIterator) → bool

C++: protocols::match::VoxelSetIterator::at_end() const –> bool

get_bin_and_pos(self: pyrosetta.rosetta.protocols.match.VoxelSetIterator, bin: pyrosetta.rosetta.utility.fixedsizearray1_unsigned_long_6_t, pos: int) → None

C++: protocols::match::VoxelSetIterator::get_bin_and_pos(class utility::fixedsizearray1<unsigned long, 6> &, unsigned long &) const –> void

pre_increment(self: pyrosetta.rosetta.protocols.match.VoxelSetIterator) → None

C++: protocols::match::VoxelSetIterator::operator++() –> void

pyrosetta.rosetta.protocols.match.advance_euler_angles(orig_angles: pyrosetta.rosetta.utility.fixedsizearray1_double_3_t, offsets: pyrosetta.rosetta.utility.fixedsizearray1_double_3_t) → pyrosetta.rosetta.utility.fixedsizearray1_double_3_t

Increment the euler angles and then wrap them into their appropriate ranges

C++: protocols::match::advance_euler_angles(const class utility::fixedsizearray1<double, 3> &, const class utility::fixedsizearray1<double, 3> &) –> class utility::fixedsizearray1<double, 3>

pyrosetta.rosetta.protocols.match.bump_grid_to_enclose_pose(pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.protocols.match.BumpGrid

C++: protocols::match::bump_grid_to_enclose_pose(const class core::pose::Pose &) –> class std::shared_ptr<class protocols::match::BumpGrid>

pyrosetta.rosetta.protocols.match.bump_grid_to_enclose_residue(residue: pyrosetta.rosetta.core.conformation.Residue, original_grid: pyrosetta.rosetta.protocols.match.BumpGrid) → pyrosetta.rosetta.protocols.match.BumpGrid

Construct a BumpGrid that encloses a single residue. Use the

original_grid as a starting point, copying over all pertinent data such that the two grids can later be merged together.

C++: protocols::match::bump_grid_to_enclose_residue(const class core::conformation::Residue &, const class protocols::match::BumpGrid &) –> class std::shared_ptr<class protocols::match::BumpGrid>

pyrosetta.rosetta.protocols.match.bump_grid_to_enclose_residue_backbone(residue: pyrosetta.rosetta.core.conformation.Residue, original_grid: pyrosetta.rosetta.protocols.match.BumpGrid) → pyrosetta.rosetta.protocols.match.BumpGrid

Construct a BumpGrid that encloses the backbone atoms for a single residue.

Use the original_grid as a starting point, copying over all pertinent data such that the two grids can later be merged together.

C++: protocols::match::bump_grid_to_enclose_residue_backbone(const class core::conformation::Residue &, const class protocols::match::BumpGrid &) –> class std::shared_ptr<class protocols::match::BumpGrid>

pyrosetta.rosetta.protocols.match.create_match_position_modifier(mpm_name: str, geom_cst: int, input_tokens: pyrosetta.rosetta.utility.vector1_std_string) → protocols::match::MatchPositionModifier

“factory” function to create the match position modifiers

C++: protocols::match::create_match_position_modifier(const std::string &, unsigned long, const class utility::vector1<std::string, class std::allocator<std::string > > &) –> class std::shared_ptr<const class protocols::match::MatchPositionModifier>

class pyrosetta.rosetta.protocols.match.downstream_hit

Bases: pybind11_object

copy_hit(self: pyrosetta.rosetta.protocols.match.downstream_hit, source: pyrosetta.rosetta.protocols.match.Hit) → None

C++: protocols::match::downstream_hit::copy_hit(const class protocols::match::Hit &) –> void

downstream_conf_id(self: pyrosetta.rosetta.protocols.match.downstream_hit) → int

C++: protocols::match::downstream_hit::downstream_conf_id() const –> unsigned long

second(self: pyrosetta.rosetta.protocols.match.downstream_hit) → pyrosetta.rosetta.utility.fixedsizearray1_double_6_t

C++: protocols::match::downstream_hit::second() –> class utility::fixedsizearray1<double, 6> &

pyrosetta.rosetta.protocols.match.fake_hit(*args, **kwargs)

Overloaded function.

1. fake_hit(: pyrosetta.rosetta.protocols.match.upstream_hit) -> pyrosetta.rosetta.protocols.match.Hit

Create a fake hit from an upstream_hit where hit.first()[4] and hit.second() are 0’s.

C++: protocols::match::fake_hit(const class protocols::match::upstream_hit &) –> class protocols::match::Hit

2. fake_hit(: pyrosetta.rosetta.protocols.match.downstream_hit) -> pyrosetta.rosetta.protocols.match.Hit

Create a fake hit from a downstream_hit where hit.first()[1-3] are 0’s.

C++: protocols::match::fake_hit(const class protocols::match::downstream_hit &) –> class protocols::match::Hit

pyrosetta.rosetta.protocols.match.fill_grid_with_backbone_heavyatom_spheres(residue: pyrosetta.rosetta.core.conformation.Residue, grid: pyrosetta.rosetta.protocols.match.BumpGrid) → None

C++: protocols::match::fill_grid_with_backbone_heavyatom_spheres(const class core::conformation::Residue &, class protocols::match::BumpGrid &) –> void

pyrosetta.rosetta.protocols.match.fill_grid_with_residue_heavyatom_spheres(residue: pyrosetta.rosetta.core.conformation.Residue, grid: pyrosetta.rosetta.protocols.match.BumpGrid) → None

C++: protocols::match::fill_grid_with_residue_heavyatom_spheres(const class core::conformation::Residue &, class protocols::match::BumpGrid &) –> void

pyrosetta.rosetta.protocols.match.fill_grid_with_residue_spheres(residue: pyrosetta.rosetta.core.conformation.Residue, grid: pyrosetta.rosetta.protocols.match.BumpGrid) → None

C++: protocols::match::fill_grid_with_residue_spheres(const class core::conformation::Residue &, class protocols::match::BumpGrid &) –> void

pyrosetta.rosetta.protocols.match.full_hit(m: pyrosetta.rosetta.protocols.match.match_dspos1) → pyrosetta.rosetta.protocols.match.Hit

Create a hit with the full data from a given match_dspos1 representing

the upstream conformation from the originating_geom_cst and its description of the downstream position.

C++: protocols::match::full_hit(const struct protocols::match::match_dspos1 &) –> class protocols::match::Hit

class pyrosetta.rosetta.protocols.match.match_dspos1

Bases: pybind11_object

Describe a match as n_geometric_constraint upstream residue conformations and one positioning of the downstream partner ( “dspos1” = 1 downstrem position)

property downstream_conf_id

property dspos

property originating_geom_cst_for_dspos

property upstream_hits

class pyrosetta.rosetta.protocols.match.match_lite_equals

Bases: pybind11_object

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

C++: protocols::match::match_lite_equals::operator=(const struct protocols::match::match_lite_equals &) –> struct protocols::match::match_lite_equals &

class pyrosetta.rosetta.protocols.match.match_lite_hasher

Bases: pybind11_object

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

C++: protocols::match::match_lite_hasher::operator=(const struct protocols::match::match_lite_hasher &) –> struct protocols::match::match_lite_hasher &

pyrosetta.rosetta.protocols.match.probe_radius_for_atom_type(atomtype: int) → pyrosetta.rosetta.protocols.match.ProbeRadius

C++: protocols::match::probe_radius_for_atom_type(unsigned long) –> enum protocols::match::ProbeRadius

pyrosetta.rosetta.protocols.match.set_ligpose_rotamer(ligpose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::match::set_ligpose_rotamer(class core::pose::Pose &) –> void

class pyrosetta.rosetta.protocols.match.upstream_hit

Bases: pybind11_object

copy_hit(self: pyrosetta.rosetta.protocols.match.upstream_hit, source: pyrosetta.rosetta.protocols.match.Hit) → None

C++: protocols::match::upstream_hit::copy_hit(const class protocols::match::Hit &) –> void

external_geom_id(*args, **kwargs)

Overloaded function.

1. external_geom_id(self: pyrosetta.rosetta.protocols.match.upstream_hit) -> int

C++: protocols::match::upstream_hit::external_geom_id() const –> unsigned long

2. external_geom_id(self: pyrosetta.rosetta.protocols.match.upstream_hit, setting: int) -> None

C++: protocols::match::upstream_hit::external_geom_id(unsigned long) –> void

scaffold_build_id(*args, **kwargs)

Overloaded function.

1. scaffold_build_id(self: pyrosetta.rosetta.protocols.match.upstream_hit) -> int

C++: protocols::match::upstream_hit::scaffold_build_id() const –> unsigned long

2. scaffold_build_id(self: pyrosetta.rosetta.protocols.match.upstream_hit, setting: int) -> None

C++: protocols::match::upstream_hit::scaffold_build_id(unsigned long) –> void

upstream_conf_id(*args, **kwargs)

Overloaded function.

1. upstream_conf_id(self: pyrosetta.rosetta.protocols.match.upstream_hit) -> int

C++: protocols::match::upstream_hit::upstream_conf_id() const –> unsigned long

2. upstream_conf_id(self: pyrosetta.rosetta.protocols.match.upstream_hit, setting: int) -> None

C++: protocols::match::upstream_hit::upstream_conf_id(unsigned long) –> void