| | |
- builtins.object
-
- Bool3DGrid
- Bool3DGridKinemageWriter
- BumpGrid
- Hit
- HitHasher
- HitNeighborFinder
- MatchCounter
- MatchOutputTracker
- MatchPositionModifier
-
- AddAllPositionsMPM
- BfactorMPM
- NumNeighborsMPM
- RemoveNorCTermMPM
- SecondaryStructureMPM
- TaskOperationMPM
- Matcher
- MatcherOutputStats
- MatcherTask
- OccupiedSpaceHash
- ProbeRadius
- VoxelSetIterator
- downstream_hit
- match_dspos1
- match_lite_equals
- match_lite_hasher
- upstream_hit
- rosetta.protocols.moves.MoverCreator(builtins.object)
-
- MatcherMoverCreator
- rosetta.protocols.rosetta_scripts.MultiplePoseMover(rosetta.protocols.moves.Mover)
-
- MatcherMover
class BfactorMPM(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
|
| |
- Method resolution order:
- BfactorMPM
- MatchPositionModifier
- builtins.object
Methods defined here:
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(self : handle, input_tokens : rosetta.utility.vector1_std_string) -> NoneType
2. __init__(handle, rosetta.protocols.match.BfactorMPM) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- assign(...) from builtins.PyCapsule
- assign(self : rosetta.protocols.match.BfactorMPM, : rosetta.protocols.match.BfactorMPM) -> rosetta.protocols.match.BfactorMPM
- get_ca_bfactors(...) from builtins.PyCapsule
- get_ca_bfactors(self : rosetta.protocols.match.BfactorMPM, pose : rosetta.core.pose.Pose) -> rosetta.utility.vector1_double
- modified_match_positions(...) from builtins.PyCapsule
- modified_match_positions(self : rosetta.protocols.match.BfactorMPM, original_positions : rosetta.utility.vector1_unsigned_long, match_pose : rosetta.core.pose.Pose, mtask : protocols::match::MatcherTask) -> rosetta.utility.vector1_unsigned_long
|
class Bool3DGrid(builtins.object) |
| | |
Methods defined here:
- __init__(...) from builtins.PyCapsule
- __init__(rosetta.protocols.match.Bool3DGrid) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- actual_bb(...) from builtins.PyCapsule
- actual_bb(rosetta.protocols.match.Bool3DGrid) -> rosetta.numeric.geometry.BoundingBox_numeric_xyzVector_double_t
- and_with(...) from builtins.PyCapsule
- and_with(self : rosetta.protocols.match.Bool3DGrid, other : rosetta.protocols.match.Bool3DGrid) -> NoneType
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.
- assign(...) from builtins.PyCapsule
- assign(self : rosetta.protocols.match.Bool3DGrid, : rosetta.protocols.match.Bool3DGrid) -> rosetta.protocols.match.Bool3DGrid
- bin_center(...) from builtins.PyCapsule
- bin_center(self : rosetta.protocols.match.Bool3DGrid, bin : rosetta.utility.fixedsizearray1_unsigned_long_3_t) -> rosetta.numeric.xyzVector_double_t
- bin_extrema(...) from builtins.PyCapsule
- bin_extrema(self : rosetta.protocols.match.Bool3DGrid, bin : rosetta.utility.fixedsizearray1_unsigned_long_3_t) -> rosetta.numeric.geometry.BoundingBox_numeric_xyzVector_double_t
bounding box points for a bin.
- bin_width(...) from builtins.PyCapsule
- bin_width(rosetta.protocols.match.Bool3DGrid) -> float
- clear(...) from builtins.PyCapsule
- clear(rosetta.protocols.match.Bool3DGrid) -> NoneType
Set all values in all bins to false
- create_grid_for_bb(...) from builtins.PyCapsule
- create_grid_for_bb(self : rosetta.protocols.match.Bool3DGrid, bb : rosetta.numeric.geometry.BoundingBox_numeric_xyzVector_double_t) -> rosetta.protocols.match.Bool3DGrid
create a grid for the input bounding box that aligns to this grid
- create_grid_for_sphere(...) from builtins.PyCapsule
- create_grid_for_sphere(self : rosetta.protocols.match.Bool3DGrid, center : rosetta.numeric.xyzVector_double_t, radius : float) -> 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.
- dimsizes(...) from builtins.PyCapsule
- dimsizes(rosetta.protocols.match.Bool3DGrid) -> rosetta.utility.fixedsizearray1_unsigned_long_3_t
Accessors
- occupied(...) from builtins.PyCapsule
- occupied(*args, **kwargs)
Overloaded function.
1. occupied(self : rosetta.protocols.match.Bool3DGrid, : rosetta.numeric.xyzVector_double_t) -> bool
2. occupied(self : rosetta.protocols.match.Bool3DGrid, bin : rosetta.utility.fixedsizearray1_unsigned_long_3_t) -> bool
- or_by_box_liberal(...) from builtins.PyCapsule
- or_by_box_liberal(self : rosetta.protocols.match.Bool3DGrid, bb : rosetta.numeric.geometry.BoundingBox_numeric_xyzVector_double_t) -> NoneType
/
Turn the values of all the bins that overlap with the
volume in this bounding box to true.
- or_by_sphere_conservative(...) from builtins.PyCapsule
- or_by_sphere_conservative(self : rosetta.protocols.match.Bool3DGrid, center : rosetta.numeric.xyzVector_double_t, radius : float) -> NoneType
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.
- or_by_sphere_liberal(...) from builtins.PyCapsule
- or_by_sphere_liberal(self : rosetta.protocols.match.Bool3DGrid, center : rosetta.numeric.xyzVector_double_t, radius : float) -> NoneType
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.
- or_by_spheres_conservative(...) from builtins.PyCapsule
- or_by_spheres_conservative(self : rosetta.protocols.match.Bool3DGrid, spheres : rosetta.utility.vector1_std_pair_numeric_xyzVector_double_double_t) -> NoneType
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.
- or_with(...) from builtins.PyCapsule
- or_with(self : rosetta.protocols.match.Bool3DGrid, other : rosetta.protocols.match.Bool3DGrid) -> NoneType
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.
- set_bin_width(...) from builtins.PyCapsule
- set_bin_width(self : rosetta.protocols.match.Bool3DGrid, width : float) -> NoneType
- set_bounding_box(...) from builtins.PyCapsule
- set_bounding_box(self : rosetta.protocols.match.Bool3DGrid, bb : rosetta.numeric.geometry.BoundingBox_numeric_xyzVector_double_t) -> NoneType
- set_value_for_bin(...) from builtins.PyCapsule
- set_value_for_bin(self : rosetta.protocols.match.Bool3DGrid, bin : rosetta.utility.fixedsizearray1_unsigned_long_3_t, setting : bool) -> NoneType
set the boolean value for a particular bin.
The bin dimensions are indexed from 0 to nbins-1.
- subtract(...) from builtins.PyCapsule
- subtract(self : rosetta.protocols.match.Bool3DGrid, other : rosetta.protocols.match.Bool3DGrid) -> NoneType
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".
|
class Bool3DGridKinemageWriter(builtins.object) |
| | |
Methods defined here:
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(rosetta.protocols.match.Bool3DGridKinemageWriter) -> NoneType
2. __init__(self : rosetta.protocols.match.Bool3DGridKinemageWriter, : rosetta.protocols.match.Bool3DGridKinemageWriter) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- assign(...) from builtins.PyCapsule
- assign(self : rosetta.protocols.match.Bool3DGridKinemageWriter, : rosetta.protocols.match.Bool3DGridKinemageWriter) -> rosetta.protocols.match.Bool3DGridKinemageWriter
- set_empty_voxel_color(...) from builtins.PyCapsule
- set_empty_voxel_color(self : rosetta.protocols.match.Bool3DGridKinemageWriter, empty_voxel_color_ : str) -> NoneType
- set_facet_alpha(...) from builtins.PyCapsule
- set_facet_alpha(self : rosetta.protocols.match.Bool3DGridKinemageWriter, facet_alpha : float) -> NoneType
- set_facet_color(...) from builtins.PyCapsule
- set_facet_color(self : rosetta.protocols.match.Bool3DGridKinemageWriter, facet_color : str) -> NoneType
- set_facet_master(...) from builtins.PyCapsule
- set_facet_master(self : rosetta.protocols.match.Bool3DGridKinemageWriter, facet_master : str) -> NoneType
- set_line_color(...) from builtins.PyCapsule
- set_line_color(self : rosetta.protocols.match.Bool3DGridKinemageWriter, line_color : str) -> NoneType
- set_master(...) from builtins.PyCapsule
- set_master(self : rosetta.protocols.match.Bool3DGridKinemageWriter, master : str) -> NoneType
- set_shrink_factor(...) from builtins.PyCapsule
- set_shrink_factor(self : rosetta.protocols.match.Bool3DGridKinemageWriter, shrink_factor : float) -> NoneType
- set_skip_completely_buried_positions(...) from builtins.PyCapsule
- set_skip_completely_buried_positions(self : rosetta.protocols.match.Bool3DGridKinemageWriter, skip_completely_buried_positions : bool) -> NoneType
- set_transparent_facets(...) from builtins.PyCapsule
- set_transparent_facets(self : rosetta.protocols.match.Bool3DGridKinemageWriter, transparent_facets : bool) -> NoneType
- set_unselectable(...) from builtins.PyCapsule
- set_unselectable(self : rosetta.protocols.match.Bool3DGridKinemageWriter, unselectable : bool) -> NoneType
- set_write_empty_voxels(...) from builtins.PyCapsule
- set_write_empty_voxels(self : rosetta.protocols.match.Bool3DGridKinemageWriter, write_empty_voxels_ : bool) -> NoneType
- set_write_facets(...) from builtins.PyCapsule
- set_write_facets(self : rosetta.protocols.match.Bool3DGridKinemageWriter, write_facets : bool) -> NoneType
- write_grid_to_file(...) from builtins.PyCapsule
- write_grid_to_file(self : rosetta.protocols.match.Bool3DGridKinemageWriter, fname : str, group_name : str, grid : rosetta.protocols.match.Bool3DGrid) -> NoneType
|
class BumpGrid(builtins.object) |
| | |
Methods defined here:
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(rosetta.protocols.match.BumpGrid) -> NoneType
2. __init__(self : rosetta.protocols.match.BumpGrid, : rosetta.protocols.match.BumpGrid) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- and_with(...) from builtins.PyCapsule
- and_with(self : rosetta.protocols.match.BumpGrid, : rosetta.protocols.match.BumpGrid) -> NoneType
- assign(...) from builtins.PyCapsule
- assign(self : rosetta.protocols.match.BumpGrid, : rosetta.protocols.match.BumpGrid) -> rosetta.protocols.match.BumpGrid
- create_bump_grid_for_bb(...) from builtins.PyCapsule
- create_bump_grid_for_bb(self : rosetta.protocols.match.BumpGrid, bb : rosetta.numeric.geometry.BoundingBox_numeric_xyzVector_double_t) -> rosetta.protocols.match.BumpGrid
- create_new_bump_grid_for_bb(...) from builtins.PyCapsule
- create_new_bump_grid_for_bb(self : rosetta.protocols.match.BumpGrid, bb : rosetta.numeric.geometry.BoundingBox_numeric_xyzVector_double_t) -> rosetta.protocols.match.BumpGrid
- grid(...) from builtins.PyCapsule
- grid(self : rosetta.protocols.match.BumpGrid, radtype : rosetta.protocols.match.ProbeRadius) -> rosetta.protocols.match.Bool3DGrid
- occupied(...) from builtins.PyCapsule
- occupied(self : rosetta.protocols.match.BumpGrid, radius_type : rosetta.protocols.match.ProbeRadius, p : 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.
- or_by_sphere(...) from builtins.PyCapsule
- or_by_sphere(*args, **kwargs)
Overloaded function.
1. or_by_sphere(self : rosetta.protocols.match.BumpGrid, : (rosetta.numeric.xyzVector_double_t, float)) -> NoneType
2. or_by_sphere(self : rosetta.protocols.match.BumpGrid, center : rosetta.numeric.xyzVector_double_t, radius_type : rosetta.protocols.match.ProbeRadius) -> NoneType
- or_with(...) from builtins.PyCapsule
- or_with(self : rosetta.protocols.match.BumpGrid, : rosetta.protocols.match.BumpGrid) -> NoneType
- overlaps(...) from builtins.PyCapsule
- overlaps(self : rosetta.protocols.match.BumpGrid, : rosetta.protocols.match.BumpGrid) -> bool
- pair_overlap_tolerance(...) from builtins.PyCapsule
- pair_overlap_tolerance(self : rosetta.protocols.match.BumpGrid, rad1 : rosetta.protocols.match.ProbeRadius, rad2 : rosetta.protocols.match.ProbeRadius) -> float
- probe_radius(...) from builtins.PyCapsule
- probe_radius(radtype : rosetta.protocols.match.ProbeRadius) -> float
- required_separation_distance(...) from builtins.PyCapsule
- required_separation_distance(self : rosetta.protocols.match.BumpGrid, rad1 : rosetta.protocols.match.ProbeRadius, rad2 : rosetta.protocols.match.ProbeRadius) -> float
- set_bounding_box(...) from builtins.PyCapsule
- set_bounding_box(self : rosetta.protocols.match.BumpGrid, bb : rosetta.numeric.geometry.BoundingBox_numeric_xyzVector_double_t) -> NoneType
Initialization
- set_general_overlap_tolerance(...) from builtins.PyCapsule
- set_general_overlap_tolerance(self : rosetta.protocols.match.BumpGrid, tolerated_overlap : float) -> NoneType
/
Set the tolerance for sphere overlap between all sphere types.
All tolerances must be set *before* any spheres are ORed into the grid.
- set_pair_overlap_tolerance(...) from builtins.PyCapsule
- set_pair_overlap_tolerance(self : rosetta.protocols.match.BumpGrid, rad1 : rosetta.protocols.match.ProbeRadius, rad2 : rosetta.protocols.match.ProbeRadius, tolerated_overlap : float) -> NoneType
/
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.
|
class HitHasher(builtins.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.
|
| |
Methods defined here:
- __init__(...) from builtins.PyCapsule
- __init__(rosetta.protocols.match.HitHasher) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- assign(...) from builtins.PyCapsule
- assign(self : rosetta.protocols.match.HitHasher, : rosetta.protocols.match.HitHasher) -> rosetta.protocols.match.HitHasher
- binner(...) from builtins.PyCapsule
- binner(self : rosetta.protocols.match.HitHasher, which_hash_map : int) -> rosetta.numeric.geometry.hashing.SixDCoordinateBinner
- clear_hash_map(...) from builtins.PyCapsule
- clear_hash_map(self : rosetta.protocols.match.HitHasher, which_hash_map : int) -> NoneType
- initialize(...) from builtins.PyCapsule
- initialize(rosetta.protocols.match.HitHasher) -> NoneType
- insert_hit(...) from builtins.PyCapsule
- insert_hit(*args, **kwargs)
Overloaded function.
1. insert_hit(self : rosetta.protocols.match.HitHasher, geometric_constraint_id : int, hit : rosetta.protocols.match.Hit) -> NoneType
Insert a hits into all 64 hash maps
2. insert_hit(self : rosetta.protocols.match.HitHasher, which_hash_map : int, geometric_constraint_id : int, hit : rosetta.protocols.match.Hit) -> NoneType
Insert a hits into a particular hash maps
- set_bounding_box(...) from builtins.PyCapsule
- set_bounding_box(self : rosetta.protocols.match.HitHasher, bb : rosetta.numeric.geometry.BoundingBox_numeric_xyzVector_double_t) -> NoneType
- set_euler_bin_widths(...) from builtins.PyCapsule
- set_euler_bin_widths(self : rosetta.protocols.match.HitHasher, euler_bin_widths : rosetta.numeric.xyzVector_double_t) -> NoneType
- set_nhits_per_match(...) from builtins.PyCapsule
- set_nhits_per_match(self : rosetta.protocols.match.HitHasher, num_geometric_constraints : int) -> NoneType
- set_uniform_euler_angle_bin_width(...) from builtins.PyCapsule
- set_uniform_euler_angle_bin_width(self : rosetta.protocols.match.HitHasher, bin_width_degrees : float) -> NoneType
- set_uniform_xyz_bin_width(...) from builtins.PyCapsule
- set_uniform_xyz_bin_width(self : rosetta.protocols.match.HitHasher, bin_width : float) -> NoneType
- set_xyz_bin_widths(...) from builtins.PyCapsule
- set_xyz_bin_widths(self : rosetta.protocols.match.HitHasher, bin_widths : rosetta.numeric.xyzVector_double_t) -> NoneType
|
class MatchCounter(builtins.object) |
| |
Class for counting the number of matches given a particular discretization level.
|
| |
Methods defined here:
- __init__(...) from builtins.PyCapsule
- __init__(rosetta.protocols.match.MatchCounter) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- add_hits(...) from builtins.PyCapsule
- add_hits(self : rosetta.protocols.match.MatchCounter, geomcst_id : int, hitlist : rosetta.std.list_protocols_match_Hit_std_allocator_protocols_match_Hit_t) -> NoneType
Add hits from a list of hits for a particular geometric constraint.
- assign(...) from builtins.PyCapsule
- assign(self : rosetta.protocols.match.MatchCounter, : rosetta.protocols.match.MatchCounter) -> rosetta.protocols.match.MatchCounter
- count_n_matches(...) from builtins.PyCapsule
- count_n_matches(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).
- initialize(...) from builtins.PyCapsule
- initialize(rosetta.protocols.match.MatchCounter) -> NoneType
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.
- set_bounding_box(...) from builtins.PyCapsule
- set_bounding_box(self : rosetta.protocols.match.MatchCounter, bb : rosetta.numeric.geometry.BoundingBox_numeric_xyzVector_double_t) -> NoneType
Use the same bounding box as the HitHasher / OccupiedSpaceHash
- set_euler_bin_widths(...) from builtins.PyCapsule
- set_euler_bin_widths(self : rosetta.protocols.match.MatchCounter, euler_bin_widths : rosetta.numeric.xyzVector_double_t) -> NoneType
Give the same euler-angle bin witdhs given to the HitHasher / OccupiedSpaceHash.
- set_n_geometric_constraints(...) from builtins.PyCapsule
- set_n_geometric_constraints(self : rosetta.protocols.match.MatchCounter, ngeomcsts : int) -> NoneType
- set_uniform_euler_angle_bin_width(...) from builtins.PyCapsule
- set_uniform_euler_angle_bin_width(self : rosetta.protocols.match.MatchCounter, bin_width_degrees : float) -> NoneType
Give the same euler-angle bin witdh given to the HitHasher / OccupiedSpaceHash.
- set_uniform_xyz_bin_width(...) from builtins.PyCapsule
- set_uniform_xyz_bin_width(self : rosetta.protocols.match.MatchCounter, bin_width : float) -> NoneType
Give the same xyz bin witdh given to the HitHasher / OccupiedSpaceHash.
- set_xyz_bin_widths(...) from builtins.PyCapsule
- set_xyz_bin_widths(self : rosetta.protocols.match.MatchCounter, bin_widths : rosetta.numeric.xyzVector_double_t) -> NoneType
Give the same xyz bin witdhs given to the HitHasher / OccupiedSpaceHash.
|
class Matcher(builtins.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.
|
| |
Methods defined here:
- __init__(...) from builtins.PyCapsule
- __init__(rosetta.protocols.match.Matcher) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- add_external_geometry_samples_for_constraint(...) from builtins.PyCapsule
- add_external_geometry_samples_for_constraint(*args, **kwargs)
Overloaded function.
1. add_external_geometry_samples_for_constraint(self : rosetta.protocols.match.Matcher, cst_id : int, restype : rosetta.core.chemical.ResidueType, upstream_launch_atoms : rosetta.utility.vector1_std_string, downstream_3atoms : rosetta.utility.vector1_core_id_AtomID, exgeom : protocols::toolbox::match_enzdes_util::ExternalGeomSampler, exgeom_id : int) -> NoneType
2. add_external_geometry_samples_for_constraint(self : rosetta.protocols.match.Matcher, cst_id : int, restype : rosetta.core.chemical.ResidueType, upstream_launch_atoms : rosetta.utility.vector1_std_string, downstream_3atoms : rosetta.utility.vector1_core_id_AtomID, exgeom : protocols::toolbox::match_enzdes_util::ExternalGeomSampler, exgeom_id : int, enumerate_ligand_rotamers : bool) -> NoneType
3. add_external_geometry_samples_for_constraint(self : rosetta.protocols.match.Matcher, cst_id : int, restype : rosetta.core.chemical.ResidueType, upstream_launch_atoms : rosetta.utility.vector1_std_string, downstream_3atoms : rosetta.utility.vector1_core_id_AtomID, exgeom : protocols::toolbox::match_enzdes_util::ExternalGeomSampler, exgeom_id : int, enumerate_ligand_rotamers : bool, catalytic_bond : bool) -> NoneType
4. add_external_geometry_samples_for_constraint(self : rosetta.protocols.match.Matcher, cst_id : int, restype : rosetta.core.chemical.ResidueType, upstream_launch_atoms : rosetta.utility.vector1_std_string, downstream_3atoms : rosetta.utility.vector1_core_id_AtomID, exgeom : protocols::toolbox::match_enzdes_util::ExternalGeomSampler, exgeom_id : int, enumerate_ligand_rotamers : bool, catalytic_bond : bool, build_round1_hits_twice : bool) -> NoneType
- add_secondary_downstream_match_geometry_for_constraint(...) from builtins.PyCapsule
- add_secondary_downstream_match_geometry_for_constraint(self : rosetta.protocols.match.Matcher, geom_cst_id : int, candidate_restype : rosetta.core.chemical.ResidueType, downstream_restype : rosetta.core.chemical.ResidueType, candidate_atids : rosetta.utility.vector1_unsigned_long, target_atids : rosetta.utility.vector1_unsigned_long, mcfi : protocols::toolbox::match_enzdes_util::MatchConstraintFileInfo, SecMatchStr : str, upstream_pose : rosetta.core.pose.Pose, catalytic_bond : bool) -> NoneType
- add_secondary_upstream_match_geometry_for_constraint(...) from builtins.PyCapsule
- add_secondary_upstream_match_geometry_for_constraint(self : rosetta.protocols.match.Matcher, geom_cst_id : int, target_geom_cst_id : int, candidate_restype : rosetta.core.chemical.ResidueType, target_restype : rosetta.core.chemical.ResidueType, candidate_atids : rosetta.utility.vector1_unsigned_long, target_atids : rosetta.utility.vector1_unsigned_long, mcfi : protocols::toolbox::match_enzdes_util::MatchConstraintFileInfo, SecMatchStr : str, upstream_pose : rosetta.core.pose.Pose) -> NoneType
- add_upstream_restype_for_constraint(...) from builtins.PyCapsule
- add_upstream_restype_for_constraint(self : rosetta.protocols.match.Matcher, cst_id : int, restype : rosetta.core.chemical.ResidueType) -> NoneType
- build_point(...) from builtins.PyCapsule
- build_point(*args, **kwargs)
Overloaded function.
1. build_point(self : rosetta.protocols.match.Matcher, index : int) -> protocols::match::upstream::ScaffoldBuildPoint
2. build_point(self : rosetta.protocols.match.Matcher, index : int) -> protocols::match::upstream::ScaffoldBuildPoint
Non-const access
- desymmeterize_upstream_restype_for_constraint(...) from builtins.PyCapsule
- desymmeterize_upstream_restype_for_constraint(self : rosetta.protocols.match.Matcher, cst_id : int) -> NoneType
- downstream_builder(...) from builtins.PyCapsule
- downstream_builder(*args, **kwargs)
Overloaded function.
1. downstream_builder(self : rosetta.protocols.match.Matcher, cst_id : int) -> protocols::match::downstream::DownstreamBuilder
Return const access to a representative downstream builder for a particular
geometric constraint. All downstream builders for a single geometric constraint
are required to behave the same when reconstructing the coordinates of the downstream
partner from a hit; therefore, a single representative is sufficient to recover
hit coordinates for any hit from a particular geometric constraint.
2. downstream_builder(self : rosetta.protocols.match.Matcher, : int) -> protocols::match::downstream::DownstreamBuilder
Return non-const access to a representative downstream builder
for a particular geometric constraint
- downstream_builders(...) from builtins.PyCapsule
- downstream_builders(self : rosetta.protocols.match.Matcher, cst_id : int) -> rosetta.std.list_std_shared_ptr_protocols_match_downstream_DownstreamBuilder_std_allocator_std_shared_ptr_protocols_match_downstream_DownstreamBuilder_t
Return non-const access to all of the downstream builders
for a particular geometric constraint
- downstream_pose(...) from builtins.PyCapsule
- downstream_pose(rosetta.protocols.match.Matcher) -> rosetta.core.pose.Pose
- erase_hit(...) from builtins.PyCapsule
- erase_hit(self : rosetta.protocols.match.Matcher, dsalg : protocols::match::downstream::DownstreamAlgorithm, geom_cst_id_for_hit : int, iter : std::_List_iterator<protocols::match::Hit>) -> NoneType
To be invoked by a downstream algorithm. Downstream algorithms may prune their
old, inviable hits, through this method -- they should pass themselves in as an argument
-- and they may also prune this hits for other rounds.
If the should prune other-round hits, then they will trigger an update to the
hit_lists_with_primary_modificiations_ list, leading to an additional pass over the
geometric constraints in a primary/peripheral pattern.
- find_hits(...) from builtins.PyCapsule
- find_hits(rosetta.protocols.match.Matcher) -> bool
Main worker function
- get_pose_build_resids(...) from builtins.PyCapsule
- get_pose_build_resids(rosetta.protocols.match.Matcher) -> rosetta.utility.vector1_unsigned_long
- has_upstream_only_geomcsts(...) from builtins.PyCapsule
- has_upstream_only_geomcsts(rosetta.protocols.match.Matcher) -> bool
- hit_list_begin(...) from builtins.PyCapsule
- hit_list_begin(self : rosetta.protocols.match.Matcher, geom_cst_id : int) -> std::_List_iterator<protocols::match::Hit>
Return a non-constant iterator to a HitList for a particular geometric constraint.
DANGER DANGER DANGER.
This access is intended to allow a DownstreamAlgorithm to delete its own non-viable hits
and also to allow a DownstreamAlgorithm to delete another algorithm's non-viable hits;
Actual deletion requires invoking the method Matcher::erase_hit().
This non-const access is not intended for any other class.
- hit_list_end(...) from builtins.PyCapsule
- hit_list_end(self : rosetta.protocols.match.Matcher, geom_cst_id : int) -> std::_List_iterator<protocols::match::Hit>
Return a non-constant iterator to the end position for a
HitList for a particular geometric constraint. See comments for hit_list_begin()
- hits(...) from builtins.PyCapsule
- hits(self : rosetta.protocols.match.Matcher, cst_id : int) -> rosetta.std.list_protocols_match_Hit_std_allocator_protocols_match_Hit_t
- initialize_from_file(...) from builtins.PyCapsule
- initialize_from_file(self : rosetta.protocols.match.Matcher, enz_data : rosetta.protocols.toolbox.match_enzdes_util.EnzConstraintIO, task : protocols::match::MatcherTask) -> NoneType
Intialize the geometric constraints from the EnzConstraionIO object.
- initialize_from_task(...) from builtins.PyCapsule
- initialize_from_task(self : rosetta.protocols.match.Matcher, task : protocols::match::MatcherTask) -> NoneType
The primary way to initialize a Matcher is through a MatcherTask.
- n_geometric_constraints(...) from builtins.PyCapsule
- n_geometric_constraints(rosetta.protocols.match.Matcher) -> int
- nonconst_downstream_algorithms(...) from builtins.PyCapsule
- nonconst_downstream_algorithms(self : rosetta.protocols.match.Matcher, cst_id : int) -> rosetta.std.list_std_shared_ptr_protocols_match_downstream_DownstreamAlgorithm_std_allocator_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.
- occ_space_hash(...) from builtins.PyCapsule
- occ_space_hash(*args, **kwargs)
Overloaded function.
1. occ_space_hash(rosetta.protocols.match.Matcher) -> protocols::match::OccupiedSpaceHash
2. occ_space_hash(rosetta.protocols.match.Matcher) -> protocols::match::OccupiedSpaceHash
- process_matches(...) from builtins.PyCapsule
- process_matches(self : rosetta.protocols.match.Matcher, processor : protocols::match::output::MatchProcessor) -> NoneType
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.
- representative_downstream_algorithm(...) from builtins.PyCapsule
- representative_downstream_algorithm(self : rosetta.protocols.match.Matcher, cst_id : int) -> protocols::match::downstream::DownstreamAlgorithm
- set_bump_tolerance(...) from builtins.PyCapsule
- set_bump_tolerance(self : rosetta.protocols.match.Matcher, permitted_overlap : float) -> NoneType
- set_downstream_pose(...) from builtins.PyCapsule
- set_downstream_pose(self : rosetta.protocols.match.Matcher, pose : rosetta.core.pose.Pose, orientation_atoms : rosetta.utility.vector1_core_id_AtomID) -> NoneType
- set_fa_dun_cutoff_for_constraint(...) from builtins.PyCapsule
- set_fa_dun_cutoff_for_constraint(self : rosetta.protocols.match.Matcher, cst_id : int, restype : rosetta.core.chemical.ResidueType, fa_dun_cutoff : float) -> NoneType
- set_hash_euclidean_bin_width(...) from builtins.PyCapsule
- set_hash_euclidean_bin_width(self : rosetta.protocols.match.Matcher, width : float) -> NoneType
- set_hash_euclidean_bin_widths(...) from builtins.PyCapsule
- set_hash_euclidean_bin_widths(self : rosetta.protocols.match.Matcher, widths : rosetta.numeric.xyzVector_double_t) -> NoneType
- set_hash_euler_bin_width(...) from builtins.PyCapsule
- set_hash_euler_bin_width(self : rosetta.protocols.match.Matcher, width : float) -> NoneType
- set_hash_euler_bin_widths(...) from builtins.PyCapsule
- set_hash_euler_bin_widths(self : rosetta.protocols.match.Matcher, widths : rosetta.numeric.xyzVector_double_t) -> NoneType
- set_n_geometric_constraints(...) from builtins.PyCapsule
- set_n_geometric_constraints(self : rosetta.protocols.match.Matcher, n_constraints : int) -> NoneType
- set_occupied_space_bounding_box(...) from builtins.PyCapsule
- set_occupied_space_bounding_box(self : rosetta.protocols.match.Matcher, bb : rosetta.numeric.geometry.BoundingBox_numeric_xyzVector_double_t) -> NoneType
- set_original_scaffold_build_points(...) from builtins.PyCapsule
- set_original_scaffold_build_points(self : rosetta.protocols.match.Matcher, resids : rosetta.utility.vector1_unsigned_long) -> NoneType
- set_original_scaffold_build_points_for_constraint(...) from builtins.PyCapsule
- set_original_scaffold_build_points_for_constraint(self : rosetta.protocols.match.Matcher, cst_id : int, resids : rosetta.utility.vector1_unsigned_long) -> NoneType
- set_sample_startegy_for_constraint(...) from builtins.PyCapsule
- set_sample_startegy_for_constraint(self : rosetta.protocols.match.Matcher, cst_id : int, restype : rosetta.core.chemical.ResidueType, chi : int, strat : protocols::match::upstream::SampleStrategyData) -> NoneType
- set_upstream_pose(...) from builtins.PyCapsule
- set_upstream_pose(self : rosetta.protocols.match.Matcher, pose : rosetta.core.pose.Pose) -> NoneType
Setup
- upstream_builder(...) from builtins.PyCapsule
- upstream_builder(*args, **kwargs)
Overloaded function.
1. upstream_builder(self : rosetta.protocols.match.Matcher, cst_id : int) -> protocols::match::upstream::UpstreamBuilder
2. upstream_builder(self : rosetta.protocols.match.Matcher, cst_id : int) -> protocols::match::upstream::UpstreamBuilder
- upstream_pose(...) from builtins.PyCapsule
- upstream_pose(rosetta.protocols.match.Matcher) -> rosetta.core.pose.Pose
Data accessors
|
class MatcherMover(rosetta.protocols.rosetta_scripts.MultiplePoseMover) |
| | |
- Method resolution order:
- MatcherMover
- rosetta.protocols.rosetta_scripts.MultiplePoseMover
- rosetta.protocols.moves.Mover
- builtins.object
Methods defined here:
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(handle) -> NoneType
doc
2. __init__(self : handle, incorporate_matches_into_pose : bool) -> NoneType
3. __init__(handle, rosetta.protocols.match.MatcherMover) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- apply(...) from builtins.PyCapsule
- apply(self : rosetta.protocols.match.MatcherMover, pose : rosetta.core.pose.Pose) -> NoneType
- clone(...) from builtins.PyCapsule
- clone(rosetta.protocols.match.MatcherMover) -> rosetta.protocols.moves.Mover
clone this object
- fresh_instance(...) from builtins.PyCapsule
- fresh_instance(rosetta.protocols.match.MatcherMover) -> rosetta.protocols.moves.Mover
create this type of object
- get_name(...) from builtins.PyCapsule
- get_name(rosetta.protocols.match.MatcherMover) -> str
- set_ligres(...) from builtins.PyCapsule
- set_ligres(self : rosetta.protocols.match.MatcherMover, ligres : rosetta.core.conformation.Residue) -> NoneType
- set_match_positions(...) from builtins.PyCapsule
- set_match_positions(self : rosetta.protocols.match.MatcherMover, match_positions : rosetta.utility.vector1_unsigned_long) -> NoneType
- set_return_single_random_match(...) from builtins.PyCapsule
- set_return_single_random_match(self : rosetta.protocols.match.MatcherMover, single_random : bool) -> NoneType
if set to true, a single random match will be returned.
The default behavior is to use the MultiplePoseMover framework
to return all matches
Methods inherited from rosetta.protocols.rosetta_scripts.MultiplePoseMover:
- get_additional_output(...) from builtins.PyCapsule
- get_additional_output(rosetta.protocols.rosetta_scripts.MultiplePoseMover) -> rosetta.core.pose.Pose
- set_previous_mover(...) from builtins.PyCapsule
- set_previous_mover(self : rosetta.protocols.rosetta_scripts.MultiplePoseMover, m : rosetta.protocols.moves.Mover) -> NoneType
Used by RosettaScripts to set the previous mover to pull poses from
- set_rosetta_scripts_tag(...) from builtins.PyCapsule
- set_rosetta_scripts_tag(self : rosetta.protocols.rosetta_scripts.MultiplePoseMover, tag : rosetta.utility.tag.Tag) -> NoneType
sets rosettascripts tag
Methods inherited from rosetta.protocols.moves.Mover:
- assign(...) from builtins.PyCapsule
- assign(self : rosetta.protocols.moves.Mover, other : rosetta.protocols.moves.Mover) -> rosetta.protocols.moves.Mover
- clear_info(...) from builtins.PyCapsule
- clear_info(rosetta.protocols.moves.Mover) -> NoneType
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
- create(...) from builtins.PyCapsule
- create(rosetta.protocols.moves.Mover) -> rosetta.protocols.moves.Mover
- get_current_job(...) from builtins.PyCapsule
- get_current_job(rosetta.protocols.moves.Mover) -> protocols::jobdist::BasicJob
- get_current_tag(...) from builtins.PyCapsule
- get_current_tag(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.
- get_input_pose(...) from builtins.PyCapsule
- get_input_pose(rosetta.protocols.moves.Mover) -> rosetta.core.pose.Pose
- get_last_move_status(...) from builtins.PyCapsule
- get_last_move_status(rosetta.protocols.moves.Mover) -> 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.
- get_native_pose(...) from builtins.PyCapsule
- get_native_pose(rosetta.protocols.moves.Mover) -> rosetta.core.pose.Pose
- get_self_ptr(...) from builtins.PyCapsule
- get_self_ptr(*args, **kwargs)
Overloaded function.
1. get_self_ptr(rosetta.protocols.moves.Mover) -> rosetta.protocols.moves.Mover
2. get_self_ptr(rosetta.protocols.moves.Mover) -> rosetta.protocols.moves.Mover
- get_self_weak_ptr(...) from builtins.PyCapsule
- get_self_weak_ptr(*args, **kwargs)
Overloaded function.
1. get_self_weak_ptr(rosetta.protocols.moves.Mover) -> rosetta.std.weak_ptr_const_protocols_moves_Mover_t
2. get_self_weak_ptr(rosetta.protocols.moves.Mover) -> rosetta.std.weak_ptr_protocols_moves_Mover_t
- get_type(...) from builtins.PyCapsule
- get_type(rosetta.protocols.moves.Mover) -> str
- info(...) from builtins.PyCapsule
- info(*args, **kwargs)
Overloaded function.
1. info(rosetta.protocols.moves.Mover) -> rosetta.std.list_std_string_std_allocator_std_string_t
non-const accessor
2. info(rosetta.protocols.moves.Mover) -> rosetta.std.list_std_string_std_allocator_std_string_t
const accessor
- last_proposal_density_ratio(...) from builtins.PyCapsule
- last_proposal_density_ratio(rosetta.protocols.moves.Mover) -> float
- name(...) from builtins.PyCapsule
- name() -> str
- register_options(...) from builtins.PyCapsule
- register_options(*args, **kwargs)
Overloaded function.
1. register_options() -> NoneType
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.
2. register_options() -> NoneType
3. register_options() -> NoneType
4. register_options() -> NoneType
5. register_options() -> NoneType
6. register_options() -> NoneType
7. register_options() -> NoneType
8. register_options() -> NoneType
9. register_options() -> NoneType
Associates relevant options with the AntibodyModeler class
10. register_options() -> NoneType
Associates relevant options with the AntibodyModeler class
11. register_options() -> NoneType
Associates relevant options with the SnugDock class
12. register_options() -> NoneType
Associates relevant options with the SnugDockProtocol class
13. register_options() -> NoneType
Register the options used by this mover with the global options
system.
14. register_options() -> NoneType
15. register_options() -> NoneType
Associate relevant options with the TemperedDocking class.
16. register_options() -> NoneType
17. register_options() -> NoneType
18. register_options() -> NoneType
Associates relevant options with the TemperedDocking class.
19. register_options() -> NoneType
20. register_options() -> NoneType
Associates relevant options with the ConstraintSetMover class
21. register_options() -> NoneType
22. register_options() -> NoneType
Associates relevant options with the DockingInitialPerturbation class
23. register_options() -> NoneType
Associates relevant options with the DockingProtocol class
24. register_options() -> NoneType
Associates relevant options with the TemperedDocking class
25. register_options() -> NoneType
26. register_options() -> NoneType
27. register_options() -> NoneType
28. register_options() -> NoneType
register options
29. register_options() -> NoneType
30. register_options() -> NoneType
Registers applicable options
31. register_options() -> NoneType
Register options with the option system.
32. register_options() -> NoneType
33. register_options() -> NoneType
34. register_options() -> NoneType
Associates relevant options with the LoopRefineInnerCycle class
35. register_options() -> NoneType
Associates relevant options with the LoopRefineInnerCycleContainer class
36. register_options() -> NoneType
Associates relevant options with the LoopRefineInnerCycle class
37. register_options() -> NoneType
Associates relevant options with the LoopRefineInnerCycle class
38. register_options() -> NoneType
39. register_options() -> NoneType
Register options with the option system.
40. register_options() -> NoneType
- reinitialize_for_each_job(...) from builtins.PyCapsule
- reinitialize_for_each_job(rosetta.protocols.moves.Mover) -> bool
Inform the Job Distributor (August '08 vintage) whether this object needs to be freshly regenerated on
each use.
- reinitialize_for_new_input(...) from builtins.PyCapsule
- reinitialize_for_new_input(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).
- reset_status(...) from builtins.PyCapsule
- reset_status(rosetta.protocols.moves.Mover) -> NoneType
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.
- set_current_job(...) from builtins.PyCapsule
- set_current_job(self : rosetta.protocols.moves.Mover, job : protocols::jobdist::BasicJob) -> NoneType
////////////////////////////end Job Distributor interface////////////////////////////////////////
- set_current_tag(...) from builtins.PyCapsule
- set_current_tag(self : rosetta.protocols.moves.Mover, new_tag : str) -> NoneType
- set_input_pose(...) from builtins.PyCapsule
- set_input_pose(self : rosetta.protocols.moves.Mover, pose : rosetta.core.pose.Pose) -> NoneType
setter for poses contained for rms
- set_native_pose(...) from builtins.PyCapsule
- set_native_pose(self : rosetta.protocols.moves.Mover, pose : rosetta.core.pose.Pose) -> NoneType
setter for native poses contained for rms ---- we should get rid of this method? it is widely used, but a bit unsafe
- set_type(...) from builtins.PyCapsule
- set_type(self : rosetta.protocols.moves.Mover, setting : str) -> NoneType
- test_move(...) from builtins.PyCapsule
- test_move(self : rosetta.protocols.moves.Mover, pose : rosetta.core.pose.Pose) -> NoneType
: Unit test support function. Apply one move to a given pose.
Allows extra test specific functions to be called before applying
- type(...) from builtins.PyCapsule
- type(*args, **kwargs)
Overloaded function.
1. type(rosetta.protocols.moves.Mover) -> str
2. type(self : rosetta.protocols.moves.Mover, type_in : str) -> NoneType
|
class MatcherTask(builtins.object) |
| | |
Methods defined here:
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(rosetta.protocols.match.MatcherTask) -> NoneType
2. __init__(self : rosetta.protocols.match.MatcherTask, other : rosetta.protocols.match.MatcherTask) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- add_filter(...) from builtins.PyCapsule
- add_filter(self : rosetta.protocols.match.MatcherTask, filter_name : str) -> NoneType
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.
- append_downstream_atom_to_active_site_required_list(...) from builtins.PyCapsule
- append_downstream_atom_to_active_site_required_list(self : rosetta.protocols.match.MatcherTask, atid : rosetta.core.id.AtomID) -> NoneType
- append_upstream_resiue_as_defining_active_site(...) from builtins.PyCapsule
- append_upstream_resiue_as_defining_active_site(self : rosetta.protocols.match.MatcherTask, resid : int, radius : float) -> NoneType
- assign(...) from builtins.PyCapsule
- assign(self : rosetta.protocols.match.MatcherTask, rhs : rosetta.protocols.match.MatcherTask) -> rosetta.protocols.match.MatcherTask
- build_round1_hits_twice(...) from builtins.PyCapsule
- build_round1_hits_twice(rosetta.protocols.match.MatcherTask) -> bool
- clear_downstream_orientation_atoms(...) from builtins.PyCapsule
- clear_downstream_orientation_atoms(rosetta.protocols.match.MatcherTask) -> NoneType
- consolidate_matches(...) from builtins.PyCapsule
- consolidate_matches(*args, **kwargs)
Overloaded function.
1. consolidate_matches(self : rosetta.protocols.match.MatcherTask, setting : bool) -> NoneType
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.
2. consolidate_matches(rosetta.protocols.match.MatcherTask) -> bool
- cstfile_name(...) from builtins.PyCapsule
- cstfile_name(rosetta.protocols.match.MatcherTask) -> str
- define_active_site_from_gridlig_file(...) from builtins.PyCapsule
- define_active_site_from_gridlig_file(self : rosetta.protocols.match.MatcherTask, file_name : str) -> NoneType
- define_active_site_from_residue_radii_list(...) from builtins.PyCapsule
- define_active_site_from_residue_radii_list(rosetta.protocols.match.MatcherTask) -> NoneType
- define_match_by_single_downstream_positioning(...) from builtins.PyCapsule
- define_match_by_single_downstream_positioning(*args, **kwargs)
Overloaded function.
1. define_match_by_single_downstream_positioning(self : rosetta.protocols.match.MatcherTask, setting : bool) -> NoneType
2. define_match_by_single_downstream_positioning(rosetta.protocols.match.MatcherTask) -> bool
- downstream_atoms_required_inside_active_site(...) from builtins.PyCapsule
- downstream_atoms_required_inside_active_site(rosetta.protocols.match.MatcherTask) -> rosetta.std.list_core_id_AtomID_std_allocator_core_id_AtomID_t
- downstream_orientation_atoms(...) from builtins.PyCapsule
- downstream_orientation_atoms(rosetta.protocols.match.MatcherTask) -> rosetta.utility.vector1_core_id_AtomID
- downstream_pose(...) from builtins.PyCapsule
- downstream_pose(rosetta.protocols.match.MatcherTask) -> rosetta.core.pose.Pose
- dynamic_grid_refinement(...) from builtins.PyCapsule
- dynamic_grid_refinement(rosetta.protocols.match.MatcherTask) -> bool
- enumerate_ligand_rotamers(...) from builtins.PyCapsule
- enumerate_ligand_rotamers(rosetta.protocols.match.MatcherTask) -> bool
- enz_input_data(...) from builtins.PyCapsule
- enz_input_data(rosetta.protocols.match.MatcherTask) -> rosetta.protocols.toolbox.match_enzdes_util.EnzConstraintIO
- euclidean_bin_widths(...) from builtins.PyCapsule
- euclidean_bin_widths(rosetta.protocols.match.MatcherTask) -> rosetta.numeric.xyzVector_double_t
- euler_bin_widths(...) from builtins.PyCapsule
- euler_bin_widths(rosetta.protocols.match.MatcherTask) -> rosetta.numeric.xyzVector_double_t
- evaluator_name(...) from builtins.PyCapsule
- evaluator_name(*args, **kwargs)
Overloaded function.
1. evaluator_name(self : rosetta.protocols.match.MatcherTask, setting : str) -> NoneType
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.
2. evaluator_name(rosetta.protocols.match.MatcherTask) -> str
- filter_names(...) from builtins.PyCapsule
- filter_names(rosetta.protocols.match.MatcherTask) -> rosetta.std.list_std_string_std_allocator_std_string_t
- filter_upstream_collisions_by_score(...) from builtins.PyCapsule
- filter_upstream_collisions_by_score(*args, **kwargs)
Overloaded function.
1. filter_upstream_collisions_by_score(self : rosetta.protocols.match.MatcherTask, setting : bool) -> NoneType
2. filter_upstream_collisions_by_score(rosetta.protocols.match.MatcherTask) -> bool
- filter_upstream_downstream_collisions(...) from builtins.PyCapsule
- filter_upstream_downstream_collisions(*args, **kwargs)
Overloaded function.
1. filter_upstream_downstream_collisions(self : rosetta.protocols.match.MatcherTask, setting : bool) -> NoneType
2. filter_upstream_downstream_collisions(rosetta.protocols.match.MatcherTask) -> bool
- filter_upstream_downstream_collisions_by_score(...) from builtins.PyCapsule
- filter_upstream_downstream_collisions_by_score(*args, **kwargs)
Overloaded function.
1. filter_upstream_downstream_collisions_by_score(self : rosetta.protocols.match.MatcherTask, setting : bool) -> NoneType
2. filter_upstream_downstream_collisions_by_score(rosetta.protocols.match.MatcherTask) -> bool
- filter_upstream_residue_collisions(...) from builtins.PyCapsule
- filter_upstream_residue_collisions(*args, **kwargs)
Overloaded function.
1. filter_upstream_residue_collisions(self : rosetta.protocols.match.MatcherTask, setting : bool) -> NoneType
2. filter_upstream_residue_collisions(rosetta.protocols.match.MatcherTask) -> bool
- geom_csts_downstream_output(...) from builtins.PyCapsule
- geom_csts_downstream_output(rosetta.protocols.match.MatcherTask) -> rosetta.utility.vector1_unsigned_long
- get_self_ptr(...) from builtins.PyCapsule
- get_self_ptr(*args, **kwargs)
Overloaded function.
1. get_self_ptr(rosetta.protocols.match.MatcherTask) -> rosetta.protocols.match.MatcherTask
self pointers
2. get_self_ptr(rosetta.protocols.match.MatcherTask) -> rosetta.protocols.match.MatcherTask
- gridlig_active_site_definition(...) from builtins.PyCapsule
- gridlig_active_site_definition(rosetta.protocols.match.MatcherTask) -> bool
Define the active site through a gridlig file (true), or by listing residue/radii paris (false)?
- gridlig_file_name(...) from builtins.PyCapsule
- gridlig_file_name(rosetta.protocols.match.MatcherTask) -> str
Accessor for the file name containing the active-site definition in gridlig format
- grouper_ds_rmsd(...) from builtins.PyCapsule
- grouper_ds_rmsd(rosetta.protocols.match.MatcherTask) -> float
- grouper_name(...) from builtins.PyCapsule
- grouper_name(*args, **kwargs)
Overloaded function.
1. grouper_name(self : rosetta.protocols.match.MatcherTask, setting : str) -> NoneType
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.
2. grouper_name(rosetta.protocols.match.MatcherTask) -> str
- initialize_from_command_line(...) from builtins.PyCapsule
- initialize_from_command_line(rosetta.protocols.match.MatcherTask) -> NoneType
Initialize many parameters from the command line options
- modify_pose_build_resids_from_endes_input(...) from builtins.PyCapsule
- modify_pose_build_resids_from_endes_input(rosetta.protocols.match.MatcherTask) -> NoneType
modify the match positions according to what is specified
in the cstfile
- n_to_output_per_group(...) from builtins.PyCapsule
- n_to_output_per_group(*args, **kwargs)
Overloaded function.
1. n_to_output_per_group(self : rosetta.protocols.match.MatcherTask, setting : int) -> NoneType
For use with the match consolidator; specify the number of output matches that the
consolidator should select for each group.
2. n_to_output_per_group(rosetta.protocols.match.MatcherTask) -> int
- occ_space_bounding_box(...) from builtins.PyCapsule
- occ_space_bounding_box(rosetta.protocols.match.MatcherTask) -> rosetta.numeric.geometry.BoundingBox_numeric_xyzVector_double_t
- only_enumerate_non_match_redundant_ligand_rotamers(...) from builtins.PyCapsule
- only_enumerate_non_match_redundant_ligand_rotamers(rosetta.protocols.match.MatcherTask) -> bool
- output_file_name(...) from builtins.PyCapsule
- output_file_name(*args, **kwargs)
Overloaded function.
1. output_file_name(self : rosetta.protocols.match.MatcherTask, setting : str) -> NoneType
Indicate the name of the single output file to which the matches will be written
2. output_file_name(rosetta.protocols.match.MatcherTask) -> str
- output_matchres_only(...) from builtins.PyCapsule
- output_matchres_only(rosetta.protocols.match.MatcherTask) -> bool
- output_scores(...) from builtins.PyCapsule
- output_scores(rosetta.protocols.match.MatcherTask) -> bool
- output_writer_name(...) from builtins.PyCapsule
- output_writer_name(*args, **kwargs)
Overloaded function.
1. output_writer_name(self : rosetta.protocols.match.MatcherTask, setting : str) -> NoneType
Specify the name of the class that will write the output.
Valid options include: KinWriter. More output options will be implemented shortly.
2. output_writer_name(rosetta.protocols.match.MatcherTask) -> str
- permitted_overlap(...) from builtins.PyCapsule
- permitted_overlap(rosetta.protocols.match.MatcherTask) -> float
- relevant_downstream_atoms(...) from builtins.PyCapsule
- relevant_downstream_atoms(rosetta.protocols.match.MatcherTask) -> rosetta.utility.vector1_core_id_AtomID
- score_output_file_name(...) from builtins.PyCapsule
- score_output_file_name(*args, **kwargs)
Overloaded function.
1. score_output_file_name(self : rosetta.protocols.match.MatcherTask, setting : str) -> NoneType
Set the name of the single output file to which the scores of matches will be written
2. score_output_file_name(rosetta.protocols.match.MatcherTask) -> str
- set_downstream_orientation_atoms(...) from builtins.PyCapsule
- set_downstream_orientation_atoms(self : rosetta.protocols.match.MatcherTask, orientation_atoms : rosetta.utility.vector1_core_id_AtomID) -> NoneType
- set_downstream_pose(...) from builtins.PyCapsule
- set_downstream_pose(*args, **kwargs)
Overloaded function.
1. set_downstream_pose(self : rosetta.protocols.match.MatcherTask, input_pose : rosetta.core.pose.Pose) -> NoneType
2. set_downstream_pose(self : rosetta.protocols.match.MatcherTask, pose : rosetta.core.pose.Pose, orientation_atoms : rosetta.utility.vector1_core_id_AtomID) -> NoneType
- set_enumerate_ligand_rotamers(...) from builtins.PyCapsule
- set_enumerate_ligand_rotamers(self : rosetta.protocols.match.MatcherTask, setting : bool) -> NoneType
- set_enz_input_data(...) from builtins.PyCapsule
- set_enz_input_data(self : rosetta.protocols.match.MatcherTask, data : rosetta.protocols.toolbox.match_enzdes_util.EnzConstraintIO) -> NoneType
Set the matcher-file input data. The Matcher will read this data when initializing itself.
- set_hash_euclidean_bin_width(...) from builtins.PyCapsule
- set_hash_euclidean_bin_width(self : rosetta.protocols.match.MatcherTask, width : float) -> NoneType
For the occupied space hash, set the euclidean-bin width to a uniform value for xy&z
- set_hash_euler_bin_width(...) from builtins.PyCapsule
- set_hash_euler_bin_width(self : rosetta.protocols.match.MatcherTask, width : float) -> NoneType
For the occupeid space hash, set the euler-bin width to a uniform value for phi,psi&theta
- set_ignore_cmdline_for_build_points(...) from builtins.PyCapsule
- set_ignore_cmdline_for_build_points(self : rosetta.protocols.match.MatcherTask, setting : bool) -> NoneType
- set_occupied_space_bounding_box(...) from builtins.PyCapsule
- set_occupied_space_bounding_box(self : rosetta.protocols.match.MatcherTask, bb : rosetta.numeric.geometry.BoundingBox_numeric_xyzVector_double_t) -> NoneType
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.
- set_only_enumerate_non_match_redundant_ligand_rotamers(...) from builtins.PyCapsule
- set_only_enumerate_non_match_redundant_ligand_rotamers(self : rosetta.protocols.match.MatcherTask, setting : bool) -> NoneType
- set_original_scaffold_build_points(...) from builtins.PyCapsule
- set_original_scaffold_build_points(self : rosetta.protocols.match.MatcherTask, resids : rosetta.utility.vector1_unsigned_long) -> NoneType
Uniformly consider the same set of build points for each of the geometric constrains
- set_original_scaffold_build_points_for_geometric_constraint(...) from builtins.PyCapsule
- set_original_scaffold_build_points_for_geometric_constraint(self : rosetta.protocols.match.MatcherTask, geom_cst_id : int, resids : rosetta.utility.vector1_unsigned_long) -> NoneType
Set the build point id's for a particular geometric constraint
- set_permitted_overlap(...) from builtins.PyCapsule
- set_permitted_overlap(self : rosetta.protocols.match.MatcherTask, permitted_overlap : float) -> NoneType
For collision detection, select the amount of collision that should
be tolerated between heavy atoms. This should be a positive value in Angstroms.
- set_upstream_pose(...) from builtins.PyCapsule
- set_upstream_pose(self : rosetta.protocols.match.MatcherTask, pose : rosetta.core.pose.Pose) -> NoneType
Setup
- upstream_downstream_atom_collision_tolerance(...) from builtins.PyCapsule
- upstream_downstream_atom_collision_tolerance(*args, **kwargs)
Overloaded function.
1. upstream_downstream_atom_collision_tolerance(self : rosetta.protocols.match.MatcherTask, setting : float) -> NoneType
2. upstream_downstream_atom_collision_tolerance(rosetta.protocols.match.MatcherTask) -> float
- upstream_downstream_residue_collision_Wfa_atr(...) from builtins.PyCapsule
- upstream_downstream_residue_collision_Wfa_atr(*args, **kwargs)
Overloaded function.
1. upstream_downstream_residue_collision_Wfa_atr(self : rosetta.protocols.match.MatcherTask, setting : float) -> NoneType
2. upstream_downstream_residue_collision_Wfa_atr(rosetta.protocols.match.MatcherTask) -> float
- upstream_downstream_residue_collision_Wfa_rep(...) from builtins.PyCapsule
- upstream_downstream_residue_collision_Wfa_rep(*args, **kwargs)
Overloaded function.
1. upstream_downstream_residue_collision_Wfa_rep(self : rosetta.protocols.match.MatcherTask, setting : float) -> NoneType
2. upstream_downstream_residue_collision_Wfa_rep(rosetta.protocols.match.MatcherTask) -> float
- upstream_downstream_residue_collision_Wfa_sol(...) from builtins.PyCapsule
- upstream_downstream_residue_collision_Wfa_sol(*args, **kwargs)
Overloaded function.
1. upstream_downstream_residue_collision_Wfa_sol(self : rosetta.protocols.match.MatcherTask, setting : float) -> NoneType
2. upstream_downstream_residue_collision_Wfa_sol(rosetta.protocols.match.MatcherTask) -> float
- upstream_downstream_residue_collision_score_cutoff(...) from builtins.PyCapsule
- upstream_downstream_residue_collision_score_cutoff(*args, **kwargs)
Overloaded function.
1. upstream_downstream_residue_collision_score_cutoff(self : rosetta.protocols.match.MatcherTask, setting : float) -> NoneType
2. upstream_downstream_residue_collision_score_cutoff(rosetta.protocols.match.MatcherTask) -> float
- upstream_only_geom_cst(...) from builtins.PyCapsule
- upstream_only_geom_cst(rosetta.protocols.match.MatcherTask) -> rosetta.std.map_unsigned_long_unsigned_long
- upstream_pose(...) from builtins.PyCapsule
- upstream_pose(rosetta.protocols.match.MatcherTask) -> rosetta.core.pose.Pose
- upstream_pose_build_resids_for_geometric_constraint(...) from builtins.PyCapsule
- upstream_pose_build_resids_for_geometric_constraint(self : rosetta.protocols.match.MatcherTask, cst_id : int) -> rosetta.utility.vector1_unsigned_long
- upstream_pose_name(...) from builtins.PyCapsule
- upstream_pose_name(rosetta.protocols.match.MatcherTask) -> str
- upstream_resids_and_radii_defining_active_site(...) from builtins.PyCapsule
- upstream_resids_and_radii_defining_active_site(rosetta.protocols.match.MatcherTask) -> rosetta.std.list_std_pair_unsigned_long_double_std_allocator_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.
- upstream_residue_collision_Wfa_atr(...) from builtins.PyCapsule
- upstream_residue_collision_Wfa_atr(*args, **kwargs)
Overloaded function.
1. upstream_residue_collision_Wfa_atr(self : rosetta.protocols.match.MatcherTask, setting : float) -> NoneType
2. upstream_residue_collision_Wfa_atr(rosetta.protocols.match.MatcherTask) -> float
- upstream_residue_collision_Wfa_rep(...) from builtins.PyCapsule
- upstream_residue_collision_Wfa_rep(*args, **kwargs)
Overloaded function.
1. upstream_residue_collision_Wfa_rep(self : rosetta.protocols.match.MatcherTask, setting : float) -> NoneType
2. upstream_residue_collision_Wfa_rep(rosetta.protocols.match.MatcherTask) -> float
- upstream_residue_collision_Wfa_sol(...) from builtins.PyCapsule
- upstream_residue_collision_Wfa_sol(*args, **kwargs)
Overloaded function.
1. upstream_residue_collision_Wfa_sol(self : rosetta.protocols.match.MatcherTask, setting : float) -> NoneType
2. upstream_residue_collision_Wfa_sol(rosetta.protocols.match.MatcherTask) -> float
- upstream_residue_collision_score_cutoff(...) from builtins.PyCapsule
- upstream_residue_collision_score_cutoff(*args, **kwargs)
Overloaded function.
1. upstream_residue_collision_score_cutoff(self : rosetta.protocols.match.MatcherTask, setting : float) -> NoneType
2. upstream_residue_collision_score_cutoff(rosetta.protocols.match.MatcherTask) -> float
- upstream_residue_collision_tolerance(...) from builtins.PyCapsule
- upstream_residue_collision_tolerance(*args, **kwargs)
Overloaded function.
1. upstream_residue_collision_tolerance(self : rosetta.protocols.match.MatcherTask, setting : float) -> NoneType
2. upstream_residue_collision_tolerance(rosetta.protocols.match.MatcherTask) -> float
- use_different_build_points_for_each_geometric_constraint(...) from builtins.PyCapsule
- use_different_build_points_for_each_geometric_constraint(self : rosetta.protocols.match.MatcherTask, n_geometric_constraints : int) -> NoneType
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.
- use_input_sc(...) from builtins.PyCapsule
- use_input_sc(rosetta.protocols.match.MatcherTask) -> bool
|
class NumNeighborsMPM(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
|
| |
- Method resolution order:
- NumNeighborsMPM
- MatchPositionModifier
- builtins.object
Methods defined here:
- __init__(...) from builtins.PyCapsule
- __init__(self : handle, input_tokens : rosetta.utility.vector1_std_string) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- assign(...) from builtins.PyCapsule
- assign(self : rosetta.protocols.match.NumNeighborsMPM, : rosetta.protocols.match.NumNeighborsMPM) -> rosetta.protocols.match.NumNeighborsMPM
- modified_match_positions(...) from builtins.PyCapsule
- modified_match_positions(self : rosetta.protocols.match.NumNeighborsMPM, original_positions : rosetta.utility.vector1_unsigned_long, match_pose : rosetta.core.pose.Pose, mtask : protocols::match::MatcherTask) -> rosetta.utility.vector1_unsigned_long
- passes_com_vector_criterion(...) from builtins.PyCapsule
- passes_com_vector_criterion(self : rosetta.protocols.match.NumNeighborsMPM, seqpos : int, pose : rosetta.core.pose.Pose, com : rosetta.numeric.xyzVector_double_t) -> bool
|
class OccupiedSpaceHash(builtins.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.
|
| |
Methods defined here:
- __init__(...) from builtins.PyCapsule
- __init__(rosetta.protocols.match.OccupiedSpaceHash) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- assign(...) from builtins.PyCapsule
- assign(self : rosetta.protocols.match.OccupiedSpaceHash, : rosetta.protocols.match.OccupiedSpaceHash) -> rosetta.protocols.match.OccupiedSpaceHash
- drop_unsatisfied_voxels(...) from builtins.PyCapsule
- drop_unsatisfied_voxels(rosetta.protocols.match.OccupiedSpaceHash) -> NoneType
- initialize(...) from builtins.PyCapsule
- initialize(rosetta.protocols.match.OccupiedSpaceHash) -> NoneType
- insert_hit_geometry(...) from builtins.PyCapsule
- insert_hit_geometry(self : rosetta.protocols.match.OccupiedSpaceHash, geom : rosetta.utility.fixedsizearray1_double_6_t) -> NoneType
- match_possible_for_hit_geometry(...) from builtins.PyCapsule
- match_possible_for_hit_geometry(self : rosetta.protocols.match.OccupiedSpaceHash, : rosetta.utility.fixedsizearray1_double_6_t) -> bool
- note_hit_geometry(...) from builtins.PyCapsule
- note_hit_geometry(self : rosetta.protocols.match.OccupiedSpaceHash, : rosetta.utility.fixedsizearray1_double_6_t) -> NoneType
- prepare_to_note_hits_for_completed_round(...) from builtins.PyCapsule
- prepare_to_note_hits_for_completed_round(rosetta.protocols.match.OccupiedSpaceHash) -> NoneType
- previous_round_geometry_still_matchable(...) from builtins.PyCapsule
- previous_round_geometry_still_matchable(self : rosetta.protocols.match.OccupiedSpaceHash, : rosetta.utility.fixedsizearray1_double_6_t) -> bool
- reset_3d_projection(...) from builtins.PyCapsule
- reset_3d_projection(rosetta.protocols.match.OccupiedSpaceHash) -> NoneType
- revision_id(...) from builtins.PyCapsule
- revision_id(rosetta.protocols.match.OccupiedSpaceHash) -> int
- set_bounding_box(...) from builtins.PyCapsule
- set_bounding_box(self : rosetta.protocols.match.OccupiedSpaceHash, bb : rosetta.numeric.geometry.BoundingBox_numeric_xyzVector_double_t) -> NoneType
- set_euler_bin_widths(...) from builtins.PyCapsule
- set_euler_bin_widths(self : rosetta.protocols.match.OccupiedSpaceHash, euler_bin_widths : rosetta.numeric.xyzVector_double_t) -> NoneType
- set_uniform_euler_angle_bin_width(...) from builtins.PyCapsule
- set_uniform_euler_angle_bin_width(self : rosetta.protocols.match.OccupiedSpaceHash, bin_width_degrees : float) -> NoneType
- set_uniform_xyz_bin_width(...) from builtins.PyCapsule
- set_uniform_xyz_bin_width(self : rosetta.protocols.match.OccupiedSpaceHash, bin_width : float) -> NoneType
- set_xyz_bin_widths(...) from builtins.PyCapsule
- set_xyz_bin_widths(self : rosetta.protocols.match.OccupiedSpaceHash, bin_widths : rosetta.numeric.xyzVector_double_t) -> NoneType
- write_3Dprojection_kinemage(...) from builtins.PyCapsule
- write_3Dprojection_kinemage(self : rosetta.protocols.match.OccupiedSpaceHash, kin_file_name : str) -> NoneType
|
class ProbeRadius(builtins.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.
|
| |
Methods defined here:
- __eq__(...) from builtins.PyCapsule
- __eq__(rosetta.protocols.match.ProbeRadius, rosetta.protocols.match.ProbeRadius) -> bool
- __hash__(...) from builtins.PyCapsule
- __hash__(rosetta.protocols.match.ProbeRadius) -> int
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(rosetta.protocols.match.ProbeRadius, int) -> NoneType
2. __init__(rosetta.protocols.match.ProbeRadius, int) -> NoneType
- __int__(...) from builtins.PyCapsule
- __int__(rosetta.protocols.match.ProbeRadius) -> int
- __ne__(...) from builtins.PyCapsule
- __ne__(rosetta.protocols.match.ProbeRadius, rosetta.protocols.match.ProbeRadius) -> bool
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- __repr__(...) from builtins.PyCapsule
- __repr__(rosetta.protocols.match.ProbeRadius) -> str
Data and other attributes defined here:
- C_ALA = ProbeRadius.C_ALA
- C_CAR = ProbeRadius.C_CAR
- H_ALA = ProbeRadius.H_ALA
- H_ARO = ProbeRadius.H_ARO
- NIT = ProbeRadius.NIT
- OXY = ProbeRadius.OXY
- SULPH = ProbeRadius.n_probe_radii
- ZERO = ProbeRadius.ZERO
- n_probe_radii = ProbeRadius.n_probe_radii
|
class VoxelSetIterator(builtins.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.
|
| |
Methods defined here:
- __init__(...) from builtins.PyCapsule
- __init__(self : rosetta.protocols.match.VoxelSetIterator, bb : rosetta.numeric.geometry.BoundingBox_numeric_xyzVector_double_t, n_xyz_bins : rosetta.utility.fixedsizearray1_unsigned_long_3_t, n_euler_bins : rosetta.utility.fixedsizearray1_unsigned_long_3_t, xyz_bin_widths : rosetta.utility.fixedsizearray1_double_3_t, euler_bin_widths : rosetta.utility.fixedsizearray1_double_3_t, xyz_bin_halfwidths : rosetta.utility.fixedsizearray1_double_3_t, euler_bin_halfwidths : rosetta.utility.fixedsizearray1_double_3_t, point : rosetta.utility.fixedsizearray1_double_6_t) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- at_end(...) from builtins.PyCapsule
- at_end(rosetta.protocols.match.VoxelSetIterator) -> bool
- get_bin_and_pos(...) from builtins.PyCapsule
- get_bin_and_pos(self : rosetta.protocols.match.VoxelSetIterator, bin : rosetta.utility.fixedsizearray1_unsigned_long_6_t, pos : int) -> NoneType
- plus_plus(...) from builtins.PyCapsule
- plus_plus(rosetta.protocols.match.VoxelSetIterator) -> NoneType
|
class match_dspos1(builtins.object) |
| |
Describe a match as n_geometric_constraint upstream residue conformations and
one positioning of the downstream partner ( "dspos1" = 1 downstrem position)
|
| |
Methods defined here:
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(rosetta.protocols.match.match_dspos1) -> NoneType
2. __init__(self : rosetta.protocols.match.match_dspos1, n_geometric_constraints : int) -> NoneType
3. __init__(self : rosetta.protocols.match.match_dspos1, m : rosetta.utility.vector1_protocols_match_Hit, geomcst_specifying_dspos : int) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
Data descriptors defined here:
- downstream_conf_id
- dspos
- originating_geom_cst_for_dspos
- upstream_hits
|
class upstream_hit(builtins.object) |
| | |
Methods defined here:
- __eq__(...) from builtins.PyCapsule
- __eq__(self : rosetta.protocols.match.upstream_hit, rhs : rosetta.protocols.match.upstream_hit) -> bool
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(rosetta.protocols.match.upstream_hit) -> NoneType
2. __init__(self : rosetta.protocols.match.upstream_hit, source : rosetta.protocols.match.Hit) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- copy_hit(...) from builtins.PyCapsule
- copy_hit(self : rosetta.protocols.match.upstream_hit, source : rosetta.protocols.match.Hit) -> NoneType
- external_geom_id(...) from builtins.PyCapsule
- external_geom_id(*args, **kwargs)
Overloaded function.
1. external_geom_id(rosetta.protocols.match.upstream_hit) -> int
2. external_geom_id(self : rosetta.protocols.match.upstream_hit, setting : int) -> NoneType
- scaffold_build_id(...) from builtins.PyCapsule
- scaffold_build_id(*args, **kwargs)
Overloaded function.
1. scaffold_build_id(rosetta.protocols.match.upstream_hit) -> int
2. scaffold_build_id(self : rosetta.protocols.match.upstream_hit, setting : int) -> NoneType
- upstream_conf_id(...) from builtins.PyCapsule
- upstream_conf_id(*args, **kwargs)
Overloaded function.
1. upstream_conf_id(rosetta.protocols.match.upstream_hit) -> int
2. upstream_conf_id(self : rosetta.protocols.match.upstream_hit, setting : int) -> NoneType
| |