build¶

Bindings for protocols::forge::build namespace

class pyrosetta.rosetta.protocols.forge.build.Bridge¶

Bases: BuildInstruction

connect two contiguous but disjoint sections of a Pose into one: continuous section
Anchor residues [i,j] to bridge must be adjacent to each other in the: Pose (i+1 = j) and adjacent to a cutpoint. Both i and j will be idealized and marked as new moveable positions since the psi @ i and the phi @ j are undefined. Depending on the fold tree, this will cause a random swing either downstream or upstream of the bridge!

add_dependency_to(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, i: pyrosetta.rosetta.std.weak_ptr_const_protocols_forge_build_BuildInstruction_t) → None¶

add an instruction to this BuildInstruction’s dependency list

before this instruction’s modify() may complete properly, all
instructions in the dependency list must have completed modify() first

C++: protocols::forge::build::BuildInstruction::add_dependency_to(class std::weak_ptr<const class protocols::forge::build::BuildInstruction>) –> void

assign(self: pyrosetta.rosetta.protocols.forge.build.Bridge, rval: pyrosetta.rosetta.protocols.forge.build.Bridge) → pyrosetta.rosetta.protocols.forge.build.Bridge¶

copy assignment

C++: protocols::forge::build::Bridge::operator=(const class protocols::forge::build::Bridge &) –> class protocols::forge::build::Bridge &

attach_to(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

attach to a Pose’s conformation

C++: protocols::forge::build::BuildInstruction::attach_to(class core::pose::Pose &) –> void

clear_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None¶

clear the list of dependencies

C++: protocols::forge::build::BuildInstruction::clear_dependencies() –> void

clone(self: pyrosetta.rosetta.protocols.forge.build.Bridge) → pyrosetta.rosetta.protocols.forge.build.BuildInstruction¶

clone this object

C++: protocols::forge::build::Bridge::clone() const –> class std::shared_ptr<class protocols::forge::build::BuildInstruction>

compatible_with(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, rval: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

compares fixed and mutable positions to determine compatibility with: another instruction

override this to obtain custom compatibility check

C++: protocols::forge::build::BuildInstruction::compatible_with(const class protocols::forge::build::BuildInstruction &) const –> bool

creates_undefined_backbone(self: pyrosetta.rosetta.protocols.forge.build.Bridge) → bool¶

does this object create undefined backbone in the modified region?

C++: protocols::forge::build::Bridge::creates_undefined_backbone() const –> bool

defined_positions(self: pyrosetta.rosetta.protocols.forge.build.Bridge) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return a copy of the set of positions within the newly modified

region that has a defined conformation. E.g. existing or copied residues.

A set containing two positions – interval.left and interval.right.

This set can change wrt length changes in Pose/Conformation being: watched.

C++: protocols::forge::build::Bridge::defined_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.utility.vector1_std_weak_ptr_const_protocols_forge_build_BuildInstruction_t¶

the list of instructions whose modify() must complete before: the modify() for this instruction may be called successfully

C++: protocols::forge::build::BuildInstruction::dependencies() const –> const class utility::vector1<class std::weak_ptr<const class protocols::forge::build::BuildInstruction>, class std::allocator<class std::weak_ptr<const class protocols::forge::build::BuildInstruction> > > &

dependent_on(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, i: pyrosetta.rosetta.std.weak_ptr_const_protocols_forge_build_BuildInstruction_t) → bool¶

is this instruction dependent upon the given instruction?

C++: protocols::forge::build::BuildInstruction::dependent_on(class std::weak_ptr<const class protocols::forge::build::BuildInstruction>) const –> bool

detach_after_modify(*args, **kwargs)¶

Overloaded function.

detach_after_modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) -> bool

detach after modify()?

Ordinarily a modify() call consists of attaching as a
length obs of the Pose, actually doing the modify, and then detaching as a length obs of the Pose. This flag governs whether the last detach occurs.

C++: protocols::forge::build::BuildInstruction::detach_after_modify() const –> bool

detach_after_modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, flag: bool) -> None

set detach after modify()

Ordinarily a modify() call consists of attaching as a
length obs of the Pose, actually doing the modify, and then detaching as a length obs of the Pose. This flag governs whether the last detach occurs.

C++: protocols::forge::build::BuildInstruction::detach_after_modify(const bool) –> void

detach_from(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None¶

detach from a Pose’s conformation

C++: protocols::forge::build::BuildInstruction::detach_from() –> void

has_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

does this BuildInstruction have dependencies?

C++: protocols::forge::build::BuildInstruction::has_dependencies() const –> bool

interval(self: pyrosetta.rosetta.protocols.forge.build.Bridge) → pyrosetta.rosetta.protocols.forge.build.Interval¶

a copy of the working range of residues specifying the bridged region

including the anchors

This residue range can change wrt length changes in Pose /Conformation: being watched.

C++: protocols::forge::build::Bridge::interval() const –> struct protocols::forge::build::Interval

modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.protocols.forge.build.BuildInstructionState.Enum¶

modify this pose

the state of the BuildInstruction

C++: protocols::forge::build::BuildInstruction::modify(class core::pose::Pose &) –> enum protocols::forge::build::BuildInstructionState::Enum

modify_was_successful(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

Is the BuildInstruction’s state at MODIFY_WAS_SUCCESSFUL?

MODIFY_WAS_SUCCESSFUL indicates the BuildInstruction has
finished modifications to the Pose, and its residue indexing is now consistent with the newly modified Pose.

C++: protocols::forge::build::BuildInstruction::modify_was_successful() const –> bool

movemap(self: pyrosetta.rosetta.protocols.forge.build.Bridge) → pyrosetta.rosetta.core.kinematics.MoveMap¶

return a copy of the MoveMap that defines the moveable/fixed

positions/dofs for this instruction

a MoveMap with [interval.left, interval.right] bb & chi set to true: at the MoveMapTorsionID level
This set can change wrt length changes in Pose/Conformation being: watched.

C++: protocols::forge::build::Bridge::movemap() const –> class core::kinematics::MoveMap

n_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → int¶

the number of dependencies this BuildInstruction has

C++: protocols::forge::build::BuildInstruction::n_dependencies() const –> unsigned long

new_positions(self: pyrosetta.rosetta.protocols.forge.build.Bridge) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return a copy of the set of positions that are “new” and did: not exist in the original Pose.

A set containing positions spanning [interval.left+1, interval.right-1].

C++: protocols::forge::build::Bridge::new_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

on_length_change(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None¶

update any indexing wrt length change to Pose/Conformation being watched

C++: protocols::forge::build::BuildInstruction::on_length_change(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_append(self: pyrosetta.rosetta.protocols.forge.build.Bridge, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None¶

update indexing on residue append

C++: protocols::forge::build::Bridge::on_residue_append(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_delete(self: pyrosetta.rosetta.protocols.forge.build.Bridge, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None¶

update indexing on residue delete

C++: protocols::forge::build::Bridge::on_residue_delete(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_prepend(self: pyrosetta.rosetta.protocols.forge.build.Bridge, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None¶

update indexing on residue prepend

C++: protocols::forge::build::Bridge::on_residue_prepend(const struct core::conformation::signals::LengthEvent &) –> void

original_deleted_positions(self: pyrosetta.rosetta.protocols.forge.build.Bridge) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return set of positions within the original interval that will: be deleted in this BuildInstruction

A set containing the positions in [original.left+1, original.right-1].

C++: protocols::forge::build::Bridge::original_deleted_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_fixed_positions(self: pyrosetta.rosetta.protocols.forge.build.Bridge) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return set of any fixed positions necessary with respect to the original

interval and original Pose numbering

Used for ensuring build regions for instructions do not overlap and: so that jumps may be placed correctly.

empty set if no fixed positions necessary

C++: protocols::forge::build::Bridge::original_fixed_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_interval(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.protocols.forge.build.Interval¶

return original residue range of this instruction

C++: protocols::forge::build::BuildInstruction::original_interval() const –> const struct protocols::forge::build::Interval &

original_interval_valid(self: pyrosetta.rosetta.protocols.forge.build.Bridge) → bool¶

is the original interval storing valid information, or is empty: or being used for something else?

true, stores valid interval

C++: protocols::forge::build::Bridge::original_interval_valid() const –> bool

original_kept_positions(self: pyrosetta.rosetta.protocols.forge.build.Bridge) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return the set of positions within the original interval that: will be kept in this BuildInstruction

A set containing the endpoints of the original interval.

C++: protocols::forge::build::Bridge::original_kept_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_mutable_positions(self: pyrosetta.rosetta.protocols.forge.build.Bridge) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return set of any mutable positions necessary with respect to the original

interval and original Pose numbering

Used for ensuring build regions for instructions do not overlap and: so that jumps may be placed correctly.

C++: protocols::forge::build::Bridge::original_mutable_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

preexisting_positions(self: pyrosetta.rosetta.protocols.forge.build.Bridge) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return a copy of the set of positions within the new region: that were pre-existing in the original Pose prior to modify()

A set containing two positions – interval.left and interval.right.

C++: protocols::forge::build::Bridge::preexisting_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

ready(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

Is the BuildInstruction’s state at READY?

READY indicates the BuildInstruction has been reset
and is ready to modify a Pose.

C++: protocols::forge::build::BuildInstruction::ready() const –> bool

reset_accounting(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None¶

reset intervals, positions, etc to initial state and drop: observers. State set to READY.

C++: protocols::forge::build::BuildInstruction::reset_accounting() –> void

residue_type_set(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.core.chemical.ResidueTypeSet¶

the residue type set being used

C++: protocols::forge::build::BuildInstruction::residue_type_set() const –> const class core::chemical::ResidueTypeSet &

state(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.protocols.forge.build.BuildInstructionState.Enum¶

return the state of this BuildInstruction

C++: protocols::forge::build::BuildInstruction::state() const –> enum protocols::forge::build::BuildInstructionState::Enum

undefined_positions(self: pyrosetta.rosetta.protocols.forge.build.Bridge) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return a copy of the set of positions within the newly modified

region that has an undefined conformation. E.g. newly created residues.

A set containing positions spanning [interval.left+1, interval.right-1].

This set can change wrt length changes in Pose/Conformation being: watched.

C++: protocols::forge::build::Bridge::undefined_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

waiting_on_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

Is the BuildInstruction’s state at WAITING_ON_DEPENDENCIES?

WAITING_ON_DEPENDENCIES indicates
the BuildInstruction is waiting for its dependencies to be satisfied before allowing modifications to proceed.

C++: protocols::forge::build::BuildInstruction::waiting_on_dependencies() const –> bool

class pyrosetta.rosetta.protocols.forge.build.BuildInstruction¶

Bases: pybind11_object

tracks modifications to be made and is capable of making residue length changes on a Pose

add_dependency_to(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, i: pyrosetta.rosetta.std.weak_ptr_const_protocols_forge_build_BuildInstruction_t) → None¶

add an instruction to this BuildInstruction’s dependency list

before this instruction’s modify() may complete properly, all
instructions in the dependency list must have completed modify() first

C++: protocols::forge::build::BuildInstruction::add_dependency_to(class std::weak_ptr<const class protocols::forge::build::BuildInstruction>) –> void

assign(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, rval: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.protocols.forge.build.BuildInstruction¶

copy assignment

C++: protocols::forge::build::BuildInstruction::operator=(const class protocols::forge::build::BuildInstruction &) –> class protocols::forge::build::BuildInstruction &

attach_to(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

attach to a Pose’s conformation

C++: protocols::forge::build::BuildInstruction::attach_to(class core::pose::Pose &) –> void

clear_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None¶

clear the list of dependencies

C++: protocols::forge::build::BuildInstruction::clear_dependencies() –> void

clone(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.protocols.forge.build.BuildInstruction¶

clone this object

C++: protocols::forge::build::BuildInstruction::clone() const –> class std::shared_ptr<class protocols::forge::build::BuildInstruction>

compatible_with(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, rval: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

compares fixed and mutable positions to determine compatibility with: another instruction

override this to obtain custom compatibility check

C++: protocols::forge::build::BuildInstruction::compatible_with(const class protocols::forge::build::BuildInstruction &) const –> bool

creates_undefined_backbone(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

does this object create undefined backbone in the modified region?

C++: protocols::forge::build::BuildInstruction::creates_undefined_backbone() const –> bool

defined_positions(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return a copy of the set of positions within the newly modified

region that has a defined conformation. E.g. existing or copied residues.

This set can change wrt length changes in Pose/Conformation being: watched.

C++: protocols::forge::build::BuildInstruction::defined_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.utility.vector1_std_weak_ptr_const_protocols_forge_build_BuildInstruction_t¶

the list of instructions whose modify() must complete before: the modify() for this instruction may be called successfully

C++: protocols::forge::build::BuildInstruction::dependencies() const –> const class utility::vector1<class std::weak_ptr<const class protocols::forge::build::BuildInstruction>, class std::allocator<class std::weak_ptr<const class protocols::forge::build::BuildInstruction> > > &

dependent_on(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, i: pyrosetta.rosetta.std.weak_ptr_const_protocols_forge_build_BuildInstruction_t) → bool¶

is this instruction dependent upon the given instruction?

C++: protocols::forge::build::BuildInstruction::dependent_on(class std::weak_ptr<const class protocols::forge::build::BuildInstruction>) const –> bool

detach_after_modify(*args, **kwargs)¶

Overloaded function.

detach_after_modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) -> bool

detach after modify()?

Ordinarily a modify() call consists of attaching as a
length obs of the Pose, actually doing the modify, and then detaching as a length obs of the Pose. This flag governs whether the last detach occurs.

C++: protocols::forge::build::BuildInstruction::detach_after_modify() const –> bool

detach_after_modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, flag: bool) -> None

set detach after modify()

Ordinarily a modify() call consists of attaching as a
length obs of the Pose, actually doing the modify, and then detaching as a length obs of the Pose. This flag governs whether the last detach occurs.

C++: protocols::forge::build::BuildInstruction::detach_after_modify(const bool) –> void

detach_from(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None¶

detach from a Pose’s conformation

C++: protocols::forge::build::BuildInstruction::detach_from() –> void

has_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

does this BuildInstruction have dependencies?

C++: protocols::forge::build::BuildInstruction::has_dependencies() const –> bool

interval(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.protocols.forge.build.Interval¶

a copy of the working range of residues specifying the modified region

This residue range can change wrt length changes in Pose /Conformation
being watched.

C++: protocols::forge::build::BuildInstruction::interval() const –> struct protocols::forge::build::Interval

modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.protocols.forge.build.BuildInstructionState.Enum¶

modify this pose

the state of the BuildInstruction

C++: protocols::forge::build::BuildInstruction::modify(class core::pose::Pose &) –> enum protocols::forge::build::BuildInstructionState::Enum

modify_was_successful(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

Is the BuildInstruction’s state at MODIFY_WAS_SUCCESSFUL?

MODIFY_WAS_SUCCESSFUL indicates the BuildInstruction has
finished modifications to the Pose, and its residue indexing is now consistent with the newly modified Pose.

C++: protocols::forge::build::BuildInstruction::modify_was_successful() const –> bool

movemap(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.core.kinematics.MoveMap¶

return a copy of the MoveMap that defines the moveable/fixed

positions/dofs for this instruction

This set can change wrt length changes in Pose/Conformation being: watched.

C++: protocols::forge::build::BuildInstruction::movemap() const –> class core::kinematics::MoveMap

n_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → int¶

the number of dependencies this BuildInstruction has

C++: protocols::forge::build::BuildInstruction::n_dependencies() const –> unsigned long

new_positions(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return a copy of the set of positions that are “new” and did: not exist in the original Pose.

C++: protocols::forge::build::BuildInstruction::new_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

on_length_change(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None¶

update any indexing wrt length change to Pose/Conformation being watched

C++: protocols::forge::build::BuildInstruction::on_length_change(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_append(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None¶

update indexing on residue append

C++: protocols::forge::build::BuildInstruction::on_residue_append(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_delete(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None¶

update indexing on residue delete

C++: protocols::forge::build::BuildInstruction::on_residue_delete(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_prepend(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None¶

update indexing on residue prepend

C++: protocols::forge::build::BuildInstruction::on_residue_prepend(const struct core::conformation::signals::LengthEvent &) –> void

original_deleted_positions(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return set of positions within the original interval that will: be deleted in this BuildInstruction

C++: protocols::forge::build::BuildInstruction::original_deleted_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_fixed_positions(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return set of any fixed positions necessary with respect to the original

interval and original Pose numbering

Used for ensuring build regions for instructions do not overlap and: so that jumps may be placed correctly.

empty set if no fixed positions necessary

C++: protocols::forge::build::BuildInstruction::original_fixed_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_interval(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.protocols.forge.build.Interval¶

return original residue range of this instruction

C++: protocols::forge::build::BuildInstruction::original_interval() const –> const struct protocols::forge::build::Interval &

original_interval_valid(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

is the original interval storing valid information, or is empty: or being used for something else?

C++: protocols::forge::build::BuildInstruction::original_interval_valid() const –> bool

original_kept_positions(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return the set of positions within the original interval that: will be kept in this BuildInstruction

C++: protocols::forge::build::BuildInstruction::original_kept_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_mutable_positions(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return set of any mutable positions necessary with respect to the original

interval and original Pose numbering

Used for ensuring build regions for instructions do not overlap and: so that jumps may be placed correctly.

C++: protocols::forge::build::BuildInstruction::original_mutable_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

preexisting_positions(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return a copy of the set of positions within the new region: that were pre-existing in the original Pose prior to modify()

C++: protocols::forge::build::BuildInstruction::preexisting_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

ready(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

Is the BuildInstruction’s state at READY?

READY indicates the BuildInstruction has been reset
and is ready to modify a Pose.

C++: protocols::forge::build::BuildInstruction::ready() const –> bool

reset_accounting(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None¶

reset intervals, positions, etc to initial state and drop: observers. State set to READY.

C++: protocols::forge::build::BuildInstruction::reset_accounting() –> void

residue_type_set(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.core.chemical.ResidueTypeSet¶

the residue type set being used

C++: protocols::forge::build::BuildInstruction::residue_type_set() const –> const class core::chemical::ResidueTypeSet &

state(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.protocols.forge.build.BuildInstructionState.Enum¶

return the state of this BuildInstruction

C++: protocols::forge::build::BuildInstruction::state() const –> enum protocols::forge::build::BuildInstructionState::Enum

undefined_positions(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return a copy of the set of positions within the newly modified

region that has an undefined conformation. E.g. newly created residues.

This set can change wrt length changes in Pose/Conformation being: watched.

C++: protocols::forge::build::BuildInstruction::undefined_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

waiting_on_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

Is the BuildInstruction’s state at WAITING_ON_DEPENDENCIES?

WAITING_ON_DEPENDENCIES indicates
the BuildInstruction is waiting for its dependencies to be satisfied before allowing modifications to proceed.

C++: protocols::forge::build::BuildInstruction::waiting_on_dependencies() const –> bool

class pyrosetta.rosetta.protocols.forge.build.BuildManager¶

Bases: pybind11_object

a container for managing BuildInstructions

Compatibility checks wrt dependencies currently do not exist.: It remains to be seen how to handle this.

add(self: pyrosetta.rosetta.protocols.forge.build.BuildManager, bi: protocols::forge::build::BuildInstruction) → None¶

add an instruction directly (no copy)

C++: protocols::forge::build::BuildManager::add(class std::shared_ptr<class protocols::forge::build::BuildInstruction>) –> void

assign(self: pyrosetta.rosetta.protocols.forge.build.BuildManager, rval: pyrosetta.rosetta.protocols.forge.build.BuildManager) → pyrosetta.rosetta.protocols.forge.build.BuildManager¶

copy assignment

C++: protocols::forge::build::BuildManager::operator=(const class protocols::forge::build::BuildManager &) –> class protocols::forge::build::BuildManager &

clear(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → None¶

clear all instructions

C++: protocols::forge::build::BuildManager::clear() –> void

clear_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → int¶

clear all dependencies

number of dependencies dropped

C++: protocols::forge::build::BuildManager::clear_dependencies() –> unsigned long

clone(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → pyrosetta.rosetta.protocols.forge.build.BuildManager¶

clone this object

C++: protocols::forge::build::BuildManager::clone() const –> class std::shared_ptr<class protocols::forge::build::BuildManager>

compatibility_check(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → bool¶

check if instruction regions are compatible with each other

true if regions compatible, false if regions incompatible

C++: protocols::forge::build::BuildManager::compatibility_check() const –> bool

create(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → pyrosetta.rosetta.protocols.forge.build.BuildManager¶

create a new instance of this type of object

C++: protocols::forge::build::BuildManager::create() const –> class std::shared_ptr<class protocols::forge::build::BuildManager>

create_directed_dependency(self: pyrosetta.rosetta.protocols.forge.build.BuildManager, u: protocols::forge::build::BuildInstruction, v: protocols::forge::build::BuildInstruction) → None¶

create a directed dependency: instruction ‘u’ must complete: before instruction ‘v’ can complete, i.e. ‘v’ depends on ‘u’

C++: protocols::forge::build::BuildManager::create_directed_dependency(class std::shared_ptr<class protocols::forge::build::BuildInstruction>, class std::shared_ptr<class protocols::forge::build::BuildInstruction>) –> void

defined_positions(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return a copy of the set of positions within the newly modified: regions that have a defined conformation. E.g. existing or copied residues.

If modify() has not been called will return an empty set.

C++: protocols::forge::build::BuildManager::defined_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

dependencies_exist(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → bool¶

have dependencies been defined?

C++: protocols::forge::build::BuildManager::dependencies_exist() const –> bool

dummy_modify(self: pyrosetta.rosetta.protocols.forge.build.BuildManager, nres: int) → int¶

a dry run of modify() with an all-ala helical Pose of the given

length

The length of the dummy structure to use.

The final length of the modified Pose.

Use this to do a fake run of modify() if you need any: position or mapping information prior to actually calling modify().

C++: protocols::forge::build::BuildManager::dummy_modify(const unsigned long) –> unsigned long

empty(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → bool¶

no instructions?

C++: protocols::forge::build::BuildManager::empty() const –> bool

modified2original_interval_endpoints(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → pyrosetta.rosetta.std.map_unsigned_long_unsigned_long¶

return a map translating modified interval endpoints to original

interval endpoints

modified intervals with no equivalent original interval (e.g. cases: such as insertions) will not appear in this map

map; empty if modify() has not yet been called

C++: protocols::forge::build::BuildManager::modified2original_interval_endpoints() const –> class std::map<unsigned long, unsigned long, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, unsigned long> > >

modify(self: pyrosetta.rosetta.protocols.forge.build.BuildManager, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.std.map_unsigned_long_unsigned_long¶

modify the pose using the instructions in this container

the Pose to modify

a map translating original residue -> modified residue for
positions that existed within both the original Pose and modified Pose

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

movemap(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → pyrosetta.rosetta.core.kinematics.MoveMap¶

return the combined movemap from all instructions in this manager

If modify() has not been called will return an empty MoveMap.

C++: protocols::forge::build::BuildManager::movemap() const –> class core::kinematics::MoveMap

movemap_as_OP(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → pyrosetta.rosetta.core.kinematics.MoveMap¶: C++: protocols::forge::build::BuildManager::movemap_as_OP() const –> class std::shared_ptr<class core::kinematics::MoveMap>

n_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → int¶

the number of dependencies currently defined (i.e. # of edges in: the dependency graph)

C++: protocols::forge::build::BuildManager::n_dependencies() const –> unsigned long

new_positions(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return a copy of the set of positions that are “new” and did: not exist in the original Pose.

If modify() has not been called will return an empty set.

C++: protocols::forge::build::BuildManager::new_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original2modified(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → pyrosetta.rosetta.std.map_unsigned_long_unsigned_long¶

return a map translating original residue -> modified residue for: positions that existed within both the original Pose and modified Pose

map; empty if modify() has not yet been called

C++: protocols::forge::build::BuildManager::original2modified() const –> const class std::map<unsigned long, unsigned long, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, unsigned long> > > &

original2modified_interval_endpoints(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → pyrosetta.rosetta.std.map_unsigned_long_unsigned_long¶

return a map translating original interval endpoints to modified

interval endpoints

modified intervals with no equivalent original interval (e.g. cases: such as insertions) will not appear in this map

map; empty if modify() has not yet been called

C++: protocols::forge::build::BuildManager::original2modified_interval_endpoints() const –> class std::map<unsigned long, unsigned long, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, unsigned long> > >

original_deleted_positions(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return set of positions within the original intervals that will: be deleted by the BuildInstructions

returns valid data even without calling modify()

C++: protocols::forge::build::BuildManager::original_deleted_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_kept_positions(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return the set of positions within the original intervals that: will be kept by the BuildInstructions

returns valid data even without calling modify()

C++: protocols::forge::build::BuildManager::original_kept_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

positions(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return all positions within the modified intervals

Since this encompasses everything this is typically not useful
except for overall tracking purposes.

If modify() has not been called will return an empty set.

C++: protocols::forge::build::BuildManager::positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

preexisting_positions(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return the set of positions within the new regions that were: pre-existing in the original Pose prior to calling modify()

If modify() has not been called will return an empty set.

C++: protocols::forge::build::BuildManager::preexisting_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

reset_accounting(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → None¶

reset all accounting info (intervals, positions, etc) to initial: state

C++: protocols::forge::build::BuildManager::reset_accounting() –> void

sequence_mapping(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → pyrosetta.rosetta.core.id.SequenceMapping¶

SequenceMapping consistent with the original -> modified mapping from the

most recent modify() call

valid Sequence mapping if modify() was called; otherwise returns: NULL
This mapping contains the same information as original2modified(): combined with original2modified_interval_endpoints().

C++: protocols::forge::build::BuildManager::sequence_mapping() const –> class std::shared_ptr<const class core::id::SequenceMapping>

size(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → int¶

current number of instructions

C++: protocols::forge::build::BuildManager::size() const –> unsigned long

undefined_positions(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return a copy of the set of positions within the newly modified: regions that have an undefined conformation. E.g. newly created residues.

If modify() has not been called will return an empty set.

C++: protocols::forge::build::BuildManager::undefined_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

union_of_intervals_containing_undefined_positions(self: pyrosetta.rosetta.protocols.forge.build.BuildManager) → pyrosetta.rosetta.std.set_unsigned_long_t¶

the positions representing the union of all intervals containing

positions with undefined conformation

Useful as a reference for defining neighborhoods around: loop modeled regions.

If modify() has not been called will return an empty set.

C++: protocols::forge::build::BuildManager::union_of_intervals_containing_undefined_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

class pyrosetta.rosetta.protocols.forge.build.ConnectRight¶

Bases: BuildInstruction

instruction to connect one Pose onto the right side of another

Denote pose_left = [a,b] and pose_right = [c,d] and the newly: connected pose_left + pose_right = pose_total = [a,d]. If ‘b’ of pose_left is an upper terminus or ‘c’ of pose_right is a lower terminus, then ConnectRight will start a new chain in the Conformation at ‘c’ when constructing pose_total, otherwise it will continue the chain at ‘b’.

add_dependency_to(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, i: pyrosetta.rosetta.std.weak_ptr_const_protocols_forge_build_BuildInstruction_t) → None¶

add an instruction to this BuildInstruction’s dependency list

before this instruction’s modify() may complete properly, all
instructions in the dependency list must have completed modify() first

C++: protocols::forge::build::BuildInstruction::add_dependency_to(class std::weak_ptr<const class protocols::forge::build::BuildInstruction>) –> void

assign(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight, rval: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.protocols.forge.build.ConnectRight¶

copy assignment

C++: protocols::forge::build::ConnectRight::operator=(const class protocols::forge::build::ConnectRight &) –> class protocols::forge::build::ConnectRight &

attach_to(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

attach to a Pose’s conformation

C++: protocols::forge::build::BuildInstruction::attach_to(class core::pose::Pose &) –> void

clear_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None¶

clear the list of dependencies

C++: protocols::forge::build::BuildInstruction::clear_dependencies() –> void

clone(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.protocols.forge.build.BuildInstruction¶

clone this object

C++: protocols::forge::build::ConnectRight::clone() const –> class std::shared_ptr<class protocols::forge::build::BuildInstruction>

compatible_with(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, rval: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

compares fixed and mutable positions to determine compatibility with: another instruction

override this to obtain custom compatibility check

C++: protocols::forge::build::BuildInstruction::compatible_with(const class protocols::forge::build::BuildInstruction &) const –> bool

creates_undefined_backbone(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → bool¶

does this object create undefined backbone in the modified region?

false

C++: protocols::forge::build::ConnectRight::creates_undefined_backbone() const –> bool

defined_positions(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return a copy of the set of positions within the newly modified

region that has a defined conformation. E.g. existing or copied residues.

A set spanning the entire interval – all positions are defined.

This set can change wrt length changes in Pose/Conformation being: watched.

C++: protocols::forge::build::ConnectRight::defined_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.utility.vector1_std_weak_ptr_const_protocols_forge_build_BuildInstruction_t¶

the list of instructions whose modify() must complete before: the modify() for this instruction may be called successfully

C++: protocols::forge::build::BuildInstruction::dependencies() const –> const class utility::vector1<class std::weak_ptr<const class protocols::forge::build::BuildInstruction>, class std::allocator<class std::weak_ptr<const class protocols::forge::build::BuildInstruction> > > &

dependent_on(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, i: pyrosetta.rosetta.std.weak_ptr_const_protocols_forge_build_BuildInstruction_t) → bool¶

is this instruction dependent upon the given instruction?

C++: protocols::forge::build::BuildInstruction::dependent_on(class std::weak_ptr<const class protocols::forge::build::BuildInstruction>) const –> bool

detach_after_modify(*args, **kwargs)¶

Overloaded function.

detach_after_modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) -> bool

detach after modify()?

Ordinarily a modify() call consists of attaching as a
length obs of the Pose, actually doing the modify, and then detaching as a length obs of the Pose. This flag governs whether the last detach occurs.

C++: protocols::forge::build::BuildInstruction::detach_after_modify() const –> bool

detach_after_modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, flag: bool) -> None

set detach after modify()

Ordinarily a modify() call consists of attaching as a
length obs of the Pose, actually doing the modify, and then detaching as a length obs of the Pose. This flag governs whether the last detach occurs.

C++: protocols::forge::build::BuildInstruction::detach_after_modify(const bool) –> void

detach_from(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None¶

detach from a Pose’s conformation

C++: protocols::forge::build::BuildInstruction::detach_from() –> void

extract_rt(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight, pose: pyrosetta.rosetta.core.pose.Pose, jump_start_residue: int, jump_stop_residue: int) → None¶

extract appropriately computed transform between two stubs that

represent a jump in the given Pose between the two residues and set it as the rt for this ConnectRight

The Pose to use.

The starting residue of the jump.: This residue should be the equivalent of the jump position on pose_left.
The stopping residue of the jump.: This residue should be the equivalent of the jump position on pose_right.
Uses left_stub_atoms() and right_stub_atoms() as the stub atoms: to compute the transform. Remember to set use_rt() to True after calling this function if you want to actually use the transform during modify().

C++: protocols::forge::build::ConnectRight::extract_rt(const class core::pose::Pose &, const unsigned long, const unsigned long) –> void

has_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

does this BuildInstruction have dependencies?

C++: protocols::forge::build::BuildInstruction::has_dependencies() const –> bool

interval(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.protocols.forge.build.Interval¶

a copy of the working range of residues specifying the modified region

before modify() holds [1, pose_right.size()]; after
modify() holds [1 + pose_left.size(), pose_right.n_residue + pose_left.size()]

This can change if listening to Conformation LengthEvents

C++: protocols::forge::build::ConnectRight::interval() const –> struct protocols::forge::build::Interval

left_stub_atoms(*args, **kwargs)¶

Overloaded function.

left_stub_atoms(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) -> pyrosetta.rosetta.utility.vector1_std_string

Use these atoms to compute the stub on pose_left.

Default [“CA”, “N”, “CA”, “C”].

This is an array with 4 elements in the same order as Stub: initialization: ‘center atom’, ‘point1’, ‘point2’, ‘point3’. See Stub docs for more details.

C++: protocols::forge::build::ConnectRight::left_stub_atoms() const –> const class utility::vector1<std::string, class std::allocator<std::string > > &

left_stub_atoms(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight, atoms: pyrosetta.rosetta.utility.vector1_std_string) -> None

Use these atoms to compute the stub on pose_left.

Default [“CA”, “N”, “CA”, “C”].

This is an array with 4 elements in the same order as Stub: initialization: ‘center atom’, ‘point1’, ‘point2’, ‘point3’. See Stub docs for more details.

C++: protocols::forge::build::ConnectRight::left_stub_atoms(const class utility::vector1<std::string, class std::allocator<std::string > > &) –> void

modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.protocols.forge.build.BuildInstructionState.Enum¶

modify this pose

the state of the BuildInstruction

C++: protocols::forge::build::BuildInstruction::modify(class core::pose::Pose &) –> enum protocols::forge::build::BuildInstructionState::Enum

modify_was_successful(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

Is the BuildInstruction’s state at MODIFY_WAS_SUCCESSFUL?

MODIFY_WAS_SUCCESSFUL indicates the BuildInstruction has
finished modifications to the Pose, and its residue indexing is now consistent with the newly modified Pose.

C++: protocols::forge::build::BuildInstruction::modify_was_successful() const –> bool

movemap(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.core.kinematics.MoveMap¶

return a copy of the MoveMap that defines the moveable/fixed

positions/dofs for this instruction

a MoveMap with [interval.left, interval.right] bb set to false: at the MoveMapTorsionID level
This set can change wrt length changes in Pose/Conformation being: watched.

C++: protocols::forge::build::ConnectRight::movemap() const –> class core::kinematics::MoveMap

n_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → int¶

the number of dependencies this BuildInstruction has

C++: protocols::forge::build::BuildInstruction::n_dependencies() const –> unsigned long

new_positions(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return a copy of the set of positions that are “new” and did: not exist in the original Pose.

A set spanning the entire interval – all positions are new.

C++: protocols::forge::build::ConnectRight::new_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

on_length_change(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None¶

update any indexing wrt length change to Pose/Conformation being watched

C++: protocols::forge::build::BuildInstruction::on_length_change(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_append(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None¶

update indexing on residue append

C++: protocols::forge::build::ConnectRight::on_residue_append(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_delete(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None¶

update indexing on residue delete

C++: protocols::forge::build::ConnectRight::on_residue_delete(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_prepend(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None¶

update indexing on residue prepend

C++: protocols::forge::build::ConnectRight::on_residue_prepend(const struct core::conformation::signals::LengthEvent &) –> void

original_deleted_positions(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return set of positions within the original interval that will: be deleted in this BuildInstruction

An empty set – no positions are deleted.

C++: protocols::forge::build::ConnectRight::original_deleted_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_fixed_positions(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return set of any fixed positions necessary with respect to the original

interval and original Pose numbering

Used for ensuring build regions for instructions do not overlap and: so that jumps may be placed correctly.

empty set if no fixed positions

C++: protocols::forge::build::ConnectRight::original_fixed_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_interval(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.protocols.forge.build.Interval¶

return original residue range of this instruction

C++: protocols::forge::build::BuildInstruction::original_interval() const –> const struct protocols::forge::build::Interval &

original_interval_valid(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → bool¶

is the original interval storing valid information, or is empty: or being used for something else?

false, stores invalid interval

C++: protocols::forge::build::ConnectRight::original_interval_valid() const –> bool

original_kept_positions(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return the set of positions within the original interval that: will be kept in this BuildInstruction

An empty set – no positions are kept.

C++: protocols::forge::build::ConnectRight::original_kept_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_mutable_positions(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return set of any mutable positions necessary with respect to the original

interval and original Pose numbering

Used for ensuring build regions for instructions do not overlap and: so that jumps may be placed correctly.

empty set if no mutable positions

C++: protocols::forge::build::ConnectRight::original_mutable_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

pose_right(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.core.pose.Pose¶

connect this pose to the right of pose_left when modify( pose_left ): is called

C++: protocols::forge::build::ConnectRight::pose_right() –> const class core::pose::Pose &

preexisting_positions(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return a copy of the set of positions within the new region: that were pre-existing in the original Pose prior to modify()

An empty set – no positions are pre-existing.

C++: protocols::forge::build::ConnectRight::preexisting_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

ready(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

Is the BuildInstruction’s state at READY?

READY indicates the BuildInstruction has been reset
and is ready to modify a Pose.

C++: protocols::forge::build::BuildInstruction::ready() const –> bool

reset_accounting(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None¶

reset intervals, positions, etc to initial state and drop: observers. State set to READY.

C++: protocols::forge::build::BuildInstruction::reset_accounting() –> void

residue_type_set(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.core.chemical.ResidueTypeSet¶

the residue type set being used

C++: protocols::forge::build::BuildInstruction::residue_type_set() const –> const class core::chemical::ResidueTypeSet &

right_stub_atoms(*args, **kwargs)¶

Overloaded function.

right_stub_atoms(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) -> pyrosetta.rosetta.utility.vector1_std_string

Use these atoms to compute the stub on pose_right.

Default [“CA”, “N”, “CA”, “C”].

This is an array with 4 elements in the same order as Stub: initialization: ‘center atom’, ‘point1’, ‘point2’, ‘point3’. See Stub docs for more details.

C++: protocols::forge::build::ConnectRight::right_stub_atoms() const –> const class utility::vector1<std::string, class std::allocator<std::string > > &

right_stub_atoms(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight, atoms: pyrosetta.rosetta.utility.vector1_std_string) -> None

Use these atoms to compute the stub on pose_right.

Default [“CA”, “N”, “CA”, “C”].

This is an array with 4 elements in the same order as Stub: initialization: ‘center atom’, ‘point1’, ‘point2’, ‘point3’. See Stub docs for more details.

C++: protocols::forge::build::ConnectRight::right_stub_atoms(const class utility::vector1<std::string, class std::allocator<std::string > > &) –> void

rt(*args, **kwargs)¶

Overloaded function.

rt(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) -> pyrosetta.rosetta.core.kinematics.RT

the rotation-translation representing an explicit transform from: the stub on pose_left to the stub on pose_right, i.e. the representation of the “jump”

C++: protocols::forge::build::ConnectRight::rt() –> const class core::kinematics::RT &

rt(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight, transform: pyrosetta.rosetta.core.kinematics.RT) -> None

the rotation-translation representing an explicit transform from: the stub on pose_left to the stub on pose_right, i.e. the representation of the “jump”

C++: protocols::forge::build::ConnectRight::rt(const class core::kinematics::RT &) –> void

state(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.protocols.forge.build.BuildInstructionState.Enum¶

return the state of this BuildInstruction

C++: protocols::forge::build::BuildInstruction::state() const –> enum protocols::forge::build::BuildInstructionState::Enum

undefined_positions(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return a copy of the set of positions within the newly modified

region that has an undefined conformation. E.g. newly created residues.

An empty set – no undefined positions.

This set can change wrt length changes in Pose/Conformation being: watched.

C++: protocols::forge::build::ConnectRight::undefined_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

use_rt(*args, **kwargs)¶

Overloaded function.

use_rt(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) -> bool

apply the transform over the jump connection between pose_left and: pose_right? default False

C++: protocols::forge::build::ConnectRight::use_rt() const –> bool

use_rt(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight, flag: bool) -> None

apply the transform over the jump connection between pose_left and: pose_right? default False

C++: protocols::forge::build::ConnectRight::use_rt(const bool) –> void

waiting_on_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

Is the BuildInstruction’s state at WAITING_ON_DEPENDENCIES?

WAITING_ON_DEPENDENCIES indicates
the BuildInstruction is waiting for its dependencies to be satisfied before allowing modifications to proceed.

C++: protocols::forge::build::BuildInstruction::waiting_on_dependencies() const –> bool

class pyrosetta.rosetta.protocols.forge.build.CountFromLeft¶

Bases: RelativeSequencePosition

count starting from interval().left in a BuildInstruction

assign(self: pyrosetta.rosetta.protocols.forge.build.CountFromLeft, : pyrosetta.rosetta.protocols.forge.build.CountFromLeft) → pyrosetta.rosetta.protocols.forge.build.CountFromLeft¶: C++: protocols::forge::build::CountFromLeft::operator=(const struct protocols::forge::build::CountFromLeft &) –> struct protocols::forge::build::CountFromLeft &

clone(self: pyrosetta.rosetta.protocols.forge.build.CountFromLeft) → pyrosetta.rosetta.protocols.forge.build.RelativeSequencePosition¶: C++: protocols::forge::build::CountFromLeft::clone() const –> class std::shared_ptr<struct protocols::forge::build::RelativeSequencePosition>

property left_skip¶

property p¶

class pyrosetta.rosetta.protocols.forge.build.GrowLeft¶

Bases: BuildInstruction

instruction to create an n-side extension

Use this for n-side insertions, but typically not n-terminal: extensions unless necessary. It does not automatically cover the additional residue on the right endpoint that needs to move during n-terminal extensions due to invalid phi torsion. For that case, use the SegmentRebuild class replacing the n-terminal residue with desired length+1.

aa(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft) → str¶

get annotated amino acid string

C++: protocols::forge::build::GrowLeft::aa() const –> const std::string &

add_dependency_to(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, i: pyrosetta.rosetta.std.weak_ptr_const_protocols_forge_build_BuildInstruction_t) → None¶

add an instruction to this BuildInstruction’s dependency list

before this instruction’s modify() may complete properly, all
instructions in the dependency list must have completed modify() first

C++: protocols::forge::build::BuildInstruction::add_dependency_to(class std::weak_ptr<const class protocols::forge::build::BuildInstruction>) –> void

assign(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft, rval: pyrosetta.rosetta.protocols.forge.build.GrowLeft) → pyrosetta.rosetta.protocols.forge.build.GrowLeft¶

copy assignment

C++: protocols::forge::build::GrowLeft::operator=(const class protocols::forge::build::GrowLeft &) –> class protocols::forge::build::GrowLeft &

attach_to(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

attach to a Pose’s conformation

C++: protocols::forge::build::BuildInstruction::attach_to(class core::pose::Pose &) –> void

clear_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None¶

clear the list of dependencies

C++: protocols::forge::build::BuildInstruction::clear_dependencies() –> void

clone(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft) → pyrosetta.rosetta.protocols.forge.build.BuildInstruction¶

clone this object

C++: protocols::forge::build::GrowLeft::clone() const –> class std::shared_ptr<class protocols::forge::build::BuildInstruction>

compatible_with(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, rval: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

compares fixed and mutable positions to determine compatibility with: another instruction

override this to obtain custom compatibility check

C++: protocols::forge::build::BuildInstruction::compatible_with(const class protocols::forge::build::BuildInstruction &) const –> bool

creates_undefined_backbone(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft) → bool¶

does this object create undefined backbone in the modified region?

true

C++: protocols::forge::build::GrowLeft::creates_undefined_backbone() const –> bool

defined_positions(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return a copy of the set of positions within the newly modified

region that has a defined conformation. E.g. existing or copied residues.

An empty set – no positions are defined.

This set can change wrt length changes in Pose/Conformation being: watched.

C++: protocols::forge::build::GrowLeft::defined_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.utility.vector1_std_weak_ptr_const_protocols_forge_build_BuildInstruction_t¶

the list of instructions whose modify() must complete before: the modify() for this instruction may be called successfully

C++: protocols::forge::build::BuildInstruction::dependencies() const –> const class utility::vector1<class std::weak_ptr<const class protocols::forge::build::BuildInstruction>, class std::allocator<class std::weak_ptr<const class protocols::forge::build::BuildInstruction> > > &

dependent_on(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, i: pyrosetta.rosetta.std.weak_ptr_const_protocols_forge_build_BuildInstruction_t) → bool¶

is this instruction dependent upon the given instruction?

C++: protocols::forge::build::BuildInstruction::dependent_on(class std::weak_ptr<const class protocols::forge::build::BuildInstruction>) const –> bool

detach_after_modify(*args, **kwargs)¶

Overloaded function.

detach_after_modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) -> bool

detach after modify()?

Ordinarily a modify() call consists of attaching as a
length obs of the Pose, actually doing the modify, and then detaching as a length obs of the Pose. This flag governs whether the last detach occurs.

C++: protocols::forge::build::BuildInstruction::detach_after_modify() const –> bool

detach_after_modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, flag: bool) -> None

set detach after modify()

Ordinarily a modify() call consists of attaching as a
length obs of the Pose, actually doing the modify, and then detaching as a length obs of the Pose. This flag governs whether the last detach occurs.

C++: protocols::forge::build::BuildInstruction::detach_after_modify(const bool) –> void

detach_from(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None¶

detach from a Pose’s conformation

C++: protocols::forge::build::BuildInstruction::detach_from() –> void

has_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

does this BuildInstruction have dependencies?

C++: protocols::forge::build::BuildInstruction::has_dependencies() const –> bool

interval(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft) → pyrosetta.rosetta.protocols.forge.build.Interval¶

a copy of the working range of residues specifying the modified region

This can change if listening to Conformation LengthEvents

C++: protocols::forge::build::GrowLeft::interval() const –> struct protocols::forge::build::Interval

modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.protocols.forge.build.BuildInstructionState.Enum¶

modify this pose

the state of the BuildInstruction

C++: protocols::forge::build::BuildInstruction::modify(class core::pose::Pose &) –> enum protocols::forge::build::BuildInstructionState::Enum

modify_was_successful(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

Is the BuildInstruction’s state at MODIFY_WAS_SUCCESSFUL?

MODIFY_WAS_SUCCESSFUL indicates the BuildInstruction has
finished modifications to the Pose, and its residue indexing is now consistent with the newly modified Pose.

C++: protocols::forge::build::BuildInstruction::modify_was_successful() const –> bool

movemap(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft) → pyrosetta.rosetta.core.kinematics.MoveMap¶

return a copy of the MoveMap that defines the moveable/fixed

positions/dofs for this instruction

a MoveMap with [interval.left, interval.right] bb & chi set to true: at the MoveMapTorsionID level
This set can change wrt length changes in Pose/Conformation being: watched.

C++: protocols::forge::build::GrowLeft::movemap() const –> class core::kinematics::MoveMap

n_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → int¶

the number of dependencies this BuildInstruction has

C++: protocols::forge::build::BuildInstruction::n_dependencies() const –> unsigned long

new_positions(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return a copy of the set of positions that are “new” and did

not exist in the original Pose.

A set of positions spanning the entire region – all positions: are new.

C++: protocols::forge::build::GrowLeft::new_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

on_length_change(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None¶

update any indexing wrt length change to Pose/Conformation being watched

C++: protocols::forge::build::BuildInstruction::on_length_change(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_append(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None¶

update indexing on residue append

C++: protocols::forge::build::GrowLeft::on_residue_append(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_delete(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None¶

update indexing on residue delete

C++: protocols::forge::build::GrowLeft::on_residue_delete(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_prepend(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None¶

update indexing on residue prepend

C++: protocols::forge::build::GrowLeft::on_residue_prepend(const struct core::conformation::signals::LengthEvent &) –> void

original_deleted_positions(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return set of positions within the original interval that will: be deleted in this BuildInstruction

An empty set – no positions are deleted.

C++: protocols::forge::build::GrowLeft::original_deleted_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_fixed_positions(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return set of any fixed positions necessary with respect to the original

interval and original Pose numbering

Used for ensuring build regions for instructions do not overlap and: so that jumps may be placed correctly.

empty set if no fixed positions

C++: protocols::forge::build::GrowLeft::original_fixed_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_interval(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.protocols.forge.build.Interval¶

return original residue range of this instruction

C++: protocols::forge::build::BuildInstruction::original_interval() const –> const struct protocols::forge::build::Interval &

original_interval_valid(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft) → bool¶

is the original interval storing valid information, or is empty: or being used for something else?

false, stores invalid interval

C++: protocols::forge::build::GrowLeft::original_interval_valid() const –> bool

original_kept_positions(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return the set of positions within the original interval that: will be kept in this BuildInstruction

An empty set – no positions are kept.

C++: protocols::forge::build::GrowLeft::original_kept_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_mutable_positions(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return set of any mutable positions necessary with respect to the original

interval and original Pose numbering

Used for ensuring build regions for instructions do not overlap and: so that jumps may be placed correctly.

empty set if no mutable positions

C++: protocols::forge::build::GrowLeft::original_mutable_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

pos(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft) → int¶

grow left from this anchor position

this can change if listening to Conformation LengthEvents
Use original_interval() to get the original anchor position.

C++: protocols::forge::build::GrowLeft::pos() const –> unsigned long

preexisting_positions(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return a copy of the set of positions within the new region: that were pre-existing in the original Pose prior to modify()

An empty set – no positions are pre-existing.

C++: protocols::forge::build::GrowLeft::preexisting_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

ready(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

Is the BuildInstruction’s state at READY?

READY indicates the BuildInstruction has been reset
and is ready to modify a Pose.

C++: protocols::forge::build::BuildInstruction::ready() const –> bool

reset_accounting(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None¶

reset intervals, positions, etc to initial state and drop: observers. State set to READY.

C++: protocols::forge::build::BuildInstruction::reset_accounting() –> void

residue_type_set(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.core.chemical.ResidueTypeSet¶

the residue type set being used

C++: protocols::forge::build::BuildInstruction::residue_type_set() const –> const class core::chemical::ResidueTypeSet &

ss(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft) → str¶

get secondary structure string

C++: protocols::forge::build::GrowLeft::ss() const –> const std::string &

state(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.protocols.forge.build.BuildInstructionState.Enum¶

return the state of this BuildInstruction

C++: protocols::forge::build::BuildInstruction::state() const –> enum protocols::forge::build::BuildInstructionState::Enum

undefined_positions(self: pyrosetta.rosetta.protocols.forge.build.GrowLeft) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return a copy of the set of positions within the newly modified

region that has an undefined conformation. E.g. newly created residues.

A set of positions spanning the entire region – all positions: are undefined.
This set can change wrt length changes in Pose/Conformation being: watched.

C++: protocols::forge::build::GrowLeft::undefined_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

waiting_on_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

Is the BuildInstruction’s state at WAITING_ON_DEPENDENCIES?

WAITING_ON_DEPENDENCIES indicates
the BuildInstruction is waiting for its dependencies to be satisfied before allowing modifications to proceed.

C++: protocols::forge::build::BuildInstruction::waiting_on_dependencies() const –> bool

class pyrosetta.rosetta.protocols.forge.build.GrowRight¶

Bases: BuildInstruction

instruction to create a c-side extension

Use this for c-side insertions but typically not c-terminal: extensions unless necessary. It does not automatically cover the additional residue on the left endpoint that needs to move during c-terminal extensions due to invalid psi torsion. For that case, use the SegmentRebuild class replacing the c-terminal residue with desired length+1.

aa(self: pyrosetta.rosetta.protocols.forge.build.GrowRight) → str¶

get annotated amino acid string

C++: protocols::forge::build::GrowRight::aa() const –> const std::string &

add_dependency_to(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, i: pyrosetta.rosetta.std.weak_ptr_const_protocols_forge_build_BuildInstruction_t) → None¶

add an instruction to this BuildInstruction’s dependency list

before this instruction’s modify() may complete properly, all
instructions in the dependency list must have completed modify() first

C++: protocols::forge::build::BuildInstruction::add_dependency_to(class std::weak_ptr<const class protocols::forge::build::BuildInstruction>) –> void

assign(self: pyrosetta.rosetta.protocols.forge.build.GrowRight, rval: pyrosetta.rosetta.protocols.forge.build.GrowRight) → pyrosetta.rosetta.protocols.forge.build.GrowRight¶

copy assignment

C++: protocols::forge::build::GrowRight::operator=(const class protocols::forge::build::GrowRight &) –> class protocols::forge::build::GrowRight &

attach_to(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

attach to a Pose’s conformation

C++: protocols::forge::build::BuildInstruction::attach_to(class core::pose::Pose &) –> void

clear_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None¶

clear the list of dependencies

C++: protocols::forge::build::BuildInstruction::clear_dependencies() –> void

clone(self: pyrosetta.rosetta.protocols.forge.build.GrowRight) → pyrosetta.rosetta.protocols.forge.build.BuildInstruction¶

clone this object

C++: protocols::forge::build::GrowRight::clone() const –> class std::shared_ptr<class protocols::forge::build::BuildInstruction>

compatible_with(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, rval: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

compares fixed and mutable positions to determine compatibility with: another instruction

override this to obtain custom compatibility check

C++: protocols::forge::build::BuildInstruction::compatible_with(const class protocols::forge::build::BuildInstruction &) const –> bool

creates_undefined_backbone(self: pyrosetta.rosetta.protocols.forge.build.GrowRight) → bool¶

does this object create undefined backbone in the modified region?

true

C++: protocols::forge::build::GrowRight::creates_undefined_backbone() const –> bool

defined_positions(self: pyrosetta.rosetta.protocols.forge.build.GrowRight) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return a copy of the set of positions within the newly modified

region that has a defined conformation. E.g. existing or copied residues.

An empty set – no positions are defined.

This set can change wrt length changes in Pose/Conformation being: watched.

C++: protocols::forge::build::GrowRight::defined_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.utility.vector1_std_weak_ptr_const_protocols_forge_build_BuildInstruction_t¶

the list of instructions whose modify() must complete before: the modify() for this instruction may be called successfully

C++: protocols::forge::build::BuildInstruction::dependencies() const –> const class utility::vector1<class std::weak_ptr<const class protocols::forge::build::BuildInstruction>, class std::allocator<class std::weak_ptr<const class protocols::forge::build::BuildInstruction> > > &

dependent_on(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, i: pyrosetta.rosetta.std.weak_ptr_const_protocols_forge_build_BuildInstruction_t) → bool¶

is this instruction dependent upon the given instruction?

C++: protocols::forge::build::BuildInstruction::dependent_on(class std::weak_ptr<const class protocols::forge::build::BuildInstruction>) const –> bool

detach_after_modify(*args, **kwargs)¶

Overloaded function.

detach_after_modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) -> bool

detach after modify()?

Ordinarily a modify() call consists of attaching as a
length obs of the Pose, actually doing the modify, and then detaching as a length obs of the Pose. This flag governs whether the last detach occurs.

C++: protocols::forge::build::BuildInstruction::detach_after_modify() const –> bool

detach_after_modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, flag: bool) -> None

set detach after modify()

Ordinarily a modify() call consists of attaching as a
length obs of the Pose, actually doing the modify, and then detaching as a length obs of the Pose. This flag governs whether the last detach occurs.

C++: protocols::forge::build::BuildInstruction::detach_after_modify(const bool) –> void

detach_from(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None¶

detach from a Pose’s conformation

C++: protocols::forge::build::BuildInstruction::detach_from() –> void

has_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

does this BuildInstruction have dependencies?

C++: protocols::forge::build::BuildInstruction::has_dependencies() const –> bool

interval(self: pyrosetta.rosetta.protocols.forge.build.GrowRight) → pyrosetta.rosetta.protocols.forge.build.Interval¶

a copy of the working range of residues specifying the modified region

This can change if listening to Conformation LengthEvents

C++: protocols::forge::build::GrowRight::interval() const –> struct protocols::forge::build::Interval

modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.protocols.forge.build.BuildInstructionState.Enum¶

modify this pose

the state of the BuildInstruction

C++: protocols::forge::build::BuildInstruction::modify(class core::pose::Pose &) –> enum protocols::forge::build::BuildInstructionState::Enum

modify_was_successful(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

Is the BuildInstruction’s state at MODIFY_WAS_SUCCESSFUL?

MODIFY_WAS_SUCCESSFUL indicates the BuildInstruction has
finished modifications to the Pose, and its residue indexing is now consistent with the newly modified Pose.

C++: protocols::forge::build::BuildInstruction::modify_was_successful() const –> bool

movemap(self: pyrosetta.rosetta.protocols.forge.build.GrowRight) → pyrosetta.rosetta.core.kinematics.MoveMap¶

return a copy of the MoveMap that defines the moveable/fixed

positions/dofs for this instruction

a MoveMap with [interval.left, interval.right] bb & chi set to true: at the MoveMapTorsionID level
This set can change wrt length changes in Pose/Conformation being: watched.

C++: protocols::forge::build::GrowRight::movemap() const –> class core::kinematics::MoveMap

n_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → int¶

the number of dependencies this BuildInstruction has

C++: protocols::forge::build::BuildInstruction::n_dependencies() const –> unsigned long

new_positions(self: pyrosetta.rosetta.protocols.forge.build.GrowRight) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return a copy of the set of positions that are “new” and did

not exist in the original Pose.

A set of positions spanning the entire region – all positions: are new.

C++: protocols::forge::build::GrowRight::new_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

on_length_change(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None¶

update any indexing wrt length change to Pose/Conformation being watched

C++: protocols::forge::build::BuildInstruction::on_length_change(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_append(self: pyrosetta.rosetta.protocols.forge.build.GrowRight, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None¶

update indexing on residue append

C++: protocols::forge::build::GrowRight::on_residue_append(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_delete(self: pyrosetta.rosetta.protocols.forge.build.GrowRight, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None¶

update indexing on residue delete

C++: protocols::forge::build::GrowRight::on_residue_delete(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_prepend(self: pyrosetta.rosetta.protocols.forge.build.GrowRight, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None¶

update indexing on residue prepend

C++: protocols::forge::build::GrowRight::on_residue_prepend(const struct core::conformation::signals::LengthEvent &) –> void

original_deleted_positions(self: pyrosetta.rosetta.protocols.forge.build.GrowRight) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return set of positions within the original interval that will: be deleted in this BuildInstruction

An empty set – no positions are deleted.

C++: protocols::forge::build::GrowRight::original_deleted_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_fixed_positions(self: pyrosetta.rosetta.protocols.forge.build.GrowRight) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return set of any fixed positions necessary with respect to the original

interval and original Pose numbering

Used for ensuring build regions for instructions do not overlap and: so that jumps may be placed correctly.

empty set if no fixed positions

C++: protocols::forge::build::GrowRight::original_fixed_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_interval(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.protocols.forge.build.Interval¶

return original residue range of this instruction

C++: protocols::forge::build::BuildInstruction::original_interval() const –> const struct protocols::forge::build::Interval &

original_interval_valid(self: pyrosetta.rosetta.protocols.forge.build.GrowRight) → bool¶

is the original interval storing valid information, or is empty: or being used for something else?

false, stores invalid interval

C++: protocols::forge::build::GrowRight::original_interval_valid() const –> bool

original_kept_positions(self: pyrosetta.rosetta.protocols.forge.build.GrowRight) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return the set of positions within the original interval that: will be kept in this BuildInstruction

An empty set – no positions are kept.

C++: protocols::forge::build::GrowRight::original_kept_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_mutable_positions(self: pyrosetta.rosetta.protocols.forge.build.GrowRight) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return set of any mutable positions necessary with respect to the original

interval and original Pose numbering

Used for ensuring build regions for instructions do not overlap and: so that jumps may be placed correctly.

empty set if no mutable positions

C++: protocols::forge::build::GrowRight::original_mutable_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

pos(self: pyrosetta.rosetta.protocols.forge.build.GrowRight) → int¶

grow right from this anchor position

This can change if listening to Conformation LengthEvents.
Use original_interval() to get the original anchor position.

C++: protocols::forge::build::GrowRight::pos() const –> unsigned long

preexisting_positions(self: pyrosetta.rosetta.protocols.forge.build.GrowRight) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return a copy of the set of positions within the new region: that were pre-existing in the original Pose prior to modify()

An empty set – no positions are pre-existing.

C++: protocols::forge::build::GrowRight::preexisting_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

ready(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

Is the BuildInstruction’s state at READY?

READY indicates the BuildInstruction has been reset
and is ready to modify a Pose.

C++: protocols::forge::build::BuildInstruction::ready() const –> bool

reset_accounting(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None¶

reset intervals, positions, etc to initial state and drop: observers. State set to READY.

C++: protocols::forge::build::BuildInstruction::reset_accounting() –> void

residue_type_set(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.core.chemical.ResidueTypeSet¶

the residue type set being used

C++: protocols::forge::build::BuildInstruction::residue_type_set() const –> const class core::chemical::ResidueTypeSet &

ss(self: pyrosetta.rosetta.protocols.forge.build.GrowRight) → str¶

get secondary structure string

C++: protocols::forge::build::GrowRight::ss() const –> const std::string &

state(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.protocols.forge.build.BuildInstructionState.Enum¶

return the state of this BuildInstruction

C++: protocols::forge::build::BuildInstruction::state() const –> enum protocols::forge::build::BuildInstructionState::Enum

undefined_positions(self: pyrosetta.rosetta.protocols.forge.build.GrowRight) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return a copy of the set of positions within the newly modified

region that has an undefined conformation. E.g. newly created residues.

A set of positions spanning the entire region – all positions: are undefined.
This set can change wrt length changes in Pose/Conformation being: watched.

C++: protocols::forge::build::GrowRight::undefined_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

waiting_on_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

Is the BuildInstruction’s state at WAITING_ON_DEPENDENCIES?

WAITING_ON_DEPENDENCIES indicates
the BuildInstruction is waiting for its dependencies to be satisfied before allowing modifications to proceed.

C++: protocols::forge::build::BuildInstruction::waiting_on_dependencies() const –> bool

class pyrosetta.rosetta.protocols.forge.build.Interval¶

Bases: pybind11_object

simple struct defining a closed interval of residues [left, right] where left <= right

assign(self: pyrosetta.rosetta.protocols.forge.build.Interval, rval: pyrosetta.rosetta.protocols.forge.build.Interval) → pyrosetta.rosetta.protocols.forge.build.Interval¶

copy assignment

C++: protocols::forge::build::Interval::operator=(const struct protocols::forge::build::Interval &) –> struct protocols::forge::build::Interval &

contains(self: pyrosetta.rosetta.protocols.forge.build.Interval, point: int) → bool¶

is a point contained in this interval?

C++: protocols::forge::build::Interval::contains(const unsigned long) const –> bool

intersects(self: pyrosetta.rosetta.protocols.forge.build.Interval, rval: pyrosetta.rosetta.protocols.forge.build.Interval) → bool¶

do the two intervals intersect?

C++: protocols::forge::build::Interval::intersects(const struct protocols::forge::build::Interval &) const –> bool

property left¶

length(self: pyrosetta.rosetta.protocols.forge.build.Interval) → int¶

length of the interval

C++: protocols::forge::build::Interval::length() const –> unsigned long

property right¶

class pyrosetta.rosetta.protocols.forge.build.RelativeConnectRight¶

Bases: ConnectRight

version of ConnectRight instruction that depends upon results from another BuildInstruction

add_dependency_to(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, i: pyrosetta.rosetta.std.weak_ptr_const_protocols_forge_build_BuildInstruction_t) → None¶

add an instruction to this BuildInstruction’s dependency list

before this instruction’s modify() may complete properly, all
instructions in the dependency list must have completed modify() first

C++: protocols::forge::build::BuildInstruction::add_dependency_to(class std::weak_ptr<const class protocols::forge::build::BuildInstruction>) –> void

assign(self: pyrosetta.rosetta.protocols.forge.build.RelativeConnectRight, rval: pyrosetta.rosetta.protocols.forge.build.RelativeConnectRight) → pyrosetta.rosetta.protocols.forge.build.RelativeConnectRight¶

copy assignment

C++: protocols::forge::build::RelativeConnectRight::operator=(const class protocols::forge::build::RelativeConnectRight &) –> class protocols::forge::build::RelativeConnectRight &

attach_to(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

attach to a Pose’s conformation

C++: protocols::forge::build::BuildInstruction::attach_to(class core::pose::Pose &) –> void

clear_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None¶

clear the list of dependencies

C++: protocols::forge::build::BuildInstruction::clear_dependencies() –> void

clone(self: pyrosetta.rosetta.protocols.forge.build.RelativeConnectRight) → pyrosetta.rosetta.protocols.forge.build.BuildInstruction¶

clone this object

C++: protocols::forge::build::RelativeConnectRight::clone() const –> class std::shared_ptr<class protocols::forge::build::BuildInstruction>

compatible_with(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, rval: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

compares fixed and mutable positions to determine compatibility with: another instruction

override this to obtain custom compatibility check

C++: protocols::forge::build::BuildInstruction::compatible_with(const class protocols::forge::build::BuildInstruction &) const –> bool

creates_undefined_backbone(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → bool¶

does this object create undefined backbone in the modified region?

false

C++: protocols::forge::build::ConnectRight::creates_undefined_backbone() const –> bool

defined_positions(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return a copy of the set of positions within the newly modified

region that has a defined conformation. E.g. existing or copied residues.

A set spanning the entire interval – all positions are defined.

This set can change wrt length changes in Pose/Conformation being: watched.

C++: protocols::forge::build::ConnectRight::defined_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.utility.vector1_std_weak_ptr_const_protocols_forge_build_BuildInstruction_t¶

the list of instructions whose modify() must complete before: the modify() for this instruction may be called successfully

C++: protocols::forge::build::BuildInstruction::dependencies() const –> const class utility::vector1<class std::weak_ptr<const class protocols::forge::build::BuildInstruction>, class std::allocator<class std::weak_ptr<const class protocols::forge::build::BuildInstruction> > > &

dependent_on(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, i: pyrosetta.rosetta.std.weak_ptr_const_protocols_forge_build_BuildInstruction_t) → bool¶

is this instruction dependent upon the given instruction?

C++: protocols::forge::build::BuildInstruction::dependent_on(class std::weak_ptr<const class protocols::forge::build::BuildInstruction>) const –> bool

detach_after_modify(*args, **kwargs)¶

Overloaded function.

detach_after_modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) -> bool

detach after modify()?

Ordinarily a modify() call consists of attaching as a
length obs of the Pose, actually doing the modify, and then detaching as a length obs of the Pose. This flag governs whether the last detach occurs.

C++: protocols::forge::build::BuildInstruction::detach_after_modify() const –> bool

detach_after_modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, flag: bool) -> None

set detach after modify()

Ordinarily a modify() call consists of attaching as a
length obs of the Pose, actually doing the modify, and then detaching as a length obs of the Pose. This flag governs whether the last detach occurs.

C++: protocols::forge::build::BuildInstruction::detach_after_modify(const bool) –> void

detach_from(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None¶

detach from a Pose’s conformation

C++: protocols::forge::build::BuildInstruction::detach_from() –> void

extract_rt(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight, pose: pyrosetta.rosetta.core.pose.Pose, jump_start_residue: int, jump_stop_residue: int) → None¶

extract appropriately computed transform between two stubs that

represent a jump in the given Pose between the two residues and set it as the rt for this ConnectRight

The Pose to use.

The starting residue of the jump.: This residue should be the equivalent of the jump position on pose_left.
The stopping residue of the jump.: This residue should be the equivalent of the jump position on pose_right.
Uses left_stub_atoms() and right_stub_atoms() as the stub atoms: to compute the transform. Remember to set use_rt() to True after calling this function if you want to actually use the transform during modify().

C++: protocols::forge::build::ConnectRight::extract_rt(const class core::pose::Pose &, const unsigned long, const unsigned long) –> void

has_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

does this BuildInstruction have dependencies?

C++: protocols::forge::build::BuildInstruction::has_dependencies() const –> bool

interval(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.protocols.forge.build.Interval¶

a copy of the working range of residues specifying the modified region

before modify() holds [1, pose_right.size()]; after
modify() holds [1 + pose_left.size(), pose_right.n_residue + pose_left.size()]

This can change if listening to Conformation LengthEvents

C++: protocols::forge::build::ConnectRight::interval() const –> struct protocols::forge::build::Interval

left_stub_atoms(*args, **kwargs)¶

Overloaded function.

left_stub_atoms(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) -> pyrosetta.rosetta.utility.vector1_std_string

Use these atoms to compute the stub on pose_left.

Default [“CA”, “N”, “CA”, “C”].

This is an array with 4 elements in the same order as Stub: initialization: ‘center atom’, ‘point1’, ‘point2’, ‘point3’. See Stub docs for more details.

C++: protocols::forge::build::ConnectRight::left_stub_atoms() const –> const class utility::vector1<std::string, class std::allocator<std::string > > &

left_stub_atoms(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight, atoms: pyrosetta.rosetta.utility.vector1_std_string) -> None

Use these atoms to compute the stub on pose_left.

Default [“CA”, “N”, “CA”, “C”].

This is an array with 4 elements in the same order as Stub: initialization: ‘center atom’, ‘point1’, ‘point2’, ‘point3’. See Stub docs for more details.

C++: protocols::forge::build::ConnectRight::left_stub_atoms(const class utility::vector1<std::string, class std::allocator<std::string > > &) –> void

modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.protocols.forge.build.BuildInstructionState.Enum¶

modify this pose

the state of the BuildInstruction

C++: protocols::forge::build::BuildInstruction::modify(class core::pose::Pose &) –> enum protocols::forge::build::BuildInstructionState::Enum

modify_impl(self: pyrosetta.rosetta.protocols.forge.build.RelativeConnectRight, pose_left: pyrosetta.rosetta.core.pose.Pose) → None¶

do the actual work of modifying the Pose

C++: protocols::forge::build::RelativeConnectRight::modify_impl(class core::pose::Pose &) –> void

modify_was_successful(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

Is the BuildInstruction’s state at MODIFY_WAS_SUCCESSFUL?

MODIFY_WAS_SUCCESSFUL indicates the BuildInstruction has
finished modifications to the Pose, and its residue indexing is now consistent with the newly modified Pose.

C++: protocols::forge::build::BuildInstruction::modify_was_successful() const –> bool

movemap(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.core.kinematics.MoveMap¶

return a copy of the MoveMap that defines the moveable/fixed

positions/dofs for this instruction

a MoveMap with [interval.left, interval.right] bb set to false: at the MoveMapTorsionID level
This set can change wrt length changes in Pose/Conformation being: watched.

C++: protocols::forge::build::ConnectRight::movemap() const –> class core::kinematics::MoveMap

n_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → int¶

the number of dependencies this BuildInstruction has

C++: protocols::forge::build::BuildInstruction::n_dependencies() const –> unsigned long

new_positions(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return a copy of the set of positions that are “new” and did: not exist in the original Pose.

A set spanning the entire interval – all positions are new.

C++: protocols::forge::build::ConnectRight::new_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

on_length_change(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None¶

update any indexing wrt length change to Pose/Conformation being watched

C++: protocols::forge::build::BuildInstruction::on_length_change(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_append(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None¶

update indexing on residue append

C++: protocols::forge::build::ConnectRight::on_residue_append(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_delete(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None¶

update indexing on residue delete

C++: protocols::forge::build::ConnectRight::on_residue_delete(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_prepend(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None¶

update indexing on residue prepend

C++: protocols::forge::build::ConnectRight::on_residue_prepend(const struct core::conformation::signals::LengthEvent &) –> void

original_deleted_positions(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return set of positions within the original interval that will: be deleted in this BuildInstruction

An empty set – no positions are deleted.

C++: protocols::forge::build::ConnectRight::original_deleted_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_fixed_positions(self: pyrosetta.rosetta.protocols.forge.build.RelativeConnectRight) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return set of any fixed positions necessary with respect to the original

interval and original Pose numbering

always empty set, no fixed positions

Used for ensuring build regions for instructions do not overlap and: so that jumps may be placed correctly. There is currently no way to represent the dependent fixed position, so we’re forced to return an empty set.

C++: protocols::forge::build::RelativeConnectRight::original_fixed_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_interval(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.protocols.forge.build.Interval¶

return original residue range of this instruction

C++: protocols::forge::build::BuildInstruction::original_interval() const –> const struct protocols::forge::build::Interval &

original_interval_valid(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → bool¶

is the original interval storing valid information, or is empty: or being used for something else?

false, stores invalid interval

C++: protocols::forge::build::ConnectRight::original_interval_valid() const –> bool

original_kept_positions(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return the set of positions within the original interval that: will be kept in this BuildInstruction

An empty set – no positions are kept.

C++: protocols::forge::build::ConnectRight::original_kept_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_mutable_positions(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return set of any mutable positions necessary with respect to the original

interval and original Pose numbering

Used for ensuring build regions for instructions do not overlap and: so that jumps may be placed correctly.

empty set if no mutable positions

C++: protocols::forge::build::ConnectRight::original_mutable_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

pose_right(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.core.pose.Pose¶

connect this pose to the right of pose_left when modify( pose_left ): is called

C++: protocols::forge::build::ConnectRight::pose_right() –> const class core::pose::Pose &

preexisting_positions(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return a copy of the set of positions within the new region: that were pre-existing in the original Pose prior to modify()

An empty set – no positions are pre-existing.

C++: protocols::forge::build::ConnectRight::preexisting_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

ready(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

Is the BuildInstruction’s state at READY?

READY indicates the BuildInstruction has been reset
and is ready to modify a Pose.

C++: protocols::forge::build::BuildInstruction::ready() const –> bool

reset_accounting(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None¶

reset intervals, positions, etc to initial state and drop: observers. State set to READY.

C++: protocols::forge::build::BuildInstruction::reset_accounting() –> void

residue_type_set(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.core.chemical.ResidueTypeSet¶

the residue type set being used

C++: protocols::forge::build::BuildInstruction::residue_type_set() const –> const class core::chemical::ResidueTypeSet &

right_stub_atoms(*args, **kwargs)¶

Overloaded function.

right_stub_atoms(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) -> pyrosetta.rosetta.utility.vector1_std_string

Use these atoms to compute the stub on pose_right.

Default [“CA”, “N”, “CA”, “C”].

This is an array with 4 elements in the same order as Stub: initialization: ‘center atom’, ‘point1’, ‘point2’, ‘point3’. See Stub docs for more details.

C++: protocols::forge::build::ConnectRight::right_stub_atoms() const –> const class utility::vector1<std::string, class std::allocator<std::string > > &

right_stub_atoms(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight, atoms: pyrosetta.rosetta.utility.vector1_std_string) -> None

Use these atoms to compute the stub on pose_right.

Default [“CA”, “N”, “CA”, “C”].

This is an array with 4 elements in the same order as Stub: initialization: ‘center atom’, ‘point1’, ‘point2’, ‘point3’. See Stub docs for more details.

C++: protocols::forge::build::ConnectRight::right_stub_atoms(const class utility::vector1<std::string, class std::allocator<std::string > > &) –> void

rt(*args, **kwargs)¶

Overloaded function.

rt(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) -> pyrosetta.rosetta.core.kinematics.RT

the rotation-translation representing an explicit transform from: the stub on pose_left to the stub on pose_right, i.e. the representation of the “jump”

C++: protocols::forge::build::ConnectRight::rt() –> const class core::kinematics::RT &

rt(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight, transform: pyrosetta.rosetta.core.kinematics.RT) -> None

the rotation-translation representing an explicit transform from: the stub on pose_left to the stub on pose_right, i.e. the representation of the “jump”

C++: protocols::forge::build::ConnectRight::rt(const class core::kinematics::RT &) –> void

state(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.protocols.forge.build.BuildInstructionState.Enum¶

return the state of this BuildInstruction

C++: protocols::forge::build::BuildInstruction::state() const –> enum protocols::forge::build::BuildInstructionState::Enum

undefined_positions(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return a copy of the set of positions within the newly modified

region that has an undefined conformation. E.g. newly created residues.

An empty set – no undefined positions.

This set can change wrt length changes in Pose/Conformation being: watched.

C++: protocols::forge::build::ConnectRight::undefined_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

use_rt(*args, **kwargs)¶

Overloaded function.

use_rt(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight) -> bool

apply the transform over the jump connection between pose_left and: pose_right? default False

C++: protocols::forge::build::ConnectRight::use_rt() const –> bool

use_rt(self: pyrosetta.rosetta.protocols.forge.build.ConnectRight, flag: bool) -> None

apply the transform over the jump connection between pose_left and: pose_right? default False

C++: protocols::forge::build::ConnectRight::use_rt(const bool) –> void

waiting_on_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

Is the BuildInstruction’s state at WAITING_ON_DEPENDENCIES?

WAITING_ON_DEPENDENCIES indicates
the BuildInstruction is waiting for its dependencies to be satisfied before allowing modifications to proceed.

C++: protocols::forge::build::BuildInstruction::waiting_on_dependencies() const –> bool

class pyrosetta.rosetta.protocols.forge.build.RelativeSequencePosition¶

Bases: pybind11_object

computes a position wrt values in given BuildInstruction

assign(self: pyrosetta.rosetta.protocols.forge.build.RelativeSequencePosition, : pyrosetta.rosetta.protocols.forge.build.RelativeSequencePosition) → pyrosetta.rosetta.protocols.forge.build.RelativeSequencePosition¶: C++: protocols::forge::build::RelativeSequencePosition::operator=(const struct protocols::forge::build::RelativeSequencePosition &) –> struct protocols::forge::build::RelativeSequencePosition &

clone(self: pyrosetta.rosetta.protocols.forge.build.RelativeSequencePosition) → pyrosetta.rosetta.protocols.forge.build.RelativeSequencePosition¶: C++: protocols::forge::build::RelativeSequencePosition::clone() const –> class std::shared_ptr<struct protocols::forge::build::RelativeSequencePosition>

class pyrosetta.rosetta.protocols.forge.build.SegmentInsert¶

Bases: BuildInstruction

insert an external segment flanked by new regions

Similar to SegmentRebuild, but with the addition of a defined: segment located in the modified region.

aa(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → str¶

get annotated amino acid string (includes insertion point as ‘^’)

C++: protocols::forge::build::SegmentInsert::aa() const –> const std::string &

add_dependency_to(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, i: pyrosetta.rosetta.std.weak_ptr_const_protocols_forge_build_BuildInstruction_t) → None¶

add an instruction to this BuildInstruction’s dependency list

before this instruction’s modify() may complete properly, all
instructions in the dependency list must have completed modify() first

C++: protocols::forge::build::BuildInstruction::add_dependency_to(class std::weak_ptr<const class protocols::forge::build::BuildInstruction>) –> void

assign(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert, rval: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → pyrosetta.rosetta.protocols.forge.build.SegmentInsert¶

copy assignment

C++: protocols::forge::build::SegmentInsert::operator=(const class protocols::forge::build::SegmentInsert &) –> class protocols::forge::build::SegmentInsert &

attach_to(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

attach to a Pose’s conformation

C++: protocols::forge::build::BuildInstruction::attach_to(class core::pose::Pose &) –> void

clear_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None¶

clear the list of dependencies

C++: protocols::forge::build::BuildInstruction::clear_dependencies() –> void

clone(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → pyrosetta.rosetta.protocols.forge.build.BuildInstruction¶

clone this object

C++: protocols::forge::build::SegmentInsert::clone() const –> class std::shared_ptr<class protocols::forge::build::BuildInstruction>

compatible_with(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, rval: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

compares fixed and mutable positions to determine compatibility with: another instruction

override this to obtain custom compatibility check

C++: protocols::forge::build::BuildInstruction::compatible_with(const class protocols::forge::build::BuildInstruction &) const –> bool

creates_undefined_backbone(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → bool¶

does this object create undefined backbone in the modified region?

C++: protocols::forge::build::SegmentInsert::creates_undefined_backbone() const –> bool

defined_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return a copy of the set of positions within the newly modified

region that has a defined conformation. E.g. existing or copied residues.

This set can change wrt length changes in Pose/Conformation being: watched.

C++: protocols::forge::build::SegmentInsert::defined_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.utility.vector1_std_weak_ptr_const_protocols_forge_build_BuildInstruction_t¶

the list of instructions whose modify() must complete before: the modify() for this instruction may be called successfully

C++: protocols::forge::build::BuildInstruction::dependencies() const –> const class utility::vector1<class std::weak_ptr<const class protocols::forge::build::BuildInstruction>, class std::allocator<class std::weak_ptr<const class protocols::forge::build::BuildInstruction> > > &

dependent_on(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, i: pyrosetta.rosetta.std.weak_ptr_const_protocols_forge_build_BuildInstruction_t) → bool¶

is this instruction dependent upon the given instruction?

C++: protocols::forge::build::BuildInstruction::dependent_on(class std::weak_ptr<const class protocols::forge::build::BuildInstruction>) const –> bool

detach_after_modify(*args, **kwargs)¶

Overloaded function.

detach_after_modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) -> bool

detach after modify()?

Ordinarily a modify() call consists of attaching as a
length obs of the Pose, actually doing the modify, and then detaching as a length obs of the Pose. This flag governs whether the last detach occurs.

C++: protocols::forge::build::BuildInstruction::detach_after_modify() const –> bool

detach_after_modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, flag: bool) -> None

set detach after modify()

Ordinarily a modify() call consists of attaching as a
length obs of the Pose, actually doing the modify, and then detaching as a length obs of the Pose. This flag governs whether the last detach occurs.

C++: protocols::forge::build::BuildInstruction::detach_after_modify(const bool) –> void

detach_from(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None¶

detach from a Pose’s conformation

C++: protocols::forge::build::BuildInstruction::detach_from() –> void

flanking_left_aa(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → str¶

get the annotated aa string of the flanking residues to the left: of the insertion point

C++: protocols::forge::build::SegmentInsert::flanking_left_aa() const –> std::string

flanking_left_nres(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → int¶

get the number of flanking residues to the left of the insertion: point

C++: protocols::forge::build::SegmentInsert::flanking_left_nres() const –> unsigned long

flanking_left_ss(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → str¶

get the ss string of the flanking residues to the left of the: insertion point

C++: protocols::forge::build::SegmentInsert::flanking_left_ss() const –> std::string

flanking_right_aa(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → str¶

get the annotated aa string of the flanking residues to the right: of the insertion point

C++: protocols::forge::build::SegmentInsert::flanking_right_aa() const –> std::string

flanking_right_nres(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → int¶

get the number of flanking residues to the right of the insertion: point

C++: protocols::forge::build::SegmentInsert::flanking_right_nres() const –> unsigned long

flanking_right_ss(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → str¶

get the ss string of the flanking residues to the right of the: insertion point

C++: protocols::forge::build::SegmentInsert::flanking_right_ss() const –> std::string

has_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

does this BuildInstruction have dependencies?

C++: protocols::forge::build::BuildInstruction::has_dependencies() const –> bool

insert_connection_scheme(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → pyrosetta.rosetta.protocols.forge.build.SegmentInsertConnectionScheme.Enum¶

get the insert connection scheme – whether the insertion will: be glued on the N-side, C-side, or if SegmentInsert will pick randomly between the two

C++: protocols::forge::build::SegmentInsert::insert_connection_scheme() const –> enum protocols::forge::build::SegmentInsertConnectionScheme::Enum

insert_pose(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → pyrosetta.rosetta.core.pose.Pose¶

the pose to insert

C++: protocols::forge::build::SegmentInsert::insert_pose() const –> const class core::pose::Pose &

insert_pose_torsion_override_movemap(*args, **kwargs)¶

Overloaded function.

insert_pose_torsion_override_movemap(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) -> pyrosetta.rosetta.core.kinematics.MoveMap

a torsion (bb/chi) specific override movemap indexed wrt the insert Pose

(residue indices may only be within the range [1, insert_pose.size()]

When generating the movemap(), this torsion movemap will be enforced.: Only explicit settings of TorsionType, MoveMapTorsionID, and TorsionID will be honored. Implicit false settings are ignored.

C++: protocols::forge::build::SegmentInsert::insert_pose_torsion_override_movemap() const –> const class core::kinematics::MoveMap &

insert_pose_torsion_override_movemap(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert, mm: pyrosetta.rosetta.core.kinematics.MoveMap) -> None

set a torsion (bb/chi) specific override movemap indexed wrt the insert

Pose (residue indices may only be within the range [1, insert_pose.size()]

When generating the movemap(), this torsion movemap will be enforced.: Only explicit settings of TorsionType, MoveMapTorsionID, and TorsionID will be honored. Implicit false settings are ignored.

C++: protocols::forge::build::SegmentInsert::insert_pose_torsion_override_movemap(const class core::kinematics::MoveMap &) –> void

static insertion_char() → str¶

the character representing the insertion point

‘^’

C++: protocols::forge::build::SegmentInsert::insertion_char() –> char

insertion_end_residue(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → int¶

get the residue at the end of the insertion relative to the: modified interval (flanking positions are not part of the insertion!)

C++: protocols::forge::build::SegmentInsert::insertion_end_residue() const –> unsigned long

insertion_point_absolute_index(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → int¶

get the absolute index of the insertion point with respect to the: flanking regions (i.e. the index inside the ss string)

C++: protocols::forge::build::SegmentInsert::insertion_point_absolute_index() const –> unsigned long

insertion_start_residue(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → int¶

get the residue at the start of the insertion relative to the: modified interval (flanking positions are not part of the insertion!)

C++: protocols::forge::build::SegmentInsert::insertion_start_residue() const –> unsigned long

interval(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → pyrosetta.rosetta.protocols.forge.build.Interval¶

a copy of the working range of residues specifying the modified region

This residue range can change wrt length changes in Pose /Conformation
being watched.

C++: protocols::forge::build::SegmentInsert::interval() const –> struct protocols::forge::build::Interval

keep_known_bb_torsions_at_junctions(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → bool¶

Attempt to keep the phi at original_interval().left and the psi+omega: at original_interval().right present from the original Pose in the modified Pose? Not applicable for pure insertions. Default False.

C++: protocols::forge::build::SegmentInsert::keep_known_bb_torsions_at_junctions() const –> bool

modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.protocols.forge.build.BuildInstructionState.Enum¶

modify this pose

the state of the BuildInstruction

C++: protocols::forge::build::BuildInstruction::modify(class core::pose::Pose &) –> enum protocols::forge::build::BuildInstructionState::Enum

modify_was_successful(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

Is the BuildInstruction’s state at MODIFY_WAS_SUCCESSFUL?

MODIFY_WAS_SUCCESSFUL indicates the BuildInstruction has
finished modifications to the Pose, and its residue indexing is now consistent with the newly modified Pose.

C++: protocols::forge::build::BuildInstruction::modify_was_successful() const –> bool

movemap(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → pyrosetta.rosetta.core.kinematics.MoveMap¶

return a copy of the MoveMap that defines the moveable/fixed

positions/dofs for this instruction

TO BE FILLED IN

This set can change wrt length changes in Pose/Conformation being: watched.

C++: protocols::forge::build::SegmentInsert::movemap() const –> class core::kinematics::MoveMap

n_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → int¶

the number of dependencies this BuildInstruction has

C++: protocols::forge::build::BuildInstruction::n_dependencies() const –> unsigned long

new_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return a copy of the set of positions that are “new” and did: not exist in the original Pose.

C++: protocols::forge::build::SegmentInsert::new_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

on_length_change(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None¶

update any indexing wrt length change to Pose/Conformation being watched

C++: protocols::forge::build::BuildInstruction::on_length_change(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_append(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None¶

update indexing on residue append

C++: protocols::forge::build::SegmentInsert::on_residue_append(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_delete(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None¶

update indexing on residue delete

C++: protocols::forge::build::SegmentInsert::on_residue_delete(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_prepend(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None¶

update indexing on residue prepend

C++: protocols::forge::build::SegmentInsert::on_residue_prepend(const struct core::conformation::signals::LengthEvent &) –> void

original_deleted_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return set of positions within the original interval that will: be deleted in this BuildInstruction

C++: protocols::forge::build::SegmentInsert::original_deleted_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_fixed_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return set of any fixed positions necessary with respect to the original

interval and original Pose numbering

Used for ensuring build regions for instructions do not overlap and: so that jumps may be placed correctly.

empty set if no fixed positions necessary

C++: protocols::forge::build::SegmentInsert::original_fixed_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_interval(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.protocols.forge.build.Interval¶

return original residue range of this instruction

C++: protocols::forge::build::BuildInstruction::original_interval() const –> const struct protocols::forge::build::Interval &

original_interval_valid(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → bool¶

is the original interval storing valid information, or is empty: or being used for something else?

always false, original interval invalid

C++: protocols::forge::build::SegmentInsert::original_interval_valid() const –> bool

original_kept_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return the set of positions within the original interval that: will be kept in this BuildInstruction

An empty set – no positions are kept.

C++: protocols::forge::build::SegmentInsert::original_kept_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_mutable_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return set of any mutable positions necessary with respect to the original

interval and original Pose numbering

Used for ensuring build regions for instructions do not overlap and: so that jumps may be placed correctly.

C++: protocols::forge::build::SegmentInsert::original_mutable_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

performing_pure_insertion(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → bool¶

performing a pure insertion/extension?

True if SegmentInsert was initialized with an interval whose
left endpoint == 0, False otherwise.

C++: protocols::forge::build::SegmentInsert::performing_pure_insertion() const –> bool

preexisting_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return a copy of the set of positions within the new region: that were pre-existing in the original Pose prior to modify()

An empty set, there are no pre-existing positions.

C++: protocols::forge::build::SegmentInsert::preexisting_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

ready(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

Is the BuildInstruction’s state at READY?

READY indicates the BuildInstruction has been reset
and is ready to modify a Pose.

C++: protocols::forge::build::BuildInstruction::ready() const –> bool

reset_accounting(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None¶

reset intervals, positions, etc to initial state and drop: observers. State set to READY.

C++: protocols::forge::build::BuildInstruction::reset_accounting() –> void

residue_type_set(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.core.chemical.ResidueTypeSet¶

the residue type set being used

C++: protocols::forge::build::BuildInstruction::residue_type_set() const –> const class core::chemical::ResidueTypeSet &

ss(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → str¶

get secondary structure string (includes insertion point as ‘^’)

C++: protocols::forge::build::SegmentInsert::ss() const –> const std::string &

state(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.protocols.forge.build.BuildInstructionState.Enum¶

return the state of this BuildInstruction

C++: protocols::forge::build::BuildInstruction::state() const –> enum protocols::forge::build::BuildInstructionState::Enum

undefined_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentInsert) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return a copy of the set of positions within the newly modified

region that has an undefined conformation. E.g. newly created residues.

This set can change wrt length changes in Pose/Conformation being: watched.

C++: protocols::forge::build::SegmentInsert::undefined_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

waiting_on_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

Is the BuildInstruction’s state at WAITING_ON_DEPENDENCIES?

WAITING_ON_DEPENDENCIES indicates
the BuildInstruction is waiting for its dependencies to be satisfied before allowing modifications to proceed.

C++: protocols::forge::build::BuildInstruction::waiting_on_dependencies() const –> bool

class pyrosetta.rosetta.protocols.forge.build.SegmentRebuild¶

Bases: BuildInstruction

instruction to rebuild a segment

Handles both cut based rebuilding (i.e. loops) and continuous: rebuilding adjacent to the boundary of a chain, such as n-term/c-term extensions.

aa(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild) → str¶

get annotated amino acid string

C++: protocols::forge::build::SegmentRebuild::aa() const –> const std::string &

add_dependency_to(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, i: pyrosetta.rosetta.std.weak_ptr_const_protocols_forge_build_BuildInstruction_t) → None¶

add an instruction to this BuildInstruction’s dependency list

before this instruction’s modify() may complete properly, all
instructions in the dependency list must have completed modify() first

C++: protocols::forge::build::BuildInstruction::add_dependency_to(class std::weak_ptr<const class protocols::forge::build::BuildInstruction>) –> void

assign(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild, rval: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild) → pyrosetta.rosetta.protocols.forge.build.SegmentRebuild¶

copy assignment

C++: protocols::forge::build::SegmentRebuild::operator=(const class protocols::forge::build::SegmentRebuild &) –> class protocols::forge::build::SegmentRebuild &

attach_to(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

attach to a Pose’s conformation

C++: protocols::forge::build::BuildInstruction::attach_to(class core::pose::Pose &) –> void

clear_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None¶

clear the list of dependencies

C++: protocols::forge::build::BuildInstruction::clear_dependencies() –> void

clone(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild) → pyrosetta.rosetta.protocols.forge.build.BuildInstruction¶

clone this object

C++: protocols::forge::build::SegmentRebuild::clone() const –> class std::shared_ptr<class protocols::forge::build::BuildInstruction>

compatible_with(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, rval: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

compares fixed and mutable positions to determine compatibility with: another instruction

override this to obtain custom compatibility check

C++: protocols::forge::build::BuildInstruction::compatible_with(const class protocols::forge::build::BuildInstruction &) const –> bool

creates_undefined_backbone(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild) → bool¶

does this object create undefined backbone in the modified region?

true

C++: protocols::forge::build::SegmentRebuild::creates_undefined_backbone() const –> bool

defined_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return a copy of the set of positions within the newly modified

region that has a defined conformation. E.g. existing or copied residues.

An empty set – no positions are defined.

This set can change wrt length changes in Pose/Conformation being: watched.

C++: protocols::forge::build::SegmentRebuild::defined_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.utility.vector1_std_weak_ptr_const_protocols_forge_build_BuildInstruction_t¶

the list of instructions whose modify() must complete before: the modify() for this instruction may be called successfully

C++: protocols::forge::build::BuildInstruction::dependencies() const –> const class utility::vector1<class std::weak_ptr<const class protocols::forge::build::BuildInstruction>, class std::allocator<class std::weak_ptr<const class protocols::forge::build::BuildInstruction> > > &

dependent_on(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, i: pyrosetta.rosetta.std.weak_ptr_const_protocols_forge_build_BuildInstruction_t) → bool¶

is this instruction dependent upon the given instruction?

C++: protocols::forge::build::BuildInstruction::dependent_on(class std::weak_ptr<const class protocols::forge::build::BuildInstruction>) const –> bool

detach_after_modify(*args, **kwargs)¶

Overloaded function.

detach_after_modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) -> bool

detach after modify()?

Ordinarily a modify() call consists of attaching as a
length obs of the Pose, actually doing the modify, and then detaching as a length obs of the Pose. This flag governs whether the last detach occurs.

C++: protocols::forge::build::BuildInstruction::detach_after_modify() const –> bool

detach_after_modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, flag: bool) -> None

set detach after modify()

Ordinarily a modify() call consists of attaching as a
length obs of the Pose, actually doing the modify, and then detaching as a length obs of the Pose. This flag governs whether the last detach occurs.

C++: protocols::forge::build::BuildInstruction::detach_after_modify(const bool) –> void

detach_from(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None¶

detach from a Pose’s conformation

C++: protocols::forge::build::BuildInstruction::detach_from() –> void

has_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

does this BuildInstruction have dependencies?

C++: protocols::forge::build::BuildInstruction::has_dependencies() const –> bool

interval(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild) → pyrosetta.rosetta.protocols.forge.build.Interval¶

a copy of the working range of residues specifying the modified region

this can change if listening to Conformation LengthEvents

C++: protocols::forge::build::SegmentRebuild::interval() const –> struct protocols::forge::build::Interval

keep_known_bb_torsions_at_junctions(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild) → bool¶

Attempt to keep the omega at original_interval().left-1, the phi: at original_interval().left and the psi+omega at original_interval().right present from the original Pose in the modified Pose? Default False

C++: protocols::forge::build::SegmentRebuild::keep_known_bb_torsions_at_junctions() const –> bool

modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.protocols.forge.build.BuildInstructionState.Enum¶

modify this pose

the state of the BuildInstruction

C++: protocols::forge::build::BuildInstruction::modify(class core::pose::Pose &) –> enum protocols::forge::build::BuildInstructionState::Enum

modify_was_successful(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

Is the BuildInstruction’s state at MODIFY_WAS_SUCCESSFUL?

MODIFY_WAS_SUCCESSFUL indicates the BuildInstruction has
finished modifications to the Pose, and its residue indexing is now consistent with the newly modified Pose.

C++: protocols::forge::build::BuildInstruction::modify_was_successful() const –> bool

movemap(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild) → pyrosetta.rosetta.core.kinematics.MoveMap¶

return a copy of the MoveMap that defines the moveable/fixed

positions/dofs for this instruction

a MoveMap with [interval.left, interval.right] bb & chi set to true: at the MoveMapTorsionID level
This set can change wrt length changes in Pose/Conformation being: watched.

C++: protocols::forge::build::SegmentRebuild::movemap() const –> class core::kinematics::MoveMap

n_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → int¶

the number of dependencies this BuildInstruction has

C++: protocols::forge::build::BuildInstruction::n_dependencies() const –> unsigned long

new_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return a copy of the set of positions that are “new” and did

not exist in the original Pose.

A set of positions spanning the entire modified interval – all: positions are undefined.

C++: protocols::forge::build::SegmentRebuild::new_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

on_length_change(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None¶

update any indexing wrt length change to Pose/Conformation being watched

C++: protocols::forge::build::BuildInstruction::on_length_change(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_append(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None¶

update indexing on residue append

C++: protocols::forge::build::SegmentRebuild::on_residue_append(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_delete(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None¶

update indexing on residue delete

C++: protocols::forge::build::SegmentRebuild::on_residue_delete(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_prepend(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None¶

update indexing on residue prepend

C++: protocols::forge::build::SegmentRebuild::on_residue_prepend(const struct core::conformation::signals::LengthEvent &) –> void

original_deleted_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return set of positions within the original interval that will: be deleted in this BuildInstruction

A set containing all positions in the original interval.

C++: protocols::forge::build::SegmentRebuild::original_deleted_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_fixed_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return set of any fixed positions necessary with respect to the original

interval and original Pose numbering

Used for ensuring build regions for instructions do not overlap and: so that jumps may be placed correctly. If SegmentRebuild has dependencies, the set of positions shrinks from the endpoints of [original_left - 1, original_right + 1] down to an empty set in the assumption that the user is requesting an advanced feature and knows what they’re doing around the endpoints, e.g. rebuilding directly adjacent to a swapped out section.

empty set if no fixed positions

C++: protocols::forge::build::SegmentRebuild::original_fixed_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_interval(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.protocols.forge.build.Interval¶

return original residue range of this instruction

C++: protocols::forge::build::BuildInstruction::original_interval() const –> const struct protocols::forge::build::Interval &

original_interval_valid(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild) → bool¶

is the original interval storing valid information, or is empty: or being used for something else?

true, stores valid interval

C++: protocols::forge::build::SegmentRebuild::original_interval_valid() const –> bool

original_kept_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return the set of positions within the original interval that: will be kept in this BuildInstruction

An empty set – no positions are kept.

C++: protocols::forge::build::SegmentRebuild::original_kept_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_mutable_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return set of any mutable positions necessary with respect to the original

interval and original Pose numbering

Used for ensuring build regions for instructions do not overlap and: so that jumps may be placed correctly.

empty set if no mutable positions

C++: protocols::forge::build::SegmentRebuild::original_mutable_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

preexisting_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return a copy of the set of positions within the new region: that were pre-existing in the original Pose prior to modify()

An empty set – no positions are pre-existing.

C++: protocols::forge::build::SegmentRebuild::preexisting_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

ready(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

Is the BuildInstruction’s state at READY?

READY indicates the BuildInstruction has been reset
and is ready to modify a Pose.

C++: protocols::forge::build::BuildInstruction::ready() const –> bool

reset_accounting(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None¶

reset intervals, positions, etc to initial state and drop: observers. State set to READY.

C++: protocols::forge::build::BuildInstruction::reset_accounting() –> void

residue_type_set(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.core.chemical.ResidueTypeSet¶

the residue type set being used

C++: protocols::forge::build::BuildInstruction::residue_type_set() const –> const class core::chemical::ResidueTypeSet &

ss(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild) → str¶

get secondary structure string

C++: protocols::forge::build::SegmentRebuild::ss() const –> const std::string &

state(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.protocols.forge.build.BuildInstructionState.Enum¶

return the state of this BuildInstruction

C++: protocols::forge::build::BuildInstruction::state() const –> enum protocols::forge::build::BuildInstructionState::Enum

undefined_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentRebuild) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return a copy of the set of positions within the newly modified

region that has an undefined conformation. E.g. newly created residues.

A set of positions spanning the entire modified interval – all: positions are undefined.
This set can change wrt length changes in Pose/Conformation being: watched.

C++: protocols::forge::build::SegmentRebuild::undefined_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

waiting_on_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

Is the BuildInstruction’s state at WAITING_ON_DEPENDENCIES?

WAITING_ON_DEPENDENCIES indicates
the BuildInstruction is waiting for its dependencies to be satisfied before allowing modifications to proceed.

C++: protocols::forge::build::BuildInstruction::waiting_on_dependencies() const –> bool

class pyrosetta.rosetta.protocols.forge.build.SegmentSwap¶

Bases: BuildInstruction

instruction to swap a segment with an external segment

add_dependency_to(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, i: pyrosetta.rosetta.std.weak_ptr_const_protocols_forge_build_BuildInstruction_t) → None¶

add an instruction to this BuildInstruction’s dependency list

before this instruction’s modify() may complete properly, all
instructions in the dependency list must have completed modify() first

C++: protocols::forge::build::BuildInstruction::add_dependency_to(class std::weak_ptr<const class protocols::forge::build::BuildInstruction>) –> void

assign(self: pyrosetta.rosetta.protocols.forge.build.SegmentSwap, rval: pyrosetta.rosetta.protocols.forge.build.SegmentSwap) → pyrosetta.rosetta.protocols.forge.build.SegmentSwap¶

copy assignment

C++: protocols::forge::build::SegmentSwap::operator=(const class protocols::forge::build::SegmentSwap &) –> class protocols::forge::build::SegmentSwap &

attach_to(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

attach to a Pose’s conformation

C++: protocols::forge::build::BuildInstruction::attach_to(class core::pose::Pose &) –> void

clear_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None¶

clear the list of dependencies

C++: protocols::forge::build::BuildInstruction::clear_dependencies() –> void

clone(self: pyrosetta.rosetta.protocols.forge.build.SegmentSwap) → pyrosetta.rosetta.protocols.forge.build.BuildInstruction¶

clone this object

C++: protocols::forge::build::SegmentSwap::clone() const –> class std::shared_ptr<class protocols::forge::build::BuildInstruction>

compatible_with(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, rval: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

compares fixed and mutable positions to determine compatibility with: another instruction

override this to obtain custom compatibility check

C++: protocols::forge::build::BuildInstruction::compatible_with(const class protocols::forge::build::BuildInstruction &) const –> bool

creates_undefined_backbone(self: pyrosetta.rosetta.protocols.forge.build.SegmentSwap) → bool¶

does this object create undefined backbone in the modified region?

C++: protocols::forge::build::SegmentSwap::creates_undefined_backbone() const –> bool

defined_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentSwap) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return a copy of the set of positions within the newly modified

region that has a defined conformation. E.g. existing or copied residues.

A set of positions spanning the interval – all positions are: are defined.
This set can change wrt length changes in Pose/Conformation being: watched.

C++: protocols::forge::build::SegmentSwap::defined_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.utility.vector1_std_weak_ptr_const_protocols_forge_build_BuildInstruction_t¶

the list of instructions whose modify() must complete before: the modify() for this instruction may be called successfully

C++: protocols::forge::build::BuildInstruction::dependencies() const –> const class utility::vector1<class std::weak_ptr<const class protocols::forge::build::BuildInstruction>, class std::allocator<class std::weak_ptr<const class protocols::forge::build::BuildInstruction> > > &

dependent_on(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, i: pyrosetta.rosetta.std.weak_ptr_const_protocols_forge_build_BuildInstruction_t) → bool¶

is this instruction dependent upon the given instruction?

C++: protocols::forge::build::BuildInstruction::dependent_on(class std::weak_ptr<const class protocols::forge::build::BuildInstruction>) const –> bool

detach_after_modify(*args, **kwargs)¶

Overloaded function.

detach_after_modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) -> bool

detach after modify()?

Ordinarily a modify() call consists of attaching as a
length obs of the Pose, actually doing the modify, and then detaching as a length obs of the Pose. This flag governs whether the last detach occurs.

C++: protocols::forge::build::BuildInstruction::detach_after_modify() const –> bool

detach_after_modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, flag: bool) -> None

set detach after modify()

Ordinarily a modify() call consists of attaching as a
length obs of the Pose, actually doing the modify, and then detaching as a length obs of the Pose. This flag governs whether the last detach occurs.

C++: protocols::forge::build::BuildInstruction::detach_after_modify(const bool) –> void

detach_from(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None¶

detach from a Pose’s conformation

C++: protocols::forge::build::BuildInstruction::detach_from() –> void

has_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

does this BuildInstruction have dependencies?

C++: protocols::forge::build::BuildInstruction::has_dependencies() const –> bool

interval(self: pyrosetta.rosetta.protocols.forge.build.SegmentSwap) → pyrosetta.rosetta.protocols.forge.build.Interval¶

a copy of the working range of residues specifying the swapped region

This residue range can change wrt length changes in Pose /Conformation
being watched.

C++: protocols::forge::build::SegmentSwap::interval() const –> struct protocols::forge::build::Interval

modify(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.protocols.forge.build.BuildInstructionState.Enum¶

modify this pose

the state of the BuildInstruction

C++: protocols::forge::build::BuildInstruction::modify(class core::pose::Pose &) –> enum protocols::forge::build::BuildInstructionState::Enum

modify_was_successful(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

Is the BuildInstruction’s state at MODIFY_WAS_SUCCESSFUL?

MODIFY_WAS_SUCCESSFUL indicates the BuildInstruction has
finished modifications to the Pose, and its residue indexing is now consistent with the newly modified Pose.

C++: protocols::forge::build::BuildInstruction::modify_was_successful() const –> bool

movemap(self: pyrosetta.rosetta.protocols.forge.build.SegmentSwap) → pyrosetta.rosetta.core.kinematics.MoveMap¶

return a copy of the MoveMap that defines the moveable/fixed

positions/dofs for this instruction

a MoveMap with [interval.left, interval.right] bb set to false: at the MoveMapTorsionID level
This set can change wrt length changes in Pose/Conformation being: watched.

C++: protocols::forge::build::SegmentSwap::movemap() const –> class core::kinematics::MoveMap

n_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → int¶

the number of dependencies this BuildInstruction has

C++: protocols::forge::build::BuildInstruction::n_dependencies() const –> unsigned long

new_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentSwap) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return a copy of the set of positions that are “new” and did

not exist in the original Pose.

A set of positions spanning the interval – all positions are: are defined.

C++: protocols::forge::build::SegmentSwap::new_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

on_length_change(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None¶

update any indexing wrt length change to Pose/Conformation being watched

C++: protocols::forge::build::BuildInstruction::on_length_change(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_append(self: pyrosetta.rosetta.protocols.forge.build.SegmentSwap, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None¶

update indexing on residue append

C++: protocols::forge::build::SegmentSwap::on_residue_append(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_delete(self: pyrosetta.rosetta.protocols.forge.build.SegmentSwap, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None¶

update indexing on residue delete

C++: protocols::forge::build::SegmentSwap::on_residue_delete(const struct core::conformation::signals::LengthEvent &) –> void

on_residue_prepend(self: pyrosetta.rosetta.protocols.forge.build.SegmentSwap, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None¶

update indexing on residue prepend

C++: protocols::forge::build::SegmentSwap::on_residue_prepend(const struct core::conformation::signals::LengthEvent &) –> void

original_deleted_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentSwap) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return set of positions within the original interval that will: be deleted in this BuildInstruction

An empty set – no positions are deleted.

C++: protocols::forge::build::SegmentSwap::original_deleted_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_fixed_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentSwap) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return set of any fixed positions necessary with respect to the original

interval and original Pose numbering

Used for ensuring build regions for instructions do not overlap and: so that jumps may be placed correctly.

empty set if no fixed positions necessary

C++: protocols::forge::build::SegmentSwap::original_fixed_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_interval(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.protocols.forge.build.Interval¶

return original residue range of this instruction

C++: protocols::forge::build::BuildInstruction::original_interval() const –> const struct protocols::forge::build::Interval &

original_interval_valid(self: pyrosetta.rosetta.protocols.forge.build.SegmentSwap) → bool¶

is the original interval storing valid information, or is empty: or being used for something else?

true, stores valid interval

C++: protocols::forge::build::SegmentSwap::original_interval_valid() const –> bool

original_kept_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentSwap) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return the set of positions within the original interval that: will be kept in this BuildInstruction

An empty set – no positions are kept.

C++: protocols::forge::build::SegmentSwap::original_kept_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

original_mutable_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentSwap) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return set of any mutable positions necessary with respect to the original

interval and original Pose numbering

Used for ensuring build regions for instructions do not overlap and: so that jumps may be placed correctly.

C++: protocols::forge::build::SegmentSwap::original_mutable_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

preexisting_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentSwap) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return a copy of the set of positions within the new region: that were pre-existing in the original Pose prior to modify()

An empty set – no positions are pre-existing.

C++: protocols::forge::build::SegmentSwap::preexisting_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

ready(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

Is the BuildInstruction’s state at READY?

READY indicates the BuildInstruction has been reset
and is ready to modify a Pose.

C++: protocols::forge::build::BuildInstruction::ready() const –> bool

reset_accounting(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → None¶

reset intervals, positions, etc to initial state and drop: observers. State set to READY.

C++: protocols::forge::build::BuildInstruction::reset_accounting() –> void

residue_type_set(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.core.chemical.ResidueTypeSet¶

the residue type set being used

C++: protocols::forge::build::BuildInstruction::residue_type_set() const –> const class core::chemical::ResidueTypeSet &

state(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → pyrosetta.rosetta.protocols.forge.build.BuildInstructionState.Enum¶

return the state of this BuildInstruction

C++: protocols::forge::build::BuildInstruction::state() const –> enum protocols::forge::build::BuildInstructionState::Enum

swap_in(self: pyrosetta.rosetta.protocols.forge.build.SegmentSwap) → pyrosetta.rosetta.core.pose.Pose¶

the pose to swap in

C++: protocols::forge::build::SegmentSwap::swap_in() const –> const class core::pose::Pose &

swap_in_movemap(self: pyrosetta.rosetta.protocols.forge.build.SegmentSwap) → pyrosetta.rosetta.core.kinematics.MoveMap¶

fixed backbone residues in this movemap will be used for new jumps

Procedure will attempt to honor this 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 (lower) median residue in the disconnected fold tree interval.

C++: protocols::forge::build::SegmentSwap::swap_in_movemap() const –> const class core::kinematics::MoveMap &

undefined_positions(self: pyrosetta.rosetta.protocols.forge.build.SegmentSwap) → pyrosetta.rosetta.std.set_unsigned_long_t¶

return a copy of the set of positions within the newly modified

region that has an undefined conformation. E.g. newly created residues.

An empty set – no undefined positions.

This set can change wrt length changes in Pose/Conformation being: watched.

C++: protocols::forge::build::SegmentSwap::undefined_positions() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

waiting_on_dependencies(self: pyrosetta.rosetta.protocols.forge.build.BuildInstruction) → bool¶

Is the BuildInstruction’s state at WAITING_ON_DEPENDENCIES?

WAITING_ON_DEPENDENCIES indicates
the BuildInstruction is waiting for its dependencies to be satisfied before allowing modifications to proceed.

C++: protocols::forge::build::BuildInstruction::waiting_on_dependencies() const –> bool