anchored_design

Bindings for protocols::anchored_design namespace

class pyrosetta.rosetta.protocols.anchored_design.Anchor

Bases: pybind11_builtins.pybind11_object

Anchor class provides for the “anchor” part of a scaffold in anchored interface design

Anchor class implements the code to read in an anchor file, stores the definition of the anchor, and provides access methods for setting move maps. It reads in PDB-keyed information, but converts it to pose resid information and internally stores only the latter.

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

1. __init__(self: pyrosetta.rosetta.protocols.anchored_design.Anchor) -> None
2. __init__(self: pyrosetta.rosetta.protocols.anchored_design.Anchor, start: int, end: int) -> None
3. __init__(self: pyrosetta.rosetta.protocols.anchored_design.Anchor, pose: pyrosetta.rosetta.core.pose.Pose, filename: str) -> None
4. __init__(self: pyrosetta.rosetta.protocols.anchored_design.Anchor, pose: pyrosetta.rosetta.core.pose.Pose) -> None
5. __init__(self: pyrosetta.rosetta.protocols.anchored_design.Anchor, arg0: pyrosetta.rosetta.protocols.anchored_design.Anchor) -> 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.anchored_design.Anchor, rhs: pyrosetta.rosetta.protocols.anchored_design.Anchor) → pyrosetta.rosetta.protocols.anchored_design.Anchor

assignment operator

C++: protocols::anchored_design::Anchor::operator=(const class protocols::anchored_design::Anchor &) –> class protocols::anchored_design::Anchor &

end(self: pyrosetta.rosetta.protocols.anchored_design.Anchor) → int

returns end of anchor (as pose resid)

C++: protocols::anchored_design::Anchor::end() const –> unsigned long

get_filename(self: pyrosetta.rosetta.protocols.anchored_design.Anchor) → str

getter for filename for anchorfile

C++: protocols::anchored_design::Anchor::get_filename() const –> const std::string &

read_anchorfile(*args, **kwargs)

Overloaded function.

1. read_anchorfile(self: pyrosetta.rosetta.protocols.anchored_design.Anchor, pose: pyrosetta.rosetta.core.pose.Pose, filename: str) -> None

method to read an anchor file. Pose is necessary to reference against

C++: protocols::anchored_design::Anchor::read_anchorfile(const class core::pose::Pose &, const class std::basic_string<char> &) –> void

2. read_anchorfile(self: pyrosetta.rosetta.protocols.anchored_design.Anchor, pose: pyrosetta.rosetta.core.pose.Pose) -> None

method to read an anchor file. Pose is necessary to reference against. Checks internal data for filename.

C++: protocols::anchored_design::Anchor::read_anchorfile(const class core::pose::Pose &) –> void

read_options(self: pyrosetta.rosetta.protocols.anchored_design.Anchor) → None

read option system into internal data

C++: protocols::anchored_design::Anchor::read_options() –> void

set_filename(self: pyrosetta.rosetta.protocols.anchored_design.Anchor, filename: str) → None

setter for filename for anchorfile

C++: protocols::anchored_design::Anchor::set_filename(const class std::basic_string<char> &) –> void

start(self: pyrosetta.rosetta.protocols.anchored_design.Anchor) → int

returns start of anchor (as pose resid)

C++: protocols::anchored_design::Anchor::start() const –> unsigned long

class pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData

Bases: pybind11_builtins.pybind11_object

This data class wraps all the data needed for the AnchoredDesign movers.

This data class keeps the anchor, mobile loops, and movemaps associated with the loops all together.

It generates its own movemaps.

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

1. __init__(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData) -> None
2. __init__(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData, arg0: pyrosetta.rosetta.protocols.anchored_design.Anchor, arg1: pyrosetta.rosetta.protocols.loops.Loops) -> None

doc

3. __init__(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData, anchor: pyrosetta.rosetta.protocols.anchored_design.Anchor, loops: pyrosetta.rosetta.protocols.loops.Loops, options: bool) -> None
4. __init__(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData, pose: pyrosetta.rosetta.core.pose.Pose) -> None
5. __init__(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData, arg0: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData) -> 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).

anchor_end(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData) → int

access for anchor end

C++: protocols::anchored_design::AnchorMoversData::anchor_end() const –> unsigned long

anchor_noise_constraints_setup(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData, pose: pyrosetta.rosetta.core.pose.Pose) → None

set up constraints for anchor_noise_constraints_mode

C++: protocols::anchored_design::AnchorMoversData::anchor_noise_constraints_setup(class core::pose::Pose &) –> void

anchor_start(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData) → int

//////////////////////////anchor functions//////////////////////////////////////////////

access for anchor start

C++: protocols::anchored_design::AnchorMoversData::anchor_start() const –> unsigned long

anchored_loop(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData) → pyrosetta.rosetta.protocols.loops.Loop

//////////////loops and movemap functions//////////////////////////////////////////////

access anchored loop

C++: protocols::anchored_design::AnchorMoversData::anchored_loop() const –> const class protocols::loops::Loop &

assign(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData, rhs: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData) → pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData

assignment operator

C++: protocols::anchored_design::AnchorMoversData::operator=(const class protocols::anchored_design::AnchorMoversData &) –> class protocols::anchored_design::AnchorMoversData &

autogenerate_constseq_frags(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData, seq: str) → pyrosetta.rosetta.core.fragment.FragSet

brew its own sequence-specific frags

C++: protocols::anchored_design::AnchorMoversData::autogenerate_constseq_frags(const class std::basic_string<char> &) –> class std::shared_ptr<const class core::fragment::FragSet>

autogenerate_design_frags(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData) → pyrosetta.rosetta.core.fragment.FragSet

brew its own design frags (LLLLL secondary structure)

C++: protocols::anchored_design::AnchorMoversData::autogenerate_design_frags() –> class std::shared_ptr<const class core::fragment::FragSet>

autogenerate_frags(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData, pose: pyrosetta.rosetta.core.pose.Pose) → None

figure out what type of fragments to use, and use them; pose needed to make packertask to detect if design is occuring

C++: protocols::anchored_design::AnchorMoversData::autogenerate_frags(const class core::pose::Pose &) –> void

clone(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData) → pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData

C++: protocols::anchored_design::AnchorMoversData::clone() const –> class std::shared_ptr<class protocols::anchored_design::AnchorMoversData>

get_VDW_weight(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData) → float

VDW weight in centroid scorefunction

C++: protocols::anchored_design::AnchorMoversData::get_VDW_weight() const –> double

get_akash_dyepos(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData) → int

dye position used in dye modeling publication

C++: protocols::anchored_design::AnchorMoversData::get_akash_dyepos() const –> unsigned long

get_allow_anchor_repack(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData) → bool

allow anchor to repack

C++: protocols::anchored_design::AnchorMoversData::get_allow_anchor_repack() const –> bool

get_anchor_noise_constraints_mode(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData) → bool

special anchor_noise_constraints_mode

C++: protocols::anchored_design::AnchorMoversData::get_anchor_noise_constraints_mode() const –> bool

get_anchor_via_constraints(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData) → bool

used to test anchoring via constraints

C++: protocols::anchored_design::AnchorMoversData::get_anchor_via_constraints() const –> bool

get_centroid_scorefunction(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData) → pyrosetta.rosetta.core.scoring.ScoreFunction

access centroid scorefunction

C++: protocols::anchored_design::AnchorMoversData::get_centroid_scorefunction() const –> class std::shared_ptr<class core::scoring::ScoreFunction>

get_centroid_scorefunction_min(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData) → pyrosetta.rosetta.core.scoring.ScoreFunction

access centroid scorefunction for minimization

C++: protocols::anchored_design::AnchorMoversData::get_centroid_scorefunction_min() const –> class std::shared_ptr<class core::scoring::ScoreFunction>

get_chainbreak_weight(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData) → float

chainbreak weight in fullatom scorefunction

C++: protocols::anchored_design::AnchorMoversData::get_chainbreak_weight() const –> double

get_frag3(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData) → str

copy of cmdline option frag3

C++: protocols::anchored_design::AnchorMoversData::get_frag3() const –> const std::string &

get_frags(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData) → pyrosetta.rosetta.core.fragment.FragSet

/////////////////////scfxn, packertask, fragments accessors//////////////////////////////

access fragments object

C++: protocols::anchored_design::AnchorMoversData::get_frags() const –> class std::shared_ptr<const class core::fragment::FragSet>

get_fullatom_scorefunction(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData) → pyrosetta.rosetta.core.scoring.ScoreFunction

access fullatom scorefunction

C++: protocols::anchored_design::AnchorMoversData::get_fullatom_scorefunction() const –> class std::shared_ptr<class core::scoring::ScoreFunction>

get_late_factory(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData) → pyrosetta.rosetta.core.pack.task.TaskFactory

access packertask factory

C++: protocols::anchored_design::AnchorMoversData::get_late_factory() const –> class std::shared_ptr<const class core::pack::task::TaskFactory>

get_loop_file(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData) → str

copy of cmdline option loop_file

C++: protocols::anchored_design::AnchorMoversData::get_loop_file() const –> const std::string &

get_no_frags(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData) → bool

do not use fragments?

C++: protocols::anchored_design::AnchorMoversData::get_no_frags() const –> bool

get_resfile_1(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData) → str

resfile for design

C++: protocols::anchored_design::AnchorMoversData::get_resfile_1() const –> const std::string &

get_resfile_2(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData) → str

later-stage resfile if desired

C++: protocols::anchored_design::AnchorMoversData::get_resfile_2() const –> const std::string &

get_super_secret_fixed_interface_mode(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData) → bool

special super_secret_fixed_interface_mode

C++: protocols::anchored_design::AnchorMoversData::get_super_secret_fixed_interface_mode() const –> bool

get_task(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.pack.task.PackerTask

return packertask from factory

C++: protocols::anchored_design::AnchorMoversData::get_task(const class core::pose::Pose &) const –> class std::shared_ptr<class core::pack::task::PackerTask>

get_task_factory(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData) → pyrosetta.rosetta.core.pack.task.TaskFactory

access packertask factory

C++: protocols::anchored_design::AnchorMoversData::get_task_factory() const –> class std::shared_ptr<const class core::pack::task::TaskFactory>

get_unbound_mode(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData) → bool

used for unbound mode

C++: protocols::anchored_design::AnchorMoversData::get_unbound_mode() const –> bool

interface_calc(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData) → str

get string name for interface_calc_

C++: protocols::anchored_design::AnchorMoversData::interface_calc() const –> const std::string &

loop(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData, i: int) → pyrosetta.rosetta.protocols.loops.Loop

accessor for a loop

C++: protocols::anchored_design::AnchorMoversData::loop(unsigned long) const –> const class protocols::loops::Loop &

loops(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData) → pyrosetta.rosetta.protocols.loops.Loops

accessor for loops object

C++: protocols::anchored_design::AnchorMoversData::loops() const –> const class protocols::loops::Loops &

movemap_cen(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData, i: int) → pyrosetta.rosetta.core.kinematics.MoveMap

accessor for omega-variable movemap (most movers); centroid phase (no anchor movement)

C++: protocols::anchored_design::AnchorMoversData::movemap_cen(unsigned long) const –> class std::shared_ptr<class core::kinematics::MoveMap>

movemap_cen_all(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData) → pyrosetta.rosetta.core.kinematics.MoveMap

access for movemap that covers all loops; centroid

C++: protocols::anchored_design::AnchorMoversData::movemap_cen_all() const –> class std::shared_ptr<class core::kinematics::MoveMap>

movemap_cen_omegafixed(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData, i: int) → pyrosetta.rosetta.core.kinematics.MoveMap

accessor for omega-fixed movemap (appropriate for CCD movers); centroid phase

C++: protocols::anchored_design::AnchorMoversData::movemap_cen_omegafixed(unsigned long) const –> class std::shared_ptr<class core::kinematics::MoveMap>

movemap_fa(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData, i: int) → pyrosetta.rosetta.core.kinematics.MoveMap

accessor for omega-variable movemap (most movers); fullatom phase (may allow anchor movement w/constraints)

C++: protocols::anchored_design::AnchorMoversData::movemap_fa(unsigned long) const –> class std::shared_ptr<class core::kinematics::MoveMap>

movemap_fa_all(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData) → pyrosetta.rosetta.core.kinematics.MoveMap

access for movemap that covers all loops; fullatom

C++: protocols::anchored_design::AnchorMoversData::movemap_fa_all() const –> class std::shared_ptr<class core::kinematics::MoveMap>

movemap_fa_omegafixed(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData, i: int) → pyrosetta.rosetta.core.kinematics.MoveMap

accessor for omega-fixed movemap (appropriate for CCD movers); fullatom phase (may allow anchor movement w/constraints)

C++: protocols::anchored_design::AnchorMoversData::movemap_fa_omegafixed(unsigned long) const –> class std::shared_ptr<class core::kinematics::MoveMap>

neighborhood_calc(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData) → str

get string name for neighborhood_calc_

C++: protocols::anchored_design::AnchorMoversData::neighborhood_calc() const –> const std::string &

num_loops(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData) → int

number of loops/mms

C++: protocols::anchored_design::AnchorMoversData::num_loops() const –> unsigned long

pick_new_cutpoints(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData, reset_always: bool) → None

randomly reset loop cutpoints. Useful only when starting structure is well-closed. Best for MPI-style runs

C++: protocols::anchored_design::AnchorMoversData::pick_new_cutpoints(bool) –> void

read_options(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData) → None

read options from the option system

C++: protocols::anchored_design::AnchorMoversData::read_options() –> void

set_VDW_weight(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData, VDW_weight: float) → None

VDW weight in centroid scorefunction

C++: protocols::anchored_design::AnchorMoversData::set_VDW_weight(double) –> void

set_akash_dyepos(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData, akash_dyepos: int) → None

/////////////option system replacement/////////////////////////////

dye position used in dye modeling publication

C++: protocols::anchored_design::AnchorMoversData::set_akash_dyepos(const unsigned long) –> void

set_allow_anchor_repack(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData, allow_anchor_repack: bool) → None

allow anchor to repack

C++: protocols::anchored_design::AnchorMoversData::set_allow_anchor_repack(bool) –> void

set_anchor_noise_constraints_mode(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData, anchor_noise_constraints_mode: bool) → None

special anchor_noise_constraints_mode

C++: protocols::anchored_design::AnchorMoversData::set_anchor_noise_constraints_mode(bool) –> void

set_anchor_via_constraints(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData, anchor_via_constraints: bool) → None

used to test anchoring via constraints

C++: protocols::anchored_design::AnchorMoversData::set_anchor_via_constraints(bool) –> void

set_centroid_scorefunction(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData, : pyrosetta.rosetta.core.scoring.ScoreFunction) → None

set centroid scorefunction

C++: protocols::anchored_design::AnchorMoversData::set_centroid_scorefunction(class std::shared_ptr<class core::scoring::ScoreFunction>) –> void

set_chainbreak_weight(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData, chainbreak_weight: float) → None

chainbreak weight in fullatom scorefunction

C++: protocols::anchored_design::AnchorMoversData::set_chainbreak_weight(double) –> void

set_frag3(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData, frag3: str) → None

copy of cmdline option frag3

C++: protocols::anchored_design::AnchorMoversData::set_frag3(const class std::basic_string<char> &) –> void

set_frags(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData, : pyrosetta.rosetta.core.fragment.FragSet) → None

////////////////set functions/////////////////////////////////////////////////////////

set fragments object

C++: protocols::anchored_design::AnchorMoversData::set_frags(class std::shared_ptr<class core::fragment::FragSet>) –> void

set_fullatom_scorefunction(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData, : pyrosetta.rosetta.core.scoring.ScoreFunction) → None

set fullatom scorefunction

C++: protocols::anchored_design::AnchorMoversData::set_fullatom_scorefunction(class std::shared_ptr<class core::scoring::ScoreFunction>) –> void

set_loops_and_anchor(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData, anchor: pyrosetta.rosetta.protocols.anchored_design.Anchor, loops: pyrosetta.rosetta.protocols.loops.Loops) → None

set up kinematics’ loops and anchors

C++: protocols::anchored_design::AnchorMoversData::set_loops_and_anchor(class std::shared_ptr<const class protocols::anchored_design::Anchor>, class protocols::loops::Loops) –> void

set_no_frags(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData, no_frags: bool) → None

do not use fragments?

C++: protocols::anchored_design::AnchorMoversData::set_no_frags(bool) –> void

set_resfile_1(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData, resfile_1: str) → None

resfile for design

C++: protocols::anchored_design::AnchorMoversData::set_resfile_1(const class std::basic_string<char> &) –> void

set_resfile_2(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData, resfile_2: str) → None

later-stage resfile if desired

C++: protocols::anchored_design::AnchorMoversData::set_resfile_2(const class std::basic_string<char> &) –> void

set_super_secret_fixed_interface_mode(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData, super_secret_fixed_interface_mode: bool) → None

special super_secret_fixed_interface_mode

C++: protocols::anchored_design::AnchorMoversData::set_super_secret_fixed_interface_mode(bool) –> void

set_task_factory(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData, : pyrosetta.rosetta.core.pack.task.TaskFactory) → None

set packertask factory

C++: protocols::anchored_design::AnchorMoversData::set_task_factory(class std::shared_ptr<class core::pack::task::TaskFactory>) –> void

set_unbound_mode(self: pyrosetta.rosetta.protocols.anchored_design.AnchorMoversData, unbound_mode: bool) → None

used for unbound mode

C++: protocols::anchored_design::AnchorMoversData::set_unbound_mode(bool) –> void

class pyrosetta.rosetta.protocols.anchored_design.AnchoredPerturbMover

Bases: pyrosetta.rosetta.protocols.moves.Mover

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

1. __init__(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredPerturbMover, interface_in: protocols::anchored_design::AnchorMoversData) -> None
2. __init__(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredPerturbMover, arg0: pyrosetta.rosetta.protocols.anchored_design.AnchoredPerturbMover) -> 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.anchored_design.AnchoredPerturbMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::anchored_design::AnchoredPerturbMover::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredPerturbMover, : pyrosetta.rosetta.protocols.anchored_design.AnchoredPerturbMover) → pyrosetta.rosetta.protocols.anchored_design.AnchoredPerturbMover

C++: protocols::anchored_design::AnchoredPerturbMover::operator=(const class protocols::anchored_design::AnchoredPerturbMover &) –> class protocols::anchored_design::AnchoredPerturbMover &

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_debug(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredPerturbMover) → bool

debugging mode activates a bunch of extra output

C++: protocols::anchored_design::AnchoredPerturbMover::get_debug() const –> bool

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_min_type(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredPerturbMover) → str

what minimizer type to use?

C++: protocols::anchored_design::AnchoredPerturbMover::get_min_type() const –> const std::string &

get_name(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredPerturbMover) → str

C++: protocols::anchored_design::AnchoredPerturbMover::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_no_frags(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredPerturbMover) → bool

do not use fragments?

C++: protocols::anchored_design::AnchoredPerturbMover::get_no_frags() const –> bool

get_nonpivot_torsion_sampling(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredPerturbMover) → bool

use nonpivot torsion sampling for KIC?

C++: protocols::anchored_design::AnchoredPerturbMover::get_nonpivot_torsion_sampling() const –> bool

get_perturb_CCD_off(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredPerturbMover) → bool

do not perform CCD style closure (use KIC only)

C++: protocols::anchored_design::AnchoredPerturbMover::get_perturb_CCD_off() const –> bool

get_perturb_KIC_off(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredPerturbMover) → bool

do not perform KIC style closure (use CCD only)

C++: protocols::anchored_design::AnchoredPerturbMover::get_perturb_KIC_off() const –> bool

get_perturb_cycles(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredPerturbMover) → int

number of MC cycles

C++: protocols::anchored_design::AnchoredPerturbMover::get_perturb_cycles() const –> unsigned long

get_perturb_show(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredPerturbMover) → bool

show perturb result structure?

C++: protocols::anchored_design::AnchoredPerturbMover::get_perturb_show() const –> bool

get_perturb_temp(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredPerturbMover) → float

MC temperature

C++: protocols::anchored_design::AnchoredPerturbMover::get_perturb_temp() const –> double

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

read_options(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredPerturbMover) → None

read in options from the options system

C++: protocols::anchored_design::AnchoredPerturbMover::read_options() –> 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_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_debug(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredPerturbMover, debug: bool) → None

debugging mode activates a bunch of extra output

C++: protocols::anchored_design::AnchoredPerturbMover::set_debug(const bool) –> 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_min_type(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredPerturbMover, min_type: str) → None

what minimizer type to use?

C++: protocols::anchored_design::AnchoredPerturbMover::set_min_type(const class std::basic_string<char> &) –> 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_no_frags(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredPerturbMover, no_frags: bool) → None

do not use fragments?

C++: protocols::anchored_design::AnchoredPerturbMover::set_no_frags(const bool) –> void

set_nonpivot_torsion_sampling(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredPerturbMover, nonpivot_torsion_sampling: bool) → None

use nonpivot torsion sampling for KIC?

C++: protocols::anchored_design::AnchoredPerturbMover::set_nonpivot_torsion_sampling(const bool) –> void

set_perturb_CCD_off(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredPerturbMover, perturb_CCD_off: bool) → None

do not perform CCD style closure (use KIC only)

C++: protocols::anchored_design::AnchoredPerturbMover::set_perturb_CCD_off(const bool) –> void

set_perturb_KIC_off(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredPerturbMover, perturb_KIC_off: bool) → None

do not perform KIC style closure (use CCD only)

C++: protocols::anchored_design::AnchoredPerturbMover::set_perturb_KIC_off(const bool) –> void

set_perturb_cycles(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredPerturbMover, perturb_cycles: int) → None

number of MC cycles

C++: protocols::anchored_design::AnchoredPerturbMover::set_perturb_cycles(const unsigned long) –> void

set_perturb_show(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredPerturbMover, perturb_show: bool) → None

show perturb result structure?

C++: protocols::anchored_design::AnchoredPerturbMover::set_perturb_show(const bool) –> void

set_perturb_temp(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredPerturbMover, perturb_temp: float) → None

MC temperature

C++: protocols::anchored_design::AnchoredPerturbMover::set_perturb_temp(const double) –> 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.

1. show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None
2. 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.

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

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

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

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