methods

    Functions:

      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

      1. 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

      1. 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

      1. 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

      2. 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

      1. 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

      1. 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

      1. 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