grafting¶

simple_movers

Bindings for protocols::grafting namespace

class pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover¶

Bases: pyrosetta.rosetta.protocols.grafting.GraftMoverBase

Grafting class adapted from Steven Lewis’ pose_into_pose algorithm.

Inserts the pose piece into the scaffold pose, deleting any overhang residues or residues in the region the insertion will occur between.
Connects the left side of the piece to the scaffold by inserting ideal geometry

(aka superposition of terminal overhangs is not needed)
Cycles of:
1. SmallMover for sampling
2. CCD to close right (Nter) side of the graft.
The insert is included as dihedral-inflexible residues in the CCD arm. Residues on either side of the scaffold are used by default to close the loop. A Moevemap can be given to include more residues for CCD to use, such as loops connecting secondary structural elements
1. MinMover to help close the graft through chainbreak terms
d) Closure check - will stop if closed (This can be overridden) d) MonteCarlo Boltzmann criterion

Repack flexible residues, insert residues, connecting residues between scaffold and insert, and neighbors

example:: mover = AnchoredGraftMover(start, end, piece, cter_overhang, nter_overhang); mover.apply(pose);

see also: grafting/util.hh.

Uses a single arm to close the loop by default. **Nter_loop_start—->Piece—-> | Cter_loop_end** Default movemap keeps insert Frozen in dihedral angle space, But think of the insert as part of a CCD giant arm. Default flexibility on Nter and Cter is only two residues (–> part of diagram). Will delete any residues between start and end, and any overhang residues from the insert.

Algorithm originally from pose_into_pose: The insert will be left unchanged in internal-coordinate space except for the phi on the first residue, and the psi/omega on the last residue, and atoms whose bonding partners change as a result of the insertion. Internally, apply performs the insertion, idealizes the loop residues (omegas to 180, peptide bonds idealized) and the newly made polymer connections at the insert point, and then attempts to close the loop(s). It is intended, but not guaranteed, to produce a graft with good rama, omega, and chainbreak/peptide_bond scores. All-atom minimization of graft or pose after insertion is recommended.

__delattr__¶: Implement delattr(self, name).

__dir__() → list¶: default dir() implementation

__eq__¶: Return self==value.

__format__()¶: default object formatter

__ge__¶: Return self>=value.

__getattribute__¶: Return getattr(self, name).

__gt__¶: Return self>value.

__hash__¶: Return hash(self).

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover) -> None
__init__(self: pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover, arg0: int, arg1: int) -> None

doc

__init__(self: pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover, start: int, end: int, copy_pdbinfo: bool) -> None
__init__(self: pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover, arg0: int, arg1: int, arg2: pyrosetta.rosetta.core.pose.Pose) -> None

doc

__init__(self: pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover, arg0: int, arg1: int, arg2: pyrosetta.rosetta.core.pose.Pose, arg3: int) -> None

doc

__init__(self: pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover, arg0: int, arg1: int, arg2: pyrosetta.rosetta.core.pose.Pose, arg3: int, arg4: int) -> None

doc

__init__(self: pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover, start: int, end: int, piece: pyrosetta.rosetta.core.pose.Pose, Nter_overhang_length: int, Cter_overhang_length: int, copy_pdbinfo: bool) -> None
__init__(self: pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover, arg0: pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover) -> None

__init_subclass__()¶

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__¶: Return self<=value.

__lt__¶: Return self<value.

__ne__¶: Return self!=value.

__new__()¶: Create and return a new object. See help(type) for accurate signature.

__reduce__()¶: helper for pickle

__reduce_ex__()¶: helper for pickle

__repr__¶: Return repr(self).

__setattr__¶: Implement setattr(self, name, value).

__sizeof__() → int¶: size of object in memory, in bytes

__str__¶: Return str(self).

__subclasshook__()¶

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

apply(self: pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Grafts the piece into the pose, uses CCD to close the connection. Insert does not change dihedral space, but DOES change cartesian space by default. Does not repack any sidechains. Deletes overhang and region between start and end if residues are present.

C++: protocols::grafting::AnchoredGraftMover::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover, : pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover) → pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover¶: C++: protocols::grafting::AnchoredGraftMover::operator=(const class protocols::grafting::AnchoredGraftMover &) –> class protocols::grafting::AnchoredGraftMover &

clear_info(self: pyrosetta.rosetta.protocols.moves.Mover) → None¶

Strings container can be used to return miscellaneous info (as std::string) from a mover, such as notes about the results of apply(). The job distributor (Apr 09 vintage) will check this function to see if your protocol wants to add string info to the Job that ran this mover. One way this can be useful is that later, a JobOutputter may include/append this info to an output file.

clear_info is called by jd2 before calling apply

C++: protocols::moves::Mover::clear_info() –> void

clone(self: pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::grafting::AnchoredGraftMover::clone() const –> class std::shared_ptr<class protocols::moves::Mover>

complex_type_generator_for_anchored_graft_mover(: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator¶: C++: protocols::grafting::AnchoredGraftMover::complex_type_generator_for_anchored_graft_mover(class utility::tag::XMLSchemaDefinition &) –> class std::shared_ptr<class utility::tag::XMLSchemaComplexTypeGenerator>

copy_pdbinfo(*args, **kwargs)¶

Overloaded function.

copy_pdbinfo(self: pyrosetta.rosetta.protocols.grafting.GraftMoverBase, copy_pdbinfo: bool) -> None

Copy PDBInfo from the pose piece into pose during graft. If false(default), PDBInfo will be obsoleted.

C++: protocols::grafting::GraftMoverBase::copy_pdbinfo(bool) –> void

copy_pdbinfo(self: pyrosetta.rosetta.protocols.grafting.GraftMoverBase) -> bool

C++: protocols::grafting::GraftMoverBase::copy_pdbinfo() const –> bool

create(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::moves::Mover::create() –> class std::shared_ptr<class protocols::moves::Mover>

end(self: pyrosetta.rosetta.protocols.grafting.GraftMoverBase) → int¶: C++: protocols::grafting::GraftMoverBase::end() –> unsigned long

final_repack(*args, **kwargs)¶

Overloaded function.

final_repack(self: pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover, final_repack: bool) -> None

Pack sidechains of flexible residues, insert and neighbors at end?: Default True.

C++: protocols::grafting::AnchoredGraftMover::final_repack(bool) –> void

final_repack(self: pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover) -> bool

Pack sidechains of flexible residues, insert and neighbors at end?

C++: protocols::grafting::AnchoredGraftMover::final_repack() –> bool

fresh_instance(self: pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::grafting::AnchoredGraftMover::fresh_instance() const –> class std::shared_ptr<class protocols::moves::Mover>

get_Cter_loop_end(self: pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover) → int¶

the Cterminal loop end (Last flexible residue). Useful to use after insertion.

C++: protocols::grafting::AnchoredGraftMover::get_Cter_loop_end() –> unsigned long

get_additional_output(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.core.pose.Pose¶

fpd

Mechanism by which a mover may return multiple output poses from a single input pose.

C++: protocols::moves::Mover::get_additional_output() –> class std::shared_ptr<class core::pose::Pose>

get_cterm_insert_flexibility(self: pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover) → int¶: C++: protocols::grafting::AnchoredGraftMover::get_cterm_insert_flexibility() –> unsigned long

get_cterm_scaffold_flexibility(self: pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover) → int¶: C++: protocols::grafting::AnchoredGraftMover::get_cterm_scaffold_flexibility() –> unsigned long

get_current_job(self: pyrosetta.rosetta.protocols.moves.Mover) → protocols::jobdist::BasicJob¶: C++: protocols::moves::Mover::get_current_job() const –> class std::shared_ptr<const class protocols::jobdist::BasicJob>

get_current_tag(self: pyrosetta.rosetta.protocols.moves.Mover) → str¶

A tag is a unique identifier used to identify structures produced: by this Mover. get_current_tag() returns the tag, and set_current_tag( std::string tag ) sets the tag. This functionality is not intended for use with the 2008 job distributor.

C++: protocols::moves::Mover::get_current_tag() const –> std::string

get_input_pose(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.core.pose.Pose¶: C++: protocols::moves::Mover::get_input_pose() const –> class std::shared_ptr<const class core::pose::Pose>

get_last_move_status(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.protocols.moves.MoverStatus¶

returns status after an apply(). The job distributor (august 08 vintage) will check this function to see if your protocol wants to filter its results - if your protocol wants to say “that run was no good, skip it” then use the protected last_move_status(MoverStatus) to change the value that this function will return.

C++: protocols::moves::Mover::get_last_move_status() const –> enum protocols::moves::MoverStatus

get_loops(self: pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover) → pyrosetta.rosetta.protocols.loops.Loops¶: C++: protocols::grafting::AnchoredGraftMover::get_loops() –> class protocols::loops::Loops

get_name(self: pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover) → str¶: C++: protocols::grafting::AnchoredGraftMover::get_name() const –> std::string

get_native_pose(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.core.pose.Pose¶: C++: protocols::moves::Mover::get_native_pose() const –> class std::shared_ptr<const class core::pose::Pose>

get_nterm_insert_flexibility(self: pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover) → int¶: C++: protocols::grafting::AnchoredGraftMover::get_nterm_insert_flexibility() –> unsigned long

get_nterm_scaffold_flexibility(self: pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover) → int¶: C++: protocols::grafting::AnchoredGraftMover::get_nterm_scaffold_flexibility() –> unsigned long

get_self_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::moves::Mover::get_self_ptr() –> class std::shared_ptr<class protocols::moves::Mover>

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.weak_ptr_protocols_moves_Mover_t¶: C++: protocols::moves::Mover::get_self_weak_ptr() –> class std::weak_ptr<class protocols::moves::Mover>

get_type(self: pyrosetta.rosetta.protocols.moves.Mover) → str¶: C++: protocols::moves::Mover::get_type() const –> std::string

idealize_insert(*args, **kwargs)¶

Overloaded function.

idealize_insert(self: pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover, idealize: bool) -> None

C++: protocols::grafting::AnchoredGraftMover::idealize_insert(bool) –> void

idealize_insert(self: pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover) -> bool

C++: protocols::grafting::AnchoredGraftMover::idealize_insert() const –> bool

info(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.list_std_string_std_allocator_std_string_t¶

non-const accessor

C++: protocols::moves::Mover::info() –> class std::list<std::string, class std::allocator<std::string > > &

insertion_length(self: pyrosetta.rosetta.protocols.grafting.GraftMoverBase) → int¶: C++: protocols::grafting::GraftMoverBase::insertion_length() –> unsigned long

last_proposal_density_ratio(self: pyrosetta.rosetta.protocols.moves.Mover) → float¶: C++: protocols::moves::Mover::last_proposal_density_ratio() –> double

mover_name() → str¶: C++: protocols::grafting::AnchoredGraftMover::mover_name() –> std::string

name() → str¶: C++: protocols::moves::Mover::name() –> std::string

neighbor_dis(*args, **kwargs)¶

Overloaded function.

neighbor_dis(self: pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover, dis: float) -> None

Neighbor distance for any repacking of side-chains.

C++: protocols::grafting::AnchoredGraftMover::neighbor_dis(double) –> void

neighbor_dis(self: pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover) -> float

C++: protocols::grafting::AnchoredGraftMover::neighbor_dis() const –> double

original_end(self: pyrosetta.rosetta.protocols.grafting.GraftMoverBase) → int¶: C++: protocols::grafting::GraftMoverBase::original_end() –> unsigned long

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None¶: C++: protocols::grafting::AnchoredGraftMover::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

register_options() → None¶

Overload this static method if you access options within the mover.

These options will end up in -help of your application if users of this mover call register_options. Do this recursively! If you use movers within your mover, call their register_options in your register_options() method.

C++: protocols::moves::Mover::register_options() –> void

reinitialize_for_each_job(self: pyrosetta.rosetta.protocols.moves.Mover) → bool¶

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be freshly regenerated on: each use.

C++: protocols::moves::Mover::reinitialize_for_each_job() const –> bool

reinitialize_for_new_input(self: pyrosetta.rosetta.protocols.moves.Mover) → bool¶

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be regenerated when the input: pose is about to change, (for example, if the Mover has special code on the first apply() that is only valid for that one input pose).

C++: protocols::moves::Mover::reinitialize_for_new_input() const –> bool

reset_status(self: pyrosetta.rosetta.protocols.moves.Mover) → None¶

resets status to SUCCESS, meant to be used before an apply(). The job distributor (august 08 vintage) uses this to ensure non-accumulation of status across apply()s.

C++: protocols::moves::Mover::reset_status() –> void

set_cen_scorefunction(self: pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover, score: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶: C++: protocols::grafting::AnchoredGraftMover::set_cen_scorefunction(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> void

set_current_job(self: pyrosetta.rosetta.protocols.moves.Mover, job: protocols::jobdist::BasicJob) → None¶

////////////////////////////end Job Distributor interface////////////////////////////////////////

C++: protocols::moves::Mover::set_current_job(class std::shared_ptr<const class protocols::jobdist::BasicJob>) –> void

set_current_tag(self: pyrosetta.rosetta.protocols.moves.Mover, new_tag: str) → None¶: C++: protocols::moves::Mover::set_current_tag(const class std::basic_string<char> &) –> void

set_cycles(self: pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover, cycles: int) → None¶: C++: protocols::grafting::AnchoredGraftMover::set_cycles(unsigned long) –> void

set_defaults(self: pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover) → None¶: C++: protocols::grafting::AnchoredGraftMover::set_defaults() –> void

set_fa_scorefunction(self: pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover, score: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶: C++: protocols::grafting::AnchoredGraftMover::set_fa_scorefunction(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> void

set_input_pose(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

setter for poses contained for rms

C++: protocols::moves::Mover::set_input_pose(class std::shared_ptr<const class core::pose::Pose>) –> void

set_insert_flexibility(self: pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover, Nter_insert_flexibility: int, Cter_insert_flexibility: int) → None¶

Sets insert flexibility on either end of insert

C++: protocols::grafting::AnchoredGraftMover::set_insert_flexibility(const unsigned long, const unsigned long) –> void

set_insert_region(self: pyrosetta.rosetta.protocols.grafting.GraftMoverBase, start: int, end: int) → None¶: C++: protocols::grafting::GraftMoverBase::set_insert_region(const unsigned long, const unsigned long) –> void

set_mintype(self: pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover, mintype: str) → None¶

Sets the mintype for the MinMover

C++: protocols::grafting::AnchoredGraftMover::set_mintype(class std::basic_string<char>) –> void

set_movemaps(self: pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover, scaffold_mm: pyrosetta.rosetta.core.kinematics.MoveMap, insert_mm: pyrosetta.rosetta.core.kinematics.MoveMap) → None¶: Advanced way to set flexibility and residues used for CCD

Will combine the movemaps for apply, and renumber everything. Flexible residues in multiple chains not recommended. From the first bb flexible residue to the last will act as one giant CCD arm,

using those residues for minimization and CCD that have bb true in movemap. This can be amazing as you can use loop regions in various parts of your protein to help the graft complete.

Note: Will disregard flexibility settings, as the movemaps will be used as primary way to define flexibility. May want to consider turning off the sampling step when passing crazy movemaps.

C++: protocols::grafting::AnchoredGraftMover::set_movemaps(const class std::shared_ptr<const class core::kinematics::MoveMap>, const class std::shared_ptr<const class core::kinematics::MoveMap>) –> void

set_native_pose(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

setter for native poses contained for rms —- we should get rid of this method? it is widely used, but a bit unsafe

C++: protocols::moves::Mover::set_native_pose(class std::shared_ptr<const class core::pose::Pose>) –> void

set_piece(self: pyrosetta.rosetta.protocols.grafting.GraftMoverBase, piece: pyrosetta.rosetta.core.pose.Pose, Nter_overhang_length: int, Cter_overhang_length: int) → None¶

Sets the piece that will be inserted, and any overhang residues.

Overhang residues are residues not being inserted into the scaffold. These residues are deleted before insertion and are used by classes usually for superposition or Initial orientation of the insert relative to the scaffold.

C++: protocols::grafting::GraftMoverBase::set_piece(const class core::pose::Pose &, unsigned long, unsigned long) –> void

set_scaffold_flexibility(self: pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover, Nter_scaffold_flexibility: int, Cter_scaffold_flexibility: int) → None¶

Sets scaffold flexiblity on either end of scaffold

C++: protocols::grafting::AnchoredGraftMover::set_scaffold_flexibility(const unsigned long, const unsigned long) –> void

set_skip_sampling(self: pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover, skip_sampling: bool) → None¶

Sets the mover to skip the small mover sampling step.

C++: protocols::grafting::AnchoredGraftMover::set_skip_sampling(bool) –> void

set_type(self: pyrosetta.rosetta.protocols.moves.Mover, setting: str) → None¶: C++: protocols::moves::Mover::set_type(const class std::basic_string<char> &) –> void

show(*args, **kwargs)¶

Overloaded function.

show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None
show(self: pyrosetta.rosetta.protocols.moves.Mover, output: pyrosetta.rosetta.std.ostream) -> None

Outputs details about the Mover, including current settings.

C++: protocols::moves::Mover::show(class std::basic_ostream<char> &) const –> void

start(self: pyrosetta.rosetta.protocols.grafting.GraftMoverBase) → int¶: C++: protocols::grafting::GraftMoverBase::start() –> unsigned long

stop_at_closure(*args, **kwargs)¶

Overloaded function.

stop_at_closure(self: pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover, stop_at_closure: bool) -> None

Stop at closure of both ends?: Default True.

C++: protocols::grafting::AnchoredGraftMover::stop_at_closure(bool) –> void

stop_at_closure(self: pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover) -> bool

Stop at closure of both ends?

C++: protocols::grafting::AnchoredGraftMover::stop_at_closure() –> bool

test_move(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

: Unit test support function. Apply one move to a given pose.: Allows extra test specific functions to be called before applying

C++: protocols::moves::Mover::test_move(class core::pose::Pose &) –> void

type(*args, **kwargs)¶

Overloaded function.

type(self: pyrosetta.rosetta.protocols.moves.Mover) -> str

C++: protocols::moves::Mover::type() const –> const std::string &

type(self: pyrosetta.rosetta.protocols.moves.Mover, type_in: str) -> None

C++: protocols::moves::Mover::type(const class std::basic_string<char> &) –> void

class pyrosetta.rosetta.protocols.grafting.CCDEndsGraftMover¶

Bases: pyrosetta.rosetta.protocols.grafting.AnchoredGraftMover

General purpose Grafting class which: 1) superimposes the insert onto the scaffold using any overhang residues, 2) Inserts the pose piece into the scaffold pose, deleting any overhang residues or residues in the region the isertion will occur between. 3) Cycles of:

SmallMover for sampling (Can be disabled))

CCDs both terminal ends of the scaffold using flexibility settings or movemap

To close the graft.

MinMover to help close the graft through chainbreak terms

d) Closure check - will return if closed (Can be disabled) d) MonteCarlo Boltzmann criterion

Repacks flexible residues and insert residues

Differs from AnchoredGraftMover in that the insert is held fixed in space after the superposition

example:: mover = CCDEndsGraftMover(start, end, piece, cter_overhang, nter_overhang) mover.apply(pose)