methods

Bindings for protocols::forge::methods namespace

pyrosetta.rosetta.protocols.forge.methods.add_cutpoint_variants(pose: pyrosetta.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

C++: protocols::forge::methods::add_cutpoint_variants(class core::pose::Pose &, const unsigned long) –> bool

pyrosetta.rosetta.protocols.forge.methods.apply_transformation(mod_pose: pyrosetta.rosetta.core.pose.Pose, residue_list: pyrosetta.rosetta.std.list_unsigned_long_t, R: pyrosetta.rosetta.numeric.xyzMatrix_double_t, preT: pyrosetta.rosetta.numeric.xyzVector_double_t, postT: pyrosetta.rosetta.numeric.xyzVector_double_t) → None

C++: protocols::forge::methods::apply_transformation(class core::pose::Pose &, const class std::list<unsigned long, class std::allocator<unsigned long> > &, const class numeric::xyzMatrix<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &) –> void

pyrosetta.rosetta.protocols.forge.methods.calc_rsd_sasa(pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.utility.vector1_double

C++: protocols::forge::methods::calc_rsd_sasa(const class core::pose::Pose &) –> const class utility::vector1<double, class std::allocator<double> >

pyrosetta.rosetta.protocols.forge.methods.closest_larger_peptide_vertex(*args, **kwargs)

Overloaded function.

1. closest_larger_peptide_vertex(v: int, ft: pyrosetta.rosetta.core.kinematics.FoldTree) -> int

2. closest_larger_peptide_vertex(v: int, ft: pyrosetta.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

C++: protocols::forge::methods::closest_larger_peptide_vertex(const unsigned long, const class core::kinematics::FoldTree &, const unsigned long) –> unsigned long

pyrosetta.rosetta.protocols.forge.methods.closest_smaller_peptide_vertex(*args, **kwargs)

Overloaded function.

1. closest_smaller_peptide_vertex(v: int, ft: pyrosetta.rosetta.core.kinematics.FoldTree) -> int

2. closest_smaller_peptide_vertex(v: int, ft: pyrosetta.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

C++: protocols::forge::methods::closest_smaller_peptide_vertex(const unsigned long, const class core::kinematics::FoldTree &, const unsigned long) –> unsigned long

pyrosetta.rosetta.protocols.forge.methods.count_cutpoints(pose: pyrosetta.rosetta.core.pose.Pose, left: int, right: int) → int

moving left to right, count the number of true cutpoints within the

specified extent

C++: protocols::forge::methods::count_cutpoints(const class core::pose::Pose &, unsigned long, unsigned long) –> unsigned long

pyrosetta.rosetta.protocols.forge.methods.fill_non_loop_cst_set(pose: pyrosetta.rosetta.core.pose.Pose, loops: pyrosetta.rosetta.protocols.loops.Loops) → None

C++: protocols::forge::methods::fill_non_loop_cst_set(class core::pose::Pose &, class protocols::loops::Loops) –> void

pyrosetta.rosetta.protocols.forge.methods.find_connecting_jump(u: int, v: int, ft: pyrosetta.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

C++: protocols::forge::methods::find_connecting_jump(const unsigned long, const unsigned long, const class core::kinematics::FoldTree &) –> unsigned long

pyrosetta.rosetta.protocols.forge.methods.find_cutpoint(pose: pyrosetta.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

C++: protocols::forge::methods::find_cutpoint(const class core::pose::Pose &, unsigned long, unsigned long) –> unsigned long

pyrosetta.rosetta.protocols.forge.methods.fold_tree_from_loops(pose: pyrosetta.rosetta.core.pose.Pose, loops: pyrosetta.rosetta.protocols.loops.Loops) → pyrosetta.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.

C++: protocols::forge::methods::fold_tree_from_loops(const class core::pose::Pose &, const class protocols::loops::Loops &) –> class core::kinematics::FoldTree

pyrosetta.rosetta.protocols.forge.methods.fold_tree_from_pose(pose: pyrosetta.rosetta.core.pose.Pose, ft_root: int, mm: pyrosetta.rosetta.core.kinematics.MoveMap) → pyrosetta.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

C++: protocols::forge::methods::fold_tree_from_pose(const class core::pose::Pose &, const unsigned long, const class core::kinematics::MoveMap &) –> class core::kinematics::FoldTree

pyrosetta.rosetta.protocols.forge.methods.interval_to_loop(interval: pyrosetta.rosetta.protocols.forge.build.Interval) → pyrosetta.rosetta.protocols.loops.Loop

create Loop object w/ random cutpoint from an Interval

C++: protocols::forge::methods::interval_to_loop(const struct protocols::forge::build::Interval &) –> class protocols::loops::Loop

pyrosetta.rosetta.protocols.forge.methods.jumps_and_cuts_from_pose(pose: pyrosetta.rosetta.core.pose.Pose, jumps: pyrosetta.rosetta.utility.vector1_std_pair_unsigned_long_unsigned_long_t, cuts: pyrosetta.rosetta.utility.vector1_unsigned_long) → None

C++: protocols::forge::methods::jumps_and_cuts_from_pose(class core::pose::Pose &, class utility::vector1<struct std::pair<unsigned long, unsigned long>, class std::allocator<struct std::pair<unsigned long, unsigned long> > > &, class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> void

pyrosetta.rosetta.protocols.forge.methods.jumps_connected_to_position(pos: int, ft: pyrosetta.rosetta.core.kinematics.FoldTree) → pyrosetta.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’.

C++: protocols::forge::methods::jumps_connected_to_position(const unsigned long, const class core::kinematics::FoldTree &) –> class utility::vector1<class core::kinematics::Edge, class std::allocator<class core::kinematics::Edge> >

pyrosetta.rosetta.protocols.forge.methods.linear_chainbreak(*args, **kwargs)

Overloaded function.

1. linear_chainbreak(pose: pyrosetta.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.

C++: protocols::forge::methods::linear_chainbreak(const class core::pose::Pose &, const unsigned long) –> double

2. linear_chainbreak(pose: pyrosetta.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.

C++: protocols::forge::methods::linear_chainbreak(class core::pose::Pose &, const unsigned long) –> double

pyrosetta.rosetta.protocols.forge.methods.make_star_foldtree(pose: pyrosetta.rosetta.core.pose.Pose, loops: pyrosetta.rosetta.protocols.loops.Loops) → None

C++: protocols::forge::methods::make_star_foldtree(class core::pose::Pose &, class protocols::loops::Loops) –> void

pyrosetta.rosetta.protocols.forge.methods.merge(*args, **kwargs)

Overloaded function.

1. merge(left_tree: pyrosetta.rosetta.core.kinematics.FoldTree, right_tree: pyrosetta.rosetta.core.kinematics.FoldTree) -> pyrosetta.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.

C++: protocols::forge::methods::merge(const class core::kinematics::FoldTree &, const class core::kinematics::FoldTree &) –> class core::kinematics::FoldTree

2. merge(left_tree: pyrosetta.rosetta.core.kinematics.FoldTree, left_position: int, right_tree: pyrosetta.rosetta.core.kinematics.FoldTree, right_position: int) -> pyrosetta.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.

C++: protocols::forge::methods::merge(const class core::kinematics::FoldTree &, const unsigned long, const class core::kinematics::FoldTree &, const unsigned long) –> class core::kinematics::FoldTree

3. merge(left_tree: pyrosetta.rosetta.core.kinematics.FoldTree, left_position: int, left_jump_atom: str, right_tree: pyrosetta.rosetta.core.kinematics.FoldTree, right_position: int, right_jump_atom: str) -> pyrosetta.rosetta.core.kinematics.FoldTree

4. merge(left_tree: pyrosetta.rosetta.core.kinematics.FoldTree, left_position: int, left_jump_atom: str, right_tree: pyrosetta.rosetta.core.kinematics.FoldTree, right_position: int, right_jump_atom: str, keep_stub_in_residue: bool) -> pyrosetta.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.

C++: protocols::forge::methods::merge(const class core::kinematics::FoldTree &, const unsigned long, const std::string &, const class core::kinematics::FoldTree &, const unsigned long, const std::string &, const bool) –> class core::kinematics::FoldTree

pyrosetta.rosetta.protocols.forge.methods.order(e: pyrosetta.rosetta.core.kinematics.Edge) → bool

enforce Edge has start <= stop (swap if necessary)

true if start and stop were swapped

C++: protocols::forge::methods::order(class core::kinematics::Edge &) –> bool

pyrosetta.rosetta.protocols.forge.methods.overlap_chainbreak(*args, **kwargs)

Overloaded function.

1. overlap_chainbreak(pose: pyrosetta.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.

C++: protocols::forge::methods::overlap_chainbreak(const class core::pose::Pose &, const unsigned long) –> double

2. overlap_chainbreak(pose: pyrosetta.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.

C++: protocols::forge::methods::overlap_chainbreak(class core::pose::Pose &, const unsigned long) –> double

pyrosetta.rosetta.protocols.forge.methods.parse_resfile_string_with_no_lockdown(pose: pyrosetta.rosetta.core.pose.Pose, the_task: pyrosetta.rosetta.core.pack.task.PackerTask, resfile_string: str) → pyrosetta.rosetta.utility.vector1_bool

C++: protocols::forge::methods::parse_resfile_string_with_no_lockdown(const class core::pose::Pose &, class core::pack::task::PackerTask &, const std::string &) –> class utility::vector1<bool, class std::allocator<bool> >

pyrosetta.rosetta.protocols.forge.methods.quadratic_chainbreak(*args, **kwargs)

Overloaded function.

1. quadratic_chainbreak(pose: pyrosetta.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.

C++: protocols::forge::methods::quadratic_chainbreak(const class core::pose::Pose &, const unsigned long) –> double

2. quadratic_chainbreak(pose: pyrosetta.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.

C++: protocols::forge::methods::quadratic_chainbreak(class core::pose::Pose &, const unsigned long) –> double

pyrosetta.rosetta.protocols.forge.methods.remodel_generic_taskfactory() → pyrosetta.rosetta.core.pack.task.TaskFactory

C++: protocols::forge::methods::remodel_generic_taskfactory() –> class std::shared_ptr<class core::pack::task::TaskFactory>

pyrosetta.rosetta.protocols.forge.methods.remove_cutpoint(v: int, ft: pyrosetta.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

C++: protocols::forge::methods::remove_cutpoint(const unsigned long, class core::kinematics::FoldTree &) –> bool

pyrosetta.rosetta.protocols.forge.methods.remove_cutpoint_variants(pose: pyrosetta.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

C++: protocols::forge::methods::remove_cutpoint_variants(class core::pose::Pose &, const unsigned long) –> bool

pyrosetta.rosetta.protocols.forge.methods.remove_cutpoints(cutpoints: pyrosetta.rosetta.utility.vector1_unsigned_long, ft: pyrosetta.rosetta.core.kinematics.FoldTree) → None

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.

C++: protocols::forge::methods::remove_cutpoints(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, class core::kinematics::FoldTree &) –> void

pyrosetta.rosetta.protocols.forge.methods.replace(original_tree: pyrosetta.rosetta.core.kinematics.FoldTree, replace_begin: int, replace_end: int, movemap: pyrosetta.rosetta.core.kinematics.MoveMap, replacement_tree: pyrosetta.rosetta.core.kinematics.FoldTree) → pyrosetta.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.

C++: protocols::forge::methods::replace(const class core::kinematics::FoldTree &, const unsigned long, const unsigned long, const class core::kinematics::MoveMap &, const class core::kinematics::FoldTree &) –> class core::kinematics::FoldTree

pyrosetta.rosetta.protocols.forge.methods.restore_residues(*args, **kwargs)

Overloaded function.

1. restore_residues(old2new: pyrosetta.rosetta.std.map_unsigned_long_unsigned_long, archive_pose: pyrosetta.rosetta.core.pose.Pose, pose: pyrosetta.rosetta.core.pose.Pose) -> None

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

C++: protocols::forge::methods::restore_residues(const class std::map<unsigned long, unsigned long, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, unsigned long> > > &, class core::pose::Pose &, class core::pose::Pose &) –> void

2. restore_residues(archive_pose: pyrosetta.rosetta.core.pose.Pose, pose: pyrosetta.rosetta.core.pose.Pose) -> None

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

C++: protocols::forge::methods::restore_residues(class core::pose::Pose &, class core::pose::Pose &) –> void

pyrosetta.rosetta.protocols.forge.methods.set_single_loop_fold_tree(pose: pyrosetta.rosetta.core.pose.Pose, loop: pyrosetta.rosetta.protocols.loops.Loop) → None

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.

C++: protocols::forge::methods::set_single_loop_fold_tree(class core::pose::Pose &, const class protocols::loops::Loop &) –> void

pyrosetta.rosetta.protocols.forge.methods.shift_jumps(ft: pyrosetta.rosetta.core.kinematics.FoldTree, mm: pyrosetta.rosetta.core.kinematics.MoveMap) → pyrosetta.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.

C++: protocols::forge::methods::shift_jumps(const class core::kinematics::FoldTree &, const class core::kinematics::MoveMap &) –> class core::kinematics::FoldTree

pyrosetta.rosetta.protocols.forge.methods.smallmer_from_largemer(*args, **kwargs)

Overloaded function.

1. smallmer_from_largemer(begin: pyrosetta.rosetta.core.fragment.ConstFrameIterator, end: pyrosetta.rosetta.core.fragment.ConstFrameIterator) -> pyrosetta.rosetta.core.fragment.ConstantLengthFragSet

2. smallmer_from_largemer(begin: pyrosetta.rosetta.core.fragment.ConstFrameIterator, end: pyrosetta.rosetta.core.fragment.ConstFrameIterator, smallmer_size: int) -> pyrosetta.rosetta.core.fragment.ConstantLengthFragSet

3. smallmer_from_largemer(begin: pyrosetta.rosetta.core.fragment.ConstFrameIterator, end: pyrosetta.rosetta.core.fragment.ConstFrameIterator, smallmer_size: int, all_possible_smallmers: bool) -> pyrosetta.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.

C++: protocols::forge::methods::smallmer_from_largemer(class core::fragment::ConstFrameIterator, class core::fragment::ConstFrameIterator, const unsigned long, const bool) –> class std::shared_ptr<class core::fragment::ConstantLengthFragSet>

pyrosetta.rosetta.protocols.forge.methods.trans_omega(left: int, right: int, pose: pyrosetta.rosetta.core.pose.Pose) → None

set omega to 180 for a range of residues [left, right]

C++: protocols::forge::methods::trans_omega(const unsigned long, const unsigned long, class core::pose::Pose &) –> void

pyrosetta.rosetta.protocols.forge.methods.union_interval(root: int, left: int, right: int, uf: pyrosetta.rosetta.utility.graph.DisjointSets) → None

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

C++: protocols::forge::methods::union_interval(const unsigned long, const unsigned long, const unsigned long, class utility::graph::DisjointSets &) –> void

pyrosetta.rosetta.protocols.forge.methods.vertex_exists(v: int, ft: pyrosetta.rosetta.core.kinematics.FoldTree) → bool

query if vertex already exists in fold tree

C++: protocols::forge::methods::vertex_exists(const unsigned long, const class core::kinematics::FoldTree &) –> bool