ligand_docking¶

Bindings for protocols::ligand_docking namespace

class pyrosetta.rosetta.protocols.ligand_docking.DistributionMap¶

Bases: pyrosetta.rosetta.utility.SingletonBase_protocols_ligand_docking_DistributionMap_t

A singleton class that returns a map of strings to enum types

__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).

__getitem__(self: pyrosetta.rosetta.protocols.ligand_docking.DistributionMap, distribution: str) → pyrosetta.rosetta.protocols.ligand_docking.Distribution¶: C++: protocols::ligand_docking::DistributionMap::operator[](class std::basic_string<char>) –> enum protocols::ligand_docking::Distribution

__gt__¶: Return self>value.

__hash__¶: Return hash(self).

__init__¶: Initialize self. See help(type(self)) for accurate signature.

__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).

get_instance() → protocols::ligand_docking::DistributionMap¶: C++: utility::SingletonBase<protocols::ligand_docking::DistributionMap>::get_instance() –> class protocols::ligand_docking::DistributionMap *

class pyrosetta.rosetta.protocols.ligand_docking.InterfaceBuilderLoader¶

Bases: pyrosetta.rosetta.protocols.parser.DataLoader

A class for loading InterfaceBuilders into the XML parser’s basic::datacache::DataMap.

__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__(self: pyrosetta.rosetta.protocols.ligand_docking.InterfaceBuilderLoader) → 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).

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

interface_builder_ct_namer(element_name: str) → str¶: C++: protocols::ligand_docking::InterfaceBuilderLoader::interface_builder_ct_namer(const class std::basic_string<char> &) –> std::string

load_data(self: pyrosetta.rosetta.protocols.ligand_docking.InterfaceBuilderLoader, pose: pyrosetta.rosetta.core.pose.Pose, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

The InterfaceBuilderLoader will create named InterfaceBuilders and load them into the basic::datacache::DataMap

C++: protocols::ligand_docking::InterfaceBuilderLoader::load_data(const class core::pose::Pose &, class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) const –> void

loader_name() → str¶: C++: protocols::ligand_docking::InterfaceBuilderLoader::loader_name() –> std::string

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

class pyrosetta.rosetta.protocols.ligand_docking.LigandBaseProtocol¶

Bases: pyrosetta.rosetta.protocols.moves.Mover

Shared functionality for protocols that dock ligands.

Includes score function setup, interface definitions, and ligand flexibility.

__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.ligand_docking.LigandBaseProtocol) -> None
__init__(self: pyrosetta.rosetta.protocols.ligand_docking.LigandBaseProtocol, arg0: pyrosetta.rosetta.protocols.ligand_docking.LigandBaseProtocol) -> 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.ligand_docking.LigandBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::ligand_docking::LigandBaseProtocol::apply(class core::pose::Pose &) –> void

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

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.moves.Mover) → pyrosetta.rosetta.protocols.moves.Mover¶

Return a clone of the Mover object.

C++: protocols::moves::Mover::clone() const –> class std::shared_ptr<class protocols::moves::Mover>

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>

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

Generates a new Mover object freshly created with the default ctor.

C++: protocols::moves::Mover::fresh_instance() const –> class std::shared_ptr<class protocols::moves::Mover>

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_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_ligand_id(*args, **kwargs)¶

Overloaded function.

get_ligand_id(self: pyrosetta.rosetta.protocols.ligand_docking.LigandBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose) -> int

C++: protocols::ligand_docking::LigandBaseProtocol::get_ligand_id(const class core::pose::Pose &) const –> unsigned long

get_ligand_id(self: pyrosetta.rosetta.protocols.ligand_docking.LigandBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, jump_id: int) -> int

C++: protocols::ligand_docking::LigandBaseProtocol::get_ligand_id(const class core::pose::Pose &, unsigned long) const –> unsigned long

get_ligand_jump_id(self: pyrosetta.rosetta.protocols.ligand_docking.LigandBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose) → int¶: C++: protocols::ligand_docking::LigandBaseProtocol::get_ligand_jump_id(const class core::pose::Pose &) const –> unsigned long

get_name(self: pyrosetta.rosetta.protocols.ligand_docking.LigandBaseProtocol) → str¶: C++: protocols::ligand_docking::LigandBaseProtocol::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_non_bb_clashing_rotamers(self: pyrosetta.rosetta.protocols.ligand_docking.LigandBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, seqpos: int, scofx: pyrosetta.rosetta.core.scoring.ScoreFunction, accepted_rotamers: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_conformation_Residue_t) → None¶: C++: protocols::ligand_docking::LigandBaseProtocol::get_non_bb_clashing_rotamers(const class core::pose::Pose &, unsigned long, class std::shared_ptr<const class core::scoring::ScoreFunction>, class utility::vector1<class std::shared_ptr<const class core::conformation::Residue>, class std::allocator<class std::shared_ptr<const class core::conformation::Residue> > > &) const –> void

get_scorefxn(self: pyrosetta.rosetta.protocols.ligand_docking.LigandBaseProtocol) → pyrosetta.rosetta.core.scoring.ScoreFunction¶: C++: protocols::ligand_docking::LigandBaseProtocol::get_scorefxn() –> class std::shared_ptr<class core::scoring::ScoreFunction>

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

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 > > &

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

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

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

reorder_foldtree_around_mobile_regions(self: pyrosetta.rosetta.protocols.ligand_docking.LigandBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, jump_id: int, mobile_bb: pyrosetta.rosetta.utility.vector1_bool, lig_id: int) → None¶: C++: protocols::ligand_docking::LigandBaseProtocol::reorder_foldtree_around_mobile_regions(class core::pose::Pose &, const unsigned long &, const class utility::vector1<bool, class std::allocator<bool> > &, const unsigned long &) const –> void

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

restrain_protein_Calphas(self: pyrosetta.rosetta.protocols.ligand_docking.LigandBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, is_restrained: pyrosetta.rosetta.utility.vector1_bool, restr_func: pyrosetta.rosetta.core.scoring.func.Func) → None¶: C++: protocols::ligand_docking::LigandBaseProtocol::restrain_protein_Calphas(class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &, class std::shared_ptr<class core::scoring::func::Func>) const –> 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_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_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_type(self: pyrosetta.rosetta.protocols.moves.Mover, setting: str) → None¶: C++: protocols::moves::Mover::set_type(const class std::basic_string<char> &) –> void

shared_from_this(self: pyrosetta.rosetta.protocols.ligand_docking.LigandBaseProtocol) → pyrosetta.rosetta.protocols.ligand_docking.LigandBaseProtocol¶: C++: protocols::ligand_docking::LigandBaseProtocol::shared_from_this() –> class std::shared_ptr<class protocols::ligand_docking::LigandBaseProtocol>

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

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.ligand_docking.MoveMapBuilderLoader¶

Bases: pyrosetta.rosetta.protocols.parser.DataLoader

A class for loading MoveMapBuilders into the XML parser’s basic::datacache::DataMap. NOTE that in the input .xml file, the InterfaceBuilder must be specified before the MoveMapBuilder

__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__(self: pyrosetta.rosetta.protocols.ligand_docking.MoveMapBuilderLoader) → 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).

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

load_data(self: pyrosetta.rosetta.protocols.ligand_docking.MoveMapBuilderLoader, pose: pyrosetta.rosetta.core.pose.Pose, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

The InterfaceBuilderLoader will create named InterfaceBuilders and load them into the basic::datacache::DataMap

C++: protocols::ligand_docking::MoveMapBuilderLoader::load_data(const class core::pose::Pose &, class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) const –> void

loader_name() → str¶: C++: protocols::ligand_docking::MoveMapBuilderLoader::loader_name() –> std::string

movemap_builder_ct_namer(element_name: str) → str¶: C++: protocols::ligand_docking::MoveMapBuilderLoader::movemap_builder_ct_namer(const class std::basic_string<char> &) –> std::string

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

class pyrosetta.rosetta.protocols.ligand_docking.RandomConformerMover¶

Bases: pyrosetta.rosetta.protocols.moves.Mover

Replace the residue at the given position with a randomly selected conformer from its rotamer library.

Only tested on ligand residues. If using torsion restraints, should be wrapped in an UnconstrainedTorsionsMover.

__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.ligand_docking.RandomConformerMover, resid: int) -> None
__init__(self: pyrosetta.rosetta.protocols.ligand_docking.RandomConformerMover, arg0: pyrosetta.rosetta.protocols.ligand_docking.RandomConformerMover) -> 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.ligand_docking.RandomConformerMover, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::ligand_docking::RandomConformerMover::apply(class core::pose::Pose &) –> void

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

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.moves.Mover) → pyrosetta.rosetta.protocols.moves.Mover¶

Return a clone of the Mover object.

C++: protocols::moves::Mover::clone() const –> class std::shared_ptr<class protocols::moves::Mover>

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>

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

Generates a new Mover object freshly created with the default ctor.

C++: protocols::moves::Mover::fresh_instance() const –> class std::shared_ptr<class protocols::moves::Mover>

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_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_name(self: pyrosetta.rosetta.protocols.ligand_docking.RandomConformerMover) → str¶: C++: protocols::ligand_docking::RandomConformerMover::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_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

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 > > &

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

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

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_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_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_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_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

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.ligand_docking.ResidueTorsionRestraints¶

Bases: pybind11_builtins.pybind11_object

Manages harmonic restraints on torsions, so they can be turned off for packing.

Restraints are created when object is created, so they start off enabled. I had to change from a PoseOP in the constructor to Pose references in enable/disable because Movers only get Pose references, not PoseOPs. Do not try to use one of these with multiple different poses, or surely the C++ gods will smite thee.

__delattr__¶: Implement delattr(self, name).

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

__eq__(self: pyrosetta.rosetta.protocols.ligand_docking.ResidueTorsionRestraints, other: pyrosetta.rosetta.protocols.ligand_docking.ResidueTorsionRestraints) → bool¶: C++: protocols::ligand_docking::ResidueTorsionRestraints::operator==(const class protocols::ligand_docking::ResidueTorsionRestraints &) –> bool

__format__()¶: default object formatter

__ge__¶: Return self>=value.

__getattribute__¶: Return getattr(self, name).

__gt__¶: Return self>value.

__hash__¶: Return hash(self).

__init__(self: pyrosetta.rosetta.protocols.ligand_docking.ResidueTorsionRestraints, pose: pyrosetta.rosetta.core.pose.Pose, resid: int, stddev_degrees: float) → 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).

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

disable(self: pyrosetta.rosetta.protocols.ligand_docking.ResidueTorsionRestraints, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Remove residue torsions constraints added by this object (if any).

C++: protocols::ligand_docking::ResidueTorsionRestraints::disable(class core::pose::Pose &) –> void

enable(self: pyrosetta.rosetta.protocols.ligand_docking.ResidueTorsionRestraints, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Constrain residue torsions for specified pose.

C++: protocols::ligand_docking::ResidueTorsionRestraints::enable(class core::pose::Pose &) –> void

class pyrosetta.rosetta.protocols.ligand_docking.RigidSearchMover¶

Bases: pyrosetta.rosetta.protocols.moves.Mover

An optimized mover for Monte Carlo trial of rigid body perturbations.

__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.ligand_docking.RigidSearchMover, jump_id: int, num_trials: int, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) -> None
__init__(self: pyrosetta.rosetta.protocols.ligand_docking.RigidSearchMover, arg0: pyrosetta.rosetta.protocols.ligand_docking.RigidSearchMover) -> 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.ligand_docking.RigidSearchMover, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::ligand_docking::RigidSearchMover::apply(class core::pose::Pose &) –> void

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

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.moves.Mover) → pyrosetta.rosetta.protocols.moves.Mover¶

Return a clone of the Mover object.

C++: protocols::moves::Mover::clone() const –> class std::shared_ptr<class protocols::moves::Mover>

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>

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

Generates a new Mover object freshly created with the default ctor.

C++: protocols::moves::Mover::fresh_instance() const –> class std::shared_ptr<class protocols::moves::Mover>

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_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_name(self: pyrosetta.rosetta.protocols.ligand_docking.RigidSearchMover) → str¶: C++: protocols::ligand_docking::RigidSearchMover::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_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

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 > > &

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

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

recover_low(*args, **kwargs)¶

Overloaded function.

recover_low(self: pyrosetta.rosetta.protocols.ligand_docking.RigidSearchMover) -> bool

Will the absolute lowest-energy pose be recovered at the end of apply()?

C++: protocols::ligand_docking::RigidSearchMover::recover_low() const –> bool

recover_low(self: pyrosetta.rosetta.protocols.ligand_docking.RigidSearchMover, b: bool) -> None

Should the absolute lowest-energy pose be recovered at the end of apply()?

C++: protocols::ligand_docking::RigidSearchMover::recover_low(bool) –> 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

rotate_around_atom(self: pyrosetta.rosetta.protocols.ligand_docking.RigidSearchMover, rsd: int, atom: int) → None¶

Rotation occurs around the specified atom

C++: protocols::ligand_docking::RigidSearchMover::rotate_around_atom(unsigned long, unsigned long) –> void

rotate_around_downstream_centroid(self: pyrosetta.rosetta.protocols.ligand_docking.RigidSearchMover) → None¶

Rotation occurs around centroid of downstream half of the jump (default)

C++: protocols::ligand_docking::RigidSearchMover::rotate_around_downstream_centroid() –> void

rotation(*args, **kwargs)¶

Overloaded function.

rotation(self: pyrosetta.rosetta.protocols.ligand_docking.RigidSearchMover) -> float

Amount of random (Gaussian) rotation, in degrees

C++: protocols::ligand_docking::RigidSearchMover::rotation() const –> double

rotation(self: pyrosetta.rosetta.protocols.ligand_docking.RigidSearchMover, degrees: float) -> None

Amount of random (Gaussian) rotation, in degrees

C++: protocols::ligand_docking::RigidSearchMover::rotation(double) –> 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_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_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_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

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

translation(*args, **kwargs)¶

Overloaded function.

translation(self: pyrosetta.rosetta.protocols.ligand_docking.RigidSearchMover) -> float

Amount of random (Gaussian) translation, in Angstroms

C++: protocols::ligand_docking::RigidSearchMover::translation() const –> double

translation(self: pyrosetta.rosetta.protocols.ligand_docking.RigidSearchMover, angstroms: float) -> None

Amount of random (Gaussian) translation, in Angstroms

C++: protocols::ligand_docking::RigidSearchMover::translation(double) –> 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.ligand_docking.UnconstrainedTorsionsMover¶

Bases: pyrosetta.rosetta.protocols.moves.Mover

Juggles torsional constraints with packing or rotamer trials.

Adds torsional constraints to the specified residue in the pose, but then removes them before running the supplied mover. They are then either restored (if no conformational change) or re-initialized. The supplied child_mover is expected to be either a full repack or rotamer trials.

__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.ligand_docking.UnconstrainedTorsionsMover, child_mover: pyrosetta.rosetta.protocols.moves.Mover, restraints: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_ligand_docking_ResidueTorsionRestraints_t) -> None
__init__(self: pyrosetta.rosetta.protocols.ligand_docking.UnconstrainedTorsionsMover, arg0: pyrosetta.rosetta.protocols.ligand_docking.UnconstrainedTorsionsMover) -> 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.ligand_docking.UnconstrainedTorsionsMover, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Removes its constraints, runs mover, restores constraints.

C++: protocols::ligand_docking::UnconstrainedTorsionsMover::apply(class core::pose::Pose &) –> void

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

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.moves.Mover) → pyrosetta.rosetta.protocols.moves.Mover¶

Return a clone of the Mover object.

C++: protocols::moves::Mover::clone() const –> class std::shared_ptr<class protocols::moves::Mover>

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>

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

Generates a new Mover object freshly created with the default ctor.

C++: protocols::moves::Mover::fresh_instance() const –> class std::shared_ptr<class protocols::moves::Mover>

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_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_name(self: pyrosetta.rosetta.protocols.ligand_docking.UnconstrainedTorsionsMover) → str¶: C++: protocols::ligand_docking::UnconstrainedTorsionsMover::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_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

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 > > &

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

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

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_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_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_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_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

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

pyrosetta.rosetta.protocols.ligand_docking.apply_rotate(mover: pyrosetta.rosetta.protocols.rigid.RigidBodyMover, pose: pyrosetta.rosetta.core.pose.Pose, center: pyrosetta.rosetta.numeric.xyzVector_double_t, jump_id: int, tag_along_chains: pyrosetta.rosetta.utility.vector1_unsigned_long) → None¶: C++: protocols::ligand_docking::apply_rotate(class std::shared_ptr<class protocols::rigid::RigidBodyMover>, class core::pose::Pose &, const class numeric::xyzVector<double> &, unsigned long, class utility::vector1<unsigned long, class std::allocator<unsigned long> >) –> void

pyrosetta.rosetta.protocols.ligand_docking.check_score(ligand: pyrosetta.rosetta.protocols.ligand_docking.Ligand_info, heavy_atom_number: int) → bool¶

Convenience Functions for use with Rotate

C++: protocols::ligand_docking::check_score(const struct protocols::ligand_docking::Ligand_info &, const unsigned long) –> bool

pyrosetta.rosetta.protocols.ligand_docking.constrain_ligand_torsions(*args, **kwargs)¶

Overloaded function.

constrain_ligand_torsions(pose: pyrosetta.rosetta.core.pose.Pose, stddev_degrees: float) -> None
constrain_ligand_torsions(pose: pyrosetta.rosetta.core.pose.Pose, stddev_degrees: float, constrain_all_torsions_equally: bool) -> None

Call get_ligand_torsion_constraints() for all non-polymer residues: and add the resulting constraints to the Pose.

C++: protocols::ligand_docking::constrain_ligand_torsions(class core::pose::Pose &, double, bool) –> void

pyrosetta.rosetta.protocols.ligand_docking.find_attach_pt(jump_id: int, interface: protocols::ligand_docking::ligand_options::Interface, pose: pyrosetta.rosetta.core.pose.Pose) → int¶: C++: protocols::ligand_docking::find_attach_pt(const unsigned long, const class protocols::ligand_docking::ligand_options::Interface &, const class core::pose::Pose &) –> unsigned long

pyrosetta.rosetta.protocols.ligand_docking.find_peptide_attach_pt(start: int, stop: int, jump_to_attach: pyrosetta.rosetta.std.map_unsigned_long_unsigned_long) → int¶: C++: protocols::ligand_docking::find_peptide_attach_pt(const int &, const int &, const class std::map<unsigned long, unsigned long, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, unsigned long> > > &) –> unsigned long

pyrosetta.rosetta.protocols.ligand_docking.find_unconnected_residues(pose: pyrosetta.rosetta.core.pose.Pose, start: int, end: int) → pyrosetta.rosetta.utility.vector1_unsigned_long¶: C++: protocols::ligand_docking::find_unconnected_residues(const class core::pose::Pose &, unsigned long, const unsigned long) –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

pyrosetta.rosetta.protocols.ligand_docking.frac_atoms_within(rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, cutoffs: pyrosetta.rosetta.utility.vector1_double, fractions_out: pyrosetta.rosetta.utility.vector1_double) → None¶

Without superimposing, automorphically computes the fraction of atoms: in these residues that are within the given cutoff(s) of each other.

C++: protocols::ligand_docking::frac_atoms_within(const class core::conformation::Residue &, const class core::conformation::Residue &, const class utility::vector1<double, class std::allocator<double> > &, class utility::vector1<double, class std::allocator<double> > &) –> void

pyrosetta.rosetta.protocols.ligand_docking.generate_unique_name(*args, **kwargs)¶

Overloaded function.

generate_unique_name() -> str
generate_unique_name(input_name: str) -> str

C++: protocols::ligand_docking::generate_unique_name(class std::basic_string<char>) –> std::string

pyrosetta.rosetta.protocols.ligand_docking.get_automorphic_RMSDs(*args, **kwargs)¶

Overloaded function.

get_automorphic_RMSDs(test_pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.Pose, test_residue_id: int, ref_residue_ids: pyrosetta.rosetta.utility.vector1_unsigned_long) -> pyrosetta.rosetta.std.map_std_string_double
get_automorphic_RMSDs(test_pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.Pose, test_residue_id: int, ref_residue_ids: pyrosetta.rosetta.utility.vector1_unsigned_long, prefix: str) -> pyrosetta.rosetta.std.map_std_string_double

C++: protocols::ligand_docking::get_automorphic_RMSDs(const class core::pose::Pose &, const class core::pose::Pose &, unsigned long, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class std::basic_string<char> &) –> class std::map<std::string, double, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, double> > >

pyrosetta.rosetta.protocols.ligand_docking.get_distribution(distribution_str: str) → pyrosetta.rosetta.protocols.ligand_docking.Distribution¶: C++: protocols::ligand_docking::get_distribution(class std::basic_string<char>) –> enum protocols::ligand_docking::Distribution

pyrosetta.rosetta.protocols.ligand_docking.get_incomplete_connections(residue: pyrosetta.rosetta.core.conformation.Residue) → pyrosetta.rosetta.utility.vector1_unsigned_long¶: C++: protocols::ligand_docking::get_incomplete_connections(class std::shared_ptr<const class core::conformation::Residue>) –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

pyrosetta.rosetta.protocols.ligand_docking.get_interface_deltas(*args, **kwargs)¶

Overloaded function.

get_interface_deltas(chain: str, after: pyrosetta.rosetta.core.pose.Pose, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) -> pyrosetta.rosetta.std.map_std_string_double
get_interface_deltas(chain: str, after: pyrosetta.rosetta.core.pose.Pose, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction, prefix: str) -> pyrosetta.rosetta.std.map_std_string_double
get_interface_deltas(chain: str, after: pyrosetta.rosetta.core.pose.Pose, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction, prefix: str, normalization_function: pyrosetta.rosetta.protocols.qsar.scoring_grid.ScoreNormalization) -> pyrosetta.rosetta.std.map_std_string_double

C++: protocols::ligand_docking::get_interface_deltas(char, const class core::pose::Pose &, const class std::shared_ptr<class core::scoring::ScoreFunction>, const class std::basic_string<char> &, class std::shared_ptr<class protocols::qsar::scoring_grid::ScoreNormalization>) –> class std::map<std::string, double, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, double> > >

pyrosetta.rosetta.protocols.ligand_docking.get_ligand_RMSDs(*args, **kwargs)¶

Overloaded function.

get_ligand_RMSDs(chain: str, test_pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.std.map_std_string_double
get_ligand_RMSDs(chain: str, test_pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.Pose, prefix: str) -> pyrosetta.rosetta.std.map_std_string_double
get_ligand_RMSDs(chain: str, test_pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.Pose, prefix: str, use_ensemble_best: bool) -> pyrosetta.rosetta.std.map_std_string_double

C++: protocols::ligand_docking::get_ligand_RMSDs(char, const class core::pose::Pose &, const class core::pose::Pose &, const class std::basic_string<char> &, bool) –> class std::map<std::string, double, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, double> > >

pyrosetta.rosetta.protocols.ligand_docking.get_ligand_grid_scores(*args, **kwargs)¶

Overloaded function.

get_ligand_grid_scores(grid_set_prototype: pyrosetta.rosetta.protocols.qsar.scoring_grid.GridSet, jump_id: int, test_pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.std.map_std_string_double
get_ligand_grid_scores(grid_set_prototype: pyrosetta.rosetta.protocols.qsar.scoring_grid.GridSet, jump_id: int, test_pose: pyrosetta.rosetta.core.pose.Pose, prefix: str) -> pyrosetta.rosetta.std.map_std_string_double
get_ligand_grid_scores(grid_set_prototype: pyrosetta.rosetta.protocols.qsar.scoring_grid.GridSet, jump_id: int, test_pose: pyrosetta.rosetta.core.pose.Pose, prefix: str, normalization_function: pyrosetta.rosetta.protocols.qsar.scoring_grid.ScoreNormalization) -> pyrosetta.rosetta.std.map_std_string_double

normalizaton_function will only be used if the Grids do not have their own normalization

C++: protocols::ligand_docking::get_ligand_grid_scores(const class protocols::qsar::scoring_grid::GridSet &, unsigned long, const class core::pose::Pose &, const class std::basic_string<char> &, class std::shared_ptr<class protocols::qsar::scoring_grid::ScoreNormalization>) –> class std::map<std::string, double, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, double> > >

get_ligand_grid_scores(grid_set_prototype: pyrosetta.rosetta.protocols.qsar.scoring_grid.GridSet, chain: str, test_pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.std.map_std_string_double
get_ligand_grid_scores(grid_set_prototype: pyrosetta.rosetta.protocols.qsar.scoring_grid.GridSet, chain: str, test_pose: pyrosetta.rosetta.core.pose.Pose, prefix: str) -> pyrosetta.rosetta.std.map_std_string_double
get_ligand_grid_scores(grid_set_prototype: pyrosetta.rosetta.protocols.qsar.scoring_grid.GridSet, chain: str, test_pose: pyrosetta.rosetta.core.pose.Pose, prefix: str, normalization_function: pyrosetta.rosetta.protocols.qsar.scoring_grid.ScoreNormalization) -> pyrosetta.rosetta.std.map_std_string_double

normalizaton_function will only be used if the Grids do not have their own normalization

C++: protocols::ligand_docking::get_ligand_grid_scores(const class protocols::qsar::scoring_grid::GridSet &, char, const class core::pose::Pose &, const class std::basic_string<char> &, class std::shared_ptr<class protocols::qsar::scoring_grid::ScoreNormalization>) –> class std::map<std::string, double, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, double> > >

get_ligand_grid_scores(grid_set_prototype: pyrosetta.rosetta.protocols.qsar.scoring_grid.GridSet, residues: pyrosetta.rosetta.utility.vector1_unsigned_long, chain_label: str, test_pose: pyrosetta.rosetta.core.pose.Pose, prefix: str, normalization_function: pyrosetta.rosetta.protocols.qsar.scoring_grid.ScoreNormalization) -> pyrosetta.rosetta.std.map_std_string_double

normalizaton_function will only be used if the Grids do not have their own normalization

C++: protocols::ligand_docking::get_ligand_grid_scores(const class protocols::qsar::scoring_grid::GridSet &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class std::basic_string<char> &, const class core::pose::Pose &, const class std::basic_string<char> &, class std::shared_ptr<class protocols::qsar::scoring_grid::ScoreNormalization>) –> class std::map<std::string, double, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, double> > >

pyrosetta.rosetta.protocols.ligand_docking.get_ligand_seqpos(pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.utility.vector1_unsigned_long¶

simple function to scan the pose for all ligand residues

C++: protocols::ligand_docking::get_ligand_seqpos(const class core::pose::Pose &) –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

pyrosetta.rosetta.protocols.ligand_docking.get_ligand_torsion_constraints(pose: pyrosetta.rosetta.core.pose.Pose, rsd_no: int, stddev_degrees: float, csts_out: pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_scoring_constraints_Constraint_t, constrain_all_torsions_equally: bool) → None¶

Produce dihedral restraints for all chi angles in the specified: residue, from chi_rotamers() if available, and from the rotamer library otherwise.

C++: protocols::ligand_docking::get_ligand_torsion_constraints(class core::pose::Pose &, unsigned long, double, class utility::vector1<class std::shared_ptr<class core::scoring::constraints::Constraint>, class std::allocator<class std::shared_ptr<class core::scoring::constraints::Constraint> > > &, const bool) –> void

pyrosetta.rosetta.protocols.ligand_docking.get_ligand_travel(*args, **kwargs)¶

Overloaded function.

get_ligand_travel(chain: str, test_pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.std.map_std_string_double
get_ligand_travel(chain: str, test_pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.Pose, prefix: str) -> pyrosetta.rosetta.std.map_std_string_double
get_ligand_travel(chain: str, test_pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.Pose, prefix: str, use_ensemble_best: bool) -> pyrosetta.rosetta.std.map_std_string_double

Another interesting metric – how far does the ligand centroid move?: Large values indicate we’re outside of the intended binding site.

C++: protocols::ligand_docking::get_ligand_travel(char, const class core::pose::Pose &, const class core::pose::Pose &, const class std::basic_string<char> &, bool) –> class std::map<std::string, double, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, double> > >

pyrosetta.rosetta.protocols.ligand_docking.get_ligand_travel_ensemble_best(test_pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.Pose, test_residue_id: int, ref_residue_ids: pyrosetta.rosetta.utility.vector1_unsigned_long) → float¶

Another interesting metric – how far does the ligand centroid move?: Returns the smallest distance from any of the residues in the reference structure.

C++: protocols::ligand_docking::get_ligand_travel_ensemble_best(const class core::pose::Pose &, const class core::pose::Pose &, unsigned long, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> double

pyrosetta.rosetta.protocols.ligand_docking.get_multi_residue_ligand_RMSDs(*args, **kwargs)¶

Overloaded function.

get_multi_residue_ligand_RMSDs(test_pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.Pose, test_residue_ids: pyrosetta.rosetta.utility.vector1_unsigned_long, ref_residue_ids: pyrosetta.rosetta.utility.vector1_unsigned_long) -> pyrosetta.rosetta.std.map_std_string_double
get_multi_residue_ligand_RMSDs(test_pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.Pose, test_residue_ids: pyrosetta.rosetta.utility.vector1_unsigned_long, ref_residue_ids: pyrosetta.rosetta.utility.vector1_unsigned_long, chain: str) -> pyrosetta.rosetta.std.map_std_string_double
get_multi_residue_ligand_RMSDs(test_pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.Pose, test_residue_ids: pyrosetta.rosetta.utility.vector1_unsigned_long, ref_residue_ids: pyrosetta.rosetta.utility.vector1_unsigned_long, chain: str, prefix: str) -> pyrosetta.rosetta.std.map_std_string_double

C++: protocols::ligand_docking::get_multi_residue_ligand_RMSDs(const class core::pose::Pose &, const class core::pose::Pose &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, char, const class std::basic_string<char> &) –> class std::map<std::string, double, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, double> > >

pyrosetta.rosetta.protocols.ligand_docking.get_radius_of_gyration(chain: str, test_pose: pyrosetta.rosetta.core.pose.Pose, prefix: str) → pyrosetta.rosetta.std.map_std_string_double¶

Calculate radius of gyration for downstream non-H atoms

Ligands tend to bind in outstretched conformations…

C++: protocols::ligand_docking::get_radius_of_gyration(char, const class core::pose::Pose &, const class std::basic_string<char> &) –> class std::map<std::string, double, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, double> > >

pyrosetta.rosetta.protocols.ligand_docking.get_rb_atr_and_rep_scores(grid: pyrosetta.rosetta.core.grid.CartGrid_int_t, pose: pyrosetta.rosetta.core.pose.Pose, begin: int, end: int) → Tuple[int, int]¶

a cleaner implementation of rb_grid_score_atr_rep

C++: protocols::ligand_docking::get_rb_atr_and_rep_scores(const class core::grid::CartGrid<int> &, const class core::pose::Pose &, unsigned long, unsigned long) –> struct std::pair<int, int>

pyrosetta.rosetta.protocols.ligand_docking.grid_rotamer_trials(*args, **kwargs)¶

Overloaded function.

grid_rotamer_trials(grid: pyrosetta.rosetta.core.grid.CartGrid_int_t, pose: pyrosetta.rosetta.core.pose.Pose, rsd_no: int) -> None
grid_rotamer_trials(grid: pyrosetta.rosetta.core.grid.CartGrid_int_t, pose: pyrosetta.rosetta.core.pose.Pose, rsd_no: int, min_score: int) -> None

Try all rotamers for the specified residue and install the first one: that minimizes the grid score. Only tested with ligand residues w/ a conformer library.

C++: protocols::ligand_docking::grid_rotamer_trials(const class core::grid::CartGrid<int> &, class core::pose::Pose &, unsigned long, const int) –> void

pyrosetta.rosetta.protocols.ligand_docking.grid_rotamer_trials_atr_rep(grid: pyrosetta.rosetta.core.grid.CartGrid_int_t, pose: pyrosetta.rosetta.core.pose.Pose, rsd_no: int) → None¶

Try all rotamers for the specified residue and install the first one: that minimizes the repulsive score, breaking ties by the attractive score. Only tested with ligand residues w/ a conformer library.

C++: protocols::ligand_docking::grid_rotamer_trials_atr_rep(const class core::grid::CartGrid<int> &, class core::pose::Pose &, unsigned long) –> void

pyrosetta.rosetta.protocols.ligand_docking.grid_score(*args, **kwargs)¶

Overloaded function.

grid_score(grid: pyrosetta.rosetta.core.grid.CartGrid_int_t, rsd: pyrosetta.rosetta.core.conformation.Residue) -> int
grid_score(grid: pyrosetta.rosetta.core.grid.CartGrid_int_t, rsd: pyrosetta.rosetta.core.conformation.Residue, max_score: int) -> int

Sum the grid values for all heavy atoms in the residue

C++: protocols::ligand_docking::grid_score(const class core::grid::CartGrid<int> &, const class core::conformation::Residue &, int) –> int

pyrosetta.rosetta.protocols.ligand_docking.grid_score_atr_rep(*args, **kwargs)¶

Overloaded function.

grid_score_atr_rep(grid: pyrosetta.rosetta.core.grid.CartGrid_int_t, rsd: pyrosetta.rosetta.core.conformation.Residue, atr_out: int, rep_out: int) -> None
grid_score_atr_rep(grid: pyrosetta.rosetta.core.grid.CartGrid_int_t, rsd: pyrosetta.rosetta.core.conformation.Residue, atr_out: int, rep_out: int, max_rep: int) -> None

Sum the grid values for all heavy atoms in the residue

C++: protocols::ligand_docking::grid_score_atr_rep(const class core::grid::CartGrid<int> &, const class core::conformation::Residue &, int &, int &, int) –> void

pyrosetta.rosetta.protocols.ligand_docking.grow(: pyrosetta.rosetta.core.pose.Pose, start: int, end: int) → bool¶: C++: protocols::ligand_docking::grow(class core::pose::Pose, unsigned long, unsigned long) –> bool

pyrosetta.rosetta.protocols.ligand_docking.has_incomplete_connections(pose: pyrosetta.rosetta.core.pose.Pose, start: int, end: int) → bool¶: C++: protocols::ligand_docking::has_incomplete_connections(class core::pose::Pose, unsigned long, const unsigned long) –> bool

pyrosetta.rosetta.protocols.ligand_docking.make_atr_rep_grid(pose: pyrosetta.rosetta.core.pose.Pose, center: pyrosetta.rosetta.numeric.xyzVector_double_t) → pyrosetta.rosetta.core.grid.CartGrid_int_t¶

Make a grid around the specified point with attractive (negative): and repulsive (positive) values for the protein backbone.

C++: protocols::ligand_docking::make_atr_rep_grid(const class core::pose::Pose &, const class numeric::xyzVector<double> &) –> class std::shared_ptr<class core::grid::CartGrid<int> >

pyrosetta.rosetta.protocols.ligand_docking.make_atr_rep_grid_without_ligand(pose: pyrosetta.rosetta.core.pose.Pose, center: pyrosetta.rosetta.numeric.xyzVector_double_t, ligand_chain_id_to_exclude: int) → pyrosetta.rosetta.core.grid.CartGrid_int_t¶

Make a grid around the specified point with attractive (negative): and repulsive (positive) values for all heavy atoms not in ligand_chain_id_to_exclude

C++: protocols::ligand_docking::make_atr_rep_grid_without_ligand(const class core::pose::Pose &, const class numeric::xyzVector<double> &, const unsigned long &) –> class std::shared_ptr<class core::grid::CartGrid<int> >

pyrosetta.rosetta.protocols.ligand_docking.make_atr_rep_grid_without_ligands(pose: pyrosetta.rosetta.core.pose.Pose, center: pyrosetta.rosetta.numeric.xyzVector_double_t, ligand_chain_ids_to_exclude: pyrosetta.rosetta.utility.vector1_unsigned_long) → pyrosetta.rosetta.core.grid.CartGrid_int_t¶

Make a grid around the specified point with attractive (negative): and repulsive (positive) values for all heavy atoms not in ligand_chain_ids_to_exclude

C++: protocols::ligand_docking::make_atr_rep_grid_without_ligands(const class core::pose::Pose &, const class numeric::xyzVector<double> &, class utility::vector1<unsigned long, class std::allocator<unsigned long> >) –> class std::shared_ptr<class core::grid::CartGrid<int> >

pyrosetta.rosetta.protocols.ligand_docking.move_ligand_neighbor_to_desired_position(*args, **kwargs)¶

Overloaded function.

move_ligand_neighbor_to_desired_position(chains: pyrosetta.rosetta.utility.vector1_std_string, desired_position: pyrosetta.rosetta.numeric.xyzVector_double_t, pose: pyrosetta.rosetta.core.pose.Pose) -> None

Move the neighbor atom of the specified multiple chains to the desired_position

C++: protocols::ligand_docking::move_ligand_neighbor_to_desired_position(const class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &, const class numeric::xyzVector<double> &, class core::pose::Pose &) –> void

move_ligand_neighbor_to_desired_position(chain: str, desired_position: pyrosetta.rosetta.numeric.xyzVector_double_t, pose: pyrosetta.rosetta.core.pose.Pose) -> None

Move the neighbor atom of the specified chain to the desired_position

C++: protocols::ligand_docking::move_ligand_neighbor_to_desired_position(const class std::basic_string<char> &, const class numeric::xyzVector<double> &, class core::pose::Pose &) –> void

pyrosetta.rosetta.protocols.ligand_docking.move_ligand_to_desired_centroid(*args, **kwargs)¶

Overloaded function.

move_ligand_to_desired_centroid(chain: str, desired_centroid: pyrosetta.rosetta.numeric.xyzVector_double_t, pose: pyrosetta.rosetta.core.pose.Pose) -> None

Move the center of specified chain to the desired_centroid

C++: protocols::ligand_docking::move_ligand_to_desired_centroid(const class std::basic_string<char> &, const class numeric::xyzVector<double> &, class core::pose::Pose &) –> void

move_ligand_to_desired_centroid(chains: pyrosetta.rosetta.utility.vector1_std_string, desired_centroid: pyrosetta.rosetta.numeric.xyzVector_double_t, pose: pyrosetta.rosetta.core.pose.Pose) -> None

Move the center of specified multiple chains to the desired_centroid

C++: protocols::ligand_docking::move_ligand_to_desired_centroid(const class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &, const class numeric::xyzVector<double> &, class core::pose::Pose &) –> void

move_ligand_to_desired_centroid(jump_id: int, desired_centroid: pyrosetta.rosetta.numeric.xyzVector_double_t, pose: pyrosetta.rosetta.core.pose.Pose) -> None

Move the center of the object(s) downstream of jump_id to the desired_centroid

C++: protocols::ligand_docking::move_ligand_to_desired_centroid(const unsigned long, const class numeric::xyzVector<double> &, class core::pose::Pose &) –> void

pyrosetta.rosetta.protocols.ligand_docking.passes_filters(pose: pyrosetta.rosetta.core.pose.Pose, start: int, end: int) → bool¶: C++: protocols::ligand_docking::passes_filters(const class core::pose::Pose &, unsigned long, const unsigned long) –> bool

pyrosetta.rosetta.protocols.ligand_docking.random_connection(residue: pyrosetta.rosetta.core.conformation.Residue) → int¶: C++: protocols::ligand_docking::random_connection(class std::shared_ptr<const class core::conformation::Residue>) –> unsigned long

pyrosetta.rosetta.protocols.ligand_docking.rb_grid_rotamer_trials_atr_rep(grid: pyrosetta.rosetta.core.grid.CartGrid_int_t, pose: pyrosetta.rosetta.core.pose.Pose, begin: int, end: int) → None¶: C++: protocols::ligand_docking::rb_grid_rotamer_trials_atr_rep(const class core::grid::CartGrid<int> &, class core::pose::Pose &, unsigned long, unsigned long) –> void

pyrosetta.rosetta.protocols.ligand_docking.rb_grid_score_atr_rep(*args, **kwargs)¶

Overloaded function.

rb_grid_score_atr_rep(grid: pyrosetta.rosetta.core.grid.CartGrid_int_t, pose: pyrosetta.rosetta.core.pose.Pose, begin: int, end: int, atr_out: int, rep_out: int) -> None
rb_grid_score_atr_rep(grid: pyrosetta.rosetta.core.grid.CartGrid_int_t, pose: pyrosetta.rosetta.core.pose.Pose, begin: int, end: int, atr_out: int, rep_out: int, max_rep: int) -> None

Sum the grid values for all heavy atoms in the residue

C++: protocols::ligand_docking::rb_grid_score_atr_rep(const class core::grid::CartGrid<int> &, const class core::pose::Pose &, unsigned long, const unsigned long, int &, int &, int) –> void

pyrosetta.rosetta.protocols.ligand_docking.reorder_with_first_non_mobile_as_root(f: pyrosetta.rosetta.core.kinematics.FoldTree, interface: protocols::ligand_docking::ligand_options::Interface, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::ligand_docking::reorder_with_first_non_mobile_as_root(class std::shared_ptr<class core::kinematics::FoldTree>, const class protocols::ligand_docking::ligand_options::Interface &, class core::pose::Pose &) –> void

pyrosetta.rosetta.protocols.ligand_docking.restrain_ligand_nbr_atom(lig_id: int, stddev_Angstroms: float, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶: C++: protocols::ligand_docking::restrain_ligand_nbr_atom(const unsigned long, const double, class core::pose::Pose &) –> class std::shared_ptr<const class core::scoring::constraints::Constraint>

pyrosetta.rosetta.protocols.ligand_docking.restrict_to_protein_residues(interface: protocols::ligand_docking::ligand_options::Interface, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::ligand_docking::restrict_to_protein_residues(class protocols::ligand_docking::ligand_options::Interface &, const class core::pose::Pose &) –> void

pyrosetta.rosetta.protocols.ligand_docking.rotamers_for_trials(pose: pyrosetta.rosetta.core.pose.Pose, rsd_no: int, conformers_out: pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_conformation_Residue_t) → None¶

Internal helper function for rotamer trials; fills conformers_out.

C++: protocols::ligand_docking::rotamers_for_trials(class core::pose::Pose &, unsigned long, class utility::vector1<class std::shared_ptr<class core::conformation::Residue>, class std::allocator<class std::shared_ptr<class core::conformation::Residue> > > &) –> void

pyrosetta.rosetta.protocols.ligand_docking.select_best_poses(*args, **kwargs)¶

Overloaded function.

select_best_poses(atdiff: pyrosetta.rosetta.core.import_pose.atom_tree_diffs.AtomTreeDiff, tags_out: pyrosetta.rosetta.std.set_std_string_std_less_std_string_std_allocator_std_string_t) -> None

Convenience wrapper: selects the best ligand docking results: from a silent file and appends their tags to the supplied set.

C++: protocols::ligand_docking::select_best_poses(const class core::import_pose::atom_tree_diffs::AtomTreeDiff &, class std::set<class std::basic_string<char>, struct std::less<class std::basic_string<char> >, class std::allocator<class std::basic_string<char> > > &) –> void

select_best_poses(atdiff: pyrosetta.rosetta.core.import_pose.atom_tree_diffs.AtomTreeDiff, scores_out: pyrosetta.rosetta.utility.vector1_std_pair_std_string_std_map_std_string_double_std_less_std_string_std_allocator_std_pair_const_std_string_double_t) -> None
select_best_poses(atdiff: pyrosetta.rosetta.core.import_pose.atom_tree_diffs.AtomTreeDiff, scores_out: pyrosetta.rosetta.utility.vector1_std_pair_std_string_std_map_std_string_double_std_less_std_string_std_allocator_std_pair_const_std_string_double_t, to_keep: float) -> None

Selects the best ligand docking results from a silent file: and appends their scores to the supplied list.

C++: protocols::ligand_docking::select_best_poses(const class core::import_pose::atom_tree_diffs::AtomTreeDiff &, class utility::vector1<struct std::pair<class std::basic_string<char>, class std::map<class std::basic_string<char>, double, struct std::less<class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, double> > > >, class std::allocator<struct std::pair<class std::basic_string<char>, class std::map<class std::basic_string<char>, double, struct std::less<class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, double> > > > > > &, double) –> void

select_best_poses(scores_in: pyrosetta.rosetta.utility.vector1_std_pair_std_string_std_map_std_string_double_std_less_std_string_std_allocator_std_pair_const_std_string_double_t, scores_out: pyrosetta.rosetta.utility.vector1_std_pair_std_string_std_map_std_string_double_std_less_std_string_std_allocator_std_pair_const_std_string_double_t) -> None
select_best_poses(scores_in: pyrosetta.rosetta.utility.vector1_std_pair_std_string_std_map_std_string_double_std_less_std_string_std_allocator_std_pair_const_std_string_double_t, scores_out: pyrosetta.rosetta.utility.vector1_std_pair_std_string_std_map_std_string_double_std_less_std_string_std_allocator_std_pair_const_std_string_double_t, to_keep: float) -> None

Trims scores_in based on ligand_is_touching (if present) and: then by total_score.

C++: protocols::ligand_docking::select_best_poses(const class utility::vector1<struct std::pair<class std::basic_string<char>, class std::map<class std::basic_string<char>, double, struct std::less<class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, double> > > >, class std::allocator<struct std::pair<class std::basic_string<char>, class std::map<class std::basic_string<char>, double, struct std::less<class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, double> > > > > > &, class utility::vector1<struct std::pair<class std::basic_string<char>, class std::map<class std::basic_string<char>, double, struct std::less<class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, double> > > >, class std::allocator<struct std::pair<class std::basic_string<char>, class std::map<class std::basic_string<char>, double, struct std::less<class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, double> > > > > > &, double) –> void

pyrosetta.rosetta.protocols.ligand_docking.sort_by_second(left_lig: Tuple[int, float], right_lig: Tuple[int, float]) → bool¶: C++: protocols::ligand_docking::sort_by_second(struct std::pair<unsigned long, double>, struct std::pair<unsigned long, double>) –> bool

pyrosetta.rosetta.protocols.ligand_docking.spearman(vector_exp: pyrosetta.rosetta.utility.vector1_std_pair_unsigned_long_double_t, vector_rosetta: pyrosetta.rosetta.utility.vector1_std_pair_unsigned_long_double_t) → float¶: C++: protocols::ligand_docking::spearman(class utility::vector1<struct std::pair<unsigned long, double>, class std::allocator<struct std::pair<unsigned long, double> > >, class utility::vector1<struct std::pair<unsigned long, double>, class std::allocator<struct std::pair<unsigned long, double> > >) –> double

pyrosetta.rosetta.protocols.ligand_docking.torsion_constraints_from_chi_rotamers(rsd_no: int, chino: int, rsdtype: pyrosetta.rosetta.core.chemical.ResidueType) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶

Produce an ambiguous dihedral restraint for the specified chi angle,: assuming that ResidueType.chi_rotamers() lists (all) energetic minima.

C++: protocols::ligand_docking::torsion_constraints_from_chi_rotamers(unsigned long, unsigned long, const class core::chemical::ResidueType &) –> class std::shared_ptr<class core::scoring::constraints::Constraint>

pyrosetta.rosetta.protocols.ligand_docking.torsion_constraints_from_rotamers(rsd_no: int, chino: int, rsds: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_conformation_Residue_t, stddev_degrees: float) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶

Produce an ambiguous dihedral restraint for the specified chi angle,: assuming that the provided conformations represent (all) energetic minima.

C++: protocols::ligand_docking::torsion_constraints_from_rotamers(unsigned long, unsigned long, const class utility::vector1<class std::shared_ptr<const class core::conformation::Residue>, class std::allocator<class std::shared_ptr<const class core::conformation::Residue> > > &, double) –> class std::shared_ptr<class core::scoring::constraints::Constraint>

pyrosetta.rosetta.protocols.ligand_docking.vector_to_rank(vector: pyrosetta.rosetta.utility.vector1_std_pair_unsigned_long_double_t) → None¶: C++: protocols::ligand_docking::vector_to_rank(class utility::vector1<struct std::pair<unsigned long, double>, class std::allocator<struct std::pair<unsigned long, double> > > &) –> void