| | |
- add_cutpoint_variants(...) method of builtins.PyCapsule instance
- add_cutpoint_variants(pose : rosetta.core.pose.Pose, pos : int) -> bool
add cutpoint variants at a specific position
to modify
at which to add cutpoint variants
true if cutpoint variants added, false if position not a topological cutpoint
- apply_transformation(...) method of builtins.PyCapsule instance
- apply_transformation(mod_pose : rosetta.core.pose.Pose, residue_list : rosetta.std.list_unsigned_long_std_allocator_unsigned_long_t, R : rosetta.numeric.xyzMatrix_double_t, preT : rosetta.numeric.xyzVector_double_t, postT : rosetta.numeric.xyzVector_double_t) -> NoneType
- calc_rsd_sasa(...) method of builtins.PyCapsule instance
- calc_rsd_sasa(pose : rosetta.core.pose.Pose) -> rosetta.utility.vector1_double
- closest_larger_peptide_vertex(...) method of builtins.PyCapsule instance
- closest_larger_peptide_vertex(*args, **kwargs)
Overloaded function.
1. closest_larger_peptide_vertex(v : int, ft : rosetta.core.kinematics.FoldTree) -> int
find the k'th closest larger peptide vertex of given vertex in fold tree
the given vertex
fold tree to search
find the k'th closest, must be > 0
0 if no such vertex
2. closest_larger_peptide_vertex(v : int, ft : rosetta.core.kinematics.FoldTree, k : int) -> int
find the k'th closest larger peptide vertex of given vertex in fold tree
the given vertex
fold tree to search
find the k'th closest, must be > 0
0 if no such vertex
- closest_smaller_peptide_vertex(...) method of builtins.PyCapsule instance
- closest_smaller_peptide_vertex(*args, **kwargs)
Overloaded function.
1. closest_smaller_peptide_vertex(v : int, ft : rosetta.core.kinematics.FoldTree) -> int
find the k'th closest smaller peptide vertex of given vertex in fold tree
the given vertex
fold tree to search
find the k'th closest, must be > 0
0 if no such vertex
2. closest_smaller_peptide_vertex(v : int, ft : rosetta.core.kinematics.FoldTree, k : int) -> int
find the k'th closest smaller peptide vertex of given vertex in fold tree
the given vertex
fold tree to search
find the k'th closest, must be > 0
0 if no such vertex
- count_cutpoints(...) method of builtins.PyCapsule instance
- count_cutpoints(pose : rosetta.core.pose.Pose, left : int, right : int) -> int
moving left to right, count the number of true cutpoints within the
specified extent
- fill_non_loop_cst_set(...) method of builtins.PyCapsule instance
- fill_non_loop_cst_set(pose : rosetta.core.pose.Pose, loops : rosetta.protocols.loops.Loops) -> NoneType
- find_connecting_jump(...) method of builtins.PyCapsule instance
- find_connecting_jump(u : int, v : int, ft : rosetta.core.kinematics.FoldTree) -> int
find the jump connecting two continuous segments of a fold tree
Any vertex on the first segment.
Any vertex on the second segment.
The fold tree to query.
the jump number connecting the two segments, 0 if no such jump
- find_cutpoint(...) method of builtins.PyCapsule instance
- find_cutpoint(pose : rosetta.core.pose.Pose, left : int, right : int) -> int
moving left to right, find the first true cutpoint within the specified
extent
the cutpoint position, otherwise 0 if not found
- fold_tree_from_loops(...) method of builtins.PyCapsule instance
- fold_tree_from_loops(pose : rosetta.core.pose.Pose, loops : rosetta.protocols.loops.Loops) -> rosetta.core.kinematics.FoldTree
create fold tree from loops
This is a generic replacement function for the one in protocols::loops
and will be moved there in the near future.
- fold_tree_from_pose(...) method of builtins.PyCapsule instance
- fold_tree_from_pose(pose : rosetta.core.pose.Pose, ft_root : int, mm : rosetta.core.kinematics.MoveMap) -> rosetta.core.kinematics.FoldTree
construct a fold tree from Pose wrt chain endings and residue types
Determines edge types from residues (polymer vs non-polymer).
Each chain will end up as one edge in the fold tree. Jumps will be made
from the new root to a random fixed backbone residue as specified by the
movemap. If all residues in a chain are moveable, will choose any random
residue.
Pose.
Root of the new fold tree.
MoveMap used to select jump positions.
fold tree wrt chain endings and residue types
- grow_left_r___gnu_cxx___normal_iterator_std_shared_ptr_core_conformation_Residue_*_std_vector_std_shared_ptr_core_conformation_Residue_std_allocator_std_shared_ptr_core_conformation_Residue_t(...) method of builtins.PyCapsule instance
- grow_left_r___gnu_cxx___normal_iterator_std_shared_ptr_core_conformation_Residue_*_std_vector_std_shared_ptr_core_conformation_Residue_std_allocator_std_shared_ptr_core_conformation_Residue_t(*args, **kwargs)
Overloaded function.
1. grow_left_r___gnu_cxx___normal_iterator_std_shared_ptr_core_conformation_Residue_*_std_vector_std_shared_ptr_core_conformation_Residue_std_allocator_std_shared_ptr_core_conformation_Residue_t(pose : rosetta.core.pose.Pose, anchor : int, begin : __gnu_cxx::__normal_iterator<std::shared_ptr<core::conformation::Residue>*, std::vector<std::shared_ptr<core::conformation::Residue>, std::allocator<std::shared_ptr<core::conformation::Residue> > > >, end : __gnu_cxx::__normal_iterator<std::shared_ptr<core::conformation::Residue>*, std::vector<std::shared_ptr<core::conformation::Residue>, std::allocator<std::shared_ptr<core::conformation::Residue> > > >) -> int
2. grow_left_r___gnu_cxx___normal_iterator_std_shared_ptr_core_conformation_Residue_*_std_vector_std_shared_ptr_core_conformation_Residue_std_allocator_std_shared_ptr_core_conformation_Residue_t(pose : rosetta.core.pose.Pose, anchor : int, begin : __gnu_cxx::__normal_iterator<std::shared_ptr<core::conformation::Residue>*, std::vector<std::shared_ptr<core::conformation::Residue>, std::allocator<std::shared_ptr<core::conformation::Residue> > > >, end : __gnu_cxx::__normal_iterator<std::shared_ptr<core::conformation::Residue>*, std::vector<std::shared_ptr<core::conformation::Residue>, std::allocator<std::shared_ptr<core::conformation::Residue> > > >, correct_terminus : bool) -> int
3. grow_left_r___gnu_cxx___normal_iterator_std_shared_ptr_core_conformation_Residue_*_std_vector_std_shared_ptr_core_conformation_Residue_std_allocator_std_shared_ptr_core_conformation_Residue_t(pose : rosetta.core.pose.Pose, anchor : int, begin : __gnu_cxx::__normal_iterator<std::shared_ptr<core::conformation::Residue>*, std::vector<std::shared_ptr<core::conformation::Residue>, std::allocator<std::shared_ptr<core::conformation::Residue> > > >, end : __gnu_cxx::__normal_iterator<std::shared_ptr<core::conformation::Residue>*, std::vector<std::shared_ptr<core::conformation::Residue>, std::allocator<std::shared_ptr<core::conformation::Residue> > > >, correct_terminus : bool, use_existing_crd : bool) -> int
- grow_right_r___gnu_cxx___normal_iterator_std_shared_ptr_core_conformation_Residue_*_std_vector_std_shared_ptr_core_conformation_Residue_std_allocator_std_shared_ptr_core_conformation_Residue_t(...) method of builtins.PyCapsule instance
- grow_right_r___gnu_cxx___normal_iterator_std_shared_ptr_core_conformation_Residue_*_std_vector_std_shared_ptr_core_conformation_Residue_std_allocator_std_shared_ptr_core_conformation_Residue_t(*args, **kwargs)
Overloaded function.
1. grow_right_r___gnu_cxx___normal_iterator_std_shared_ptr_core_conformation_Residue_*_std_vector_std_shared_ptr_core_conformation_Residue_std_allocator_std_shared_ptr_core_conformation_Residue_t(pose : rosetta.core.pose.Pose, anchor : int, begin : __gnu_cxx::__normal_iterator<std::shared_ptr<core::conformation::Residue>*, std::vector<std::shared_ptr<core::conformation::Residue>, std::allocator<std::shared_ptr<core::conformation::Residue> > > >, end : __gnu_cxx::__normal_iterator<std::shared_ptr<core::conformation::Residue>*, std::vector<std::shared_ptr<core::conformation::Residue>, std::allocator<std::shared_ptr<core::conformation::Residue> > > >) -> int
2. grow_right_r___gnu_cxx___normal_iterator_std_shared_ptr_core_conformation_Residue_*_std_vector_std_shared_ptr_core_conformation_Residue_std_allocator_std_shared_ptr_core_conformation_Residue_t(pose : rosetta.core.pose.Pose, anchor : int, begin : __gnu_cxx::__normal_iterator<std::shared_ptr<core::conformation::Residue>*, std::vector<std::shared_ptr<core::conformation::Residue>, std::allocator<std::shared_ptr<core::conformation::Residue> > > >, end : __gnu_cxx::__normal_iterator<std::shared_ptr<core::conformation::Residue>*, std::vector<std::shared_ptr<core::conformation::Residue>, std::allocator<std::shared_ptr<core::conformation::Residue> > > >, correct_terminus : bool) -> int
3. grow_right_r___gnu_cxx___normal_iterator_std_shared_ptr_core_conformation_Residue_*_std_vector_std_shared_ptr_core_conformation_Residue_std_allocator_std_shared_ptr_core_conformation_Residue_t(pose : rosetta.core.pose.Pose, anchor : int, begin : __gnu_cxx::__normal_iterator<std::shared_ptr<core::conformation::Residue>*, std::vector<std::shared_ptr<core::conformation::Residue>, std::allocator<std::shared_ptr<core::conformation::Residue> > > >, end : __gnu_cxx::__normal_iterator<std::shared_ptr<core::conformation::Residue>*, std::vector<std::shared_ptr<core::conformation::Residue>, std::allocator<std::shared_ptr<core::conformation::Residue> > > >, correct_terminus : bool, use_existing_crd : bool) -> int
- interval_to_loop(...) method of builtins.PyCapsule instance
- interval_to_loop(interval : rosetta.protocols.forge.build.Interval) -> rosetta.protocols.loops.Loop
create Loop object w/ random cutpoint from an Interval
- jumps_and_cuts_from_pose(...) method of builtins.PyCapsule instance
- jumps_and_cuts_from_pose(pose : rosetta.core.pose.Pose, jumps : rosetta.utility.vector1_std_pair_unsigned_long_unsigned_long_t, cuts : rosetta.utility.vector1_unsigned_long) -> NoneType
- jumps_connected_to_position(...) method of builtins.PyCapsule instance
- jumps_connected_to_position(pos : int, ft : rosetta.core.kinematics.FoldTree) -> rosetta.utility.vector1_core_kinematics_Edge
find all jump edges whose start or stop lands on the given position
The position.
The fold tree.
a list of jump edges
jump edges start/stop will be ordered such that 'pos' will always
be at 'start'.
- linear_chainbreak(...) method of builtins.PyCapsule instance
- linear_chainbreak(*args, **kwargs)
Overloaded function.
1. linear_chainbreak(pose : rosetta.core.pose.Pose, pos : int) -> float
evaluate linear chainbreak at a position
Copies the Pose, if necessary swaps the Pose with a cut fold tree,
then evaluates the chainbreak.
2. linear_chainbreak(pose : rosetta.core.pose.Pose, pos : int) -> float
evaluate linear chainbreak at a position
If necessary, will evaluate using a copy of the Pose with a cut
fold tree.
- make_star_foldtree(...) method of builtins.PyCapsule instance
- make_star_foldtree(pose : rosetta.core.pose.Pose, loops : rosetta.protocols.loops.Loops) -> NoneType
- merge(...) method of builtins.PyCapsule instance
- merge(*args, **kwargs)
Overloaded function.
1. merge(left_tree : rosetta.core.kinematics.FoldTree, right_tree : rosetta.core.kinematics.FoldTree) -> rosetta.core.kinematics.FoldTree
merge two fold trees by jump between their roots
Merged FoldTree with all vertices of right_tree placed to the
right of vertices in left_tree. Jump labels in right_tree will be
renumbered += left_tree.num_jump(). New tree is rooted in the same
place as left_tree.
2. merge(left_tree : rosetta.core.kinematics.FoldTree, left_position : int, right_tree : rosetta.core.kinematics.FoldTree, right_position : int) -> rosetta.core.kinematics.FoldTree
merge two fold trees connecting by jump via specified positions
position on left_tree to connect
position on right_tree to connect
Merged FoldTree with all vertices of right_tree placed to the
right of vertices in left_tree. Jump labels in right_tree will be
renumbered += left_tree.num_jump(). New tree is rooted in the same
place as left_tree.
3. merge(left_tree : rosetta.core.kinematics.FoldTree, left_position : int, left_jump_atom : str, right_tree : rosetta.core.kinematics.FoldTree, right_position : int, right_jump_atom : str) -> rosetta.core.kinematics.FoldTree
merge two fold trees connecting by jump via specified positions
position on left_tree to connect
Use this atom for the left side of the jump.
Use empty string to indicate default setting.
position on right_tree to connect
Use this atom for the right set of the jump.
Use empty string to indicate default setting.
Attempt to keep generated stubs of the
jump within their respective residues. default False
Merged FoldTree with all vertices of right_tree placed to the
right of vertices in left_tree. Jump labels in right_tree will be
renumbered += left_tree.num_jump(). New tree is rooted in the same
place as left_tree.
4. merge(left_tree : rosetta.core.kinematics.FoldTree, left_position : int, left_jump_atom : str, right_tree : rosetta.core.kinematics.FoldTree, right_position : int, right_jump_atom : str, keep_stub_in_residue : bool) -> rosetta.core.kinematics.FoldTree
merge two fold trees connecting by jump via specified positions
position on left_tree to connect
Use this atom for the left side of the jump.
Use empty string to indicate default setting.
position on right_tree to connect
Use this atom for the right set of the jump.
Use empty string to indicate default setting.
Attempt to keep generated stubs of the
jump within their respective residues. default False
Merged FoldTree with all vertices of right_tree placed to the
right of vertices in left_tree. Jump labels in right_tree will be
renumbered += left_tree.num_jump(). New tree is rooted in the same
place as left_tree.
- order(...) method of builtins.PyCapsule instance
- order(e : rosetta.core.kinematics.Edge) -> bool
enforce Edge has start <= stop (swap if necessary)
true if start and stop were swapped
- overlap_chainbreak(...) method of builtins.PyCapsule instance
- overlap_chainbreak(*args, **kwargs)
Overloaded function.
1. overlap_chainbreak(pose : rosetta.core.pose.Pose, pos : int) -> float
evaluate overlap chainbreak at a position
Copies the Pose, if necessary swaps the Pose with a cut fold tree,
then evaluates the chainbreak.
2. overlap_chainbreak(pose : rosetta.core.pose.Pose, pos : int) -> float
evaluate overlap chainbreak at a position
If necessary, will evaluate using a copy of the Pose with a cut
fold tree.
- parse_resfile_string_with_no_lockdown(...) method of builtins.PyCapsule instance
- parse_resfile_string_with_no_lockdown(pose : rosetta.core.pose.Pose, the_task : rosetta.core.pack.task.PackerTask, resfile_string : str) -> rosetta.utility.vector1_bool
- quadratic_chainbreak(...) method of builtins.PyCapsule instance
- quadratic_chainbreak(*args, **kwargs)
Overloaded function.
1. quadratic_chainbreak(pose : rosetta.core.pose.Pose, pos : int) -> float
evaluate quadratic chainbreak at a position
Copies the Pose, if necessary swaps the Pose with a cut fold tree,
then evaluates the chainbreak.
2. quadratic_chainbreak(pose : rosetta.core.pose.Pose, pos : int) -> float
evaluate quadratic chainbreak at a position
If necessary, will evaluate using a copy of the Pose with a cut
fold tree.
- remodel_generic_taskfactory(...) method of builtins.PyCapsule instance
- remodel_generic_taskfactory() -> rosetta.core.pack.task.TaskFactory
- remove_cutpoint(...) method of builtins.PyCapsule instance
- remove_cutpoint(v : int, ft : rosetta.core.kinematics.FoldTree) -> bool
remove a cutpoint, merging the two sections that are adjacent to the cut
true if cutpoint removed, false if not a cutpoint
- remove_cutpoint_variants(...) method of builtins.PyCapsule instance
- remove_cutpoint_variants(pose : rosetta.core.pose.Pose, pos : int) -> bool
remove cutpoint variants at a specific position
to modify
at which to remove cutpoint variants
true if cutpoint variants removed, false if no cutpoint variants found
or position not a topological cutpoint
- remove_cutpoints(...) method of builtins.PyCapsule instance
- remove_cutpoints(cutpoints : rosetta.utility.vector1_unsigned_long, ft : rosetta.core.kinematics.FoldTree) -> NoneType
seal a fold tree by removing all specified cutpoints
Cutpoints to remove.
The input tree.
A new tree with cutpoints removed and all other topology kept
constant.
- replace(...) method of builtins.PyCapsule instance
- replace(original_tree : rosetta.core.kinematics.FoldTree, replace_begin : int, replace_end : int, movemap : rosetta.core.kinematics.MoveMap, replacement_tree : rosetta.core.kinematics.FoldTree) -> rosetta.core.kinematics.FoldTree
replace a section of one fold tree with another fold tree, connecting by
jump between their roots
residue starting the section of original_tree to replace
residue ending the section of original_tree to replace
MoveMap whose fixed backbone positions dictates where new jumps
may be placed.
FoldTree with section replaced.
The procedure will attempt to honor the MoveMap as much as it can. The caveat
is that sequences of calls to some FoldTree routines may shift the jumps internally in
a way that is not easily predictable. If the procedure cannot find an allowed
residue for a jump, it will make a jump to the median residue in the disconnected
fold tree interval.
- restore_residues(...) method of builtins.PyCapsule instance
- restore_residues(*args, **kwargs)
Overloaded function.
1. restore_residues(old2new : rosetta.std.map_unsigned_long_unsigned_long, archive_pose : rosetta.core.pose.Pose, pose : rosetta.core.pose.Pose) -> NoneType
restore residues (i.e. sidechains)
map indicating residues to be transferred and
the mapping from archive_pose position -> pose position
the original Pose to take residues from
the altered Pose that needs residue restoration
2. restore_residues(archive_pose : rosetta.core.pose.Pose, pose : rosetta.core.pose.Pose) -> NoneType
restore residues (i.e. sidechains)
the original Pose to take residues from
the altered Pose that needs residue restoration
length between two poses must be equal
- set_single_loop_fold_tree(...) method of builtins.PyCapsule instance
- set_single_loop_fold_tree(pose : rosetta.core.pose.Pose, loop : rosetta.protocols.loops.Loop) -> NoneType
set a single loop fold tree
This is a generic replacement function for the one in protocols::loops
and will be moved there in the near future.
- shift_jumps(...) method of builtins.PyCapsule instance
- shift_jumps(ft : rosetta.core.kinematics.FoldTree, mm : rosetta.core.kinematics.MoveMap) -> rosetta.core.kinematics.FoldTree
attempt to shift jumps in a fold tree based on fixed positions in a MoveMap
FoldTree to alter
MoveMap to try and honor
FoldTree with jumps shifted, if possible
Procedure will shift a jump position on a continuous segment to a
randomly selected fixed position on that segment specified by the MoveMap.
No changes will be made to a jump point if it is contained within a segment
lacking valid fixed positions. This procedure has the side effect of
collapsing all jump points to a single point within segments that have
fixed positions.
- smallmer_from_largemer(...) method of builtins.PyCapsule instance
- smallmer_from_largemer(*args, **kwargs)
Overloaded function.
1. smallmer_from_largemer(begin : rosetta.core.fragment.ConstFrameIterator, end : rosetta.core.fragment.ConstFrameIterator) -> rosetta.core.fragment.ConstantLengthFragSet
create small-mers from large-mers
Default false. If true, grab all
possible smallmers using every possible starting position in a largemer
(you could end up with a *lot* of fragments per position). If false,
grab smallmers using only the first position of a largemer as the starting
position.
2. smallmer_from_largemer(begin : rosetta.core.fragment.ConstFrameIterator, end : rosetta.core.fragment.ConstFrameIterator, smallmer_size : int) -> rosetta.core.fragment.ConstantLengthFragSet
create small-mers from large-mers
Default false. If true, grab all
possible smallmers using every possible starting position in a largemer
(you could end up with a *lot* of fragments per position). If false,
grab smallmers using only the first position of a largemer as the starting
position.
3. smallmer_from_largemer(begin : rosetta.core.fragment.ConstFrameIterator, end : rosetta.core.fragment.ConstFrameIterator, smallmer_size : int, all_possible_smallmers : bool) -> rosetta.core.fragment.ConstantLengthFragSet
create small-mers from large-mers
Default false. If true, grab all
possible smallmers using every possible starting position in a largemer
(you could end up with a *lot* of fragments per position). If false,
grab smallmers using only the first position of a largemer as the starting
position.
- trans_omega(...) method of builtins.PyCapsule instance
- trans_omega(left : int, right : int, pose : rosetta.core.pose.Pose) -> NoneType
set omega to 180 for a range of residues [left, right]
- union_interval(...) method of builtins.PyCapsule instance
- union_interval(root : int, left : int, right : int, uf : rosetta.core.graph.DisjointSets) -> NoneType
perform union( root, i ) for all 'i' within the closed interval
[left, right]
position to union with; can be any number, does not have
to be a true root of a set
start of the interval
end of the interval
- vertex_exists(...) method of builtins.PyCapsule instance
- vertex_exists(v : int, ft : rosetta.core.kinematics.FoldTree) -> bool
query if vertex already exists in fold tree
|