anchored_design

Bindings for protocols::anchored_design namespace

class pyrosetta.rosetta.protocols.anchored_design.Anchor

Bases: 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.

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 std::string &) –> 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 std::string &) –> 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_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.

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 std::string &) –> 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 std::string &) –> 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 std::string &) –> 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 std::string &) –> 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.AnchoredDesignMover

Bases: Mover

apply(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredDesignMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

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

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

assignment operator

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

calculate_rmsd(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredDesignMover, pose: pyrosetta.rosetta.core.pose.Pose, start_pose: pyrosetta.rosetta.core.pose.Pose) → None

calculate RMSD if desired; protected internally

C++: protocols::anchored_design::AnchoredDesignMover::calculate_rmsd(const class core::pose::Pose &, class std::shared_ptr<const class core::pose::Pose>) –> void

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

C++: protocols::anchored_design::AnchoredDesignMover::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>

delete_interface_native_sidechains(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredDesignMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

This function repacks the interface with use_input_sc forcibly off for benchmarking purposes.

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

filter(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredDesignMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

runs varous filtering checks on the finished pose; sets MoverStatus for failure as needed

C++: protocols::anchored_design::AnchoredDesignMover::filter(class core::pose::Pose &) –> void

forget_initial_loops(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredDesignMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

implements the “extended” field of the loop file specification - sets extended phi/psi as needed

C++: protocols::anchored_design::AnchoredDesignMover::forget_initial_loops(class core::pose::Pose &) –> void

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

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

get_RMSD_only_this(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredDesignMover) → str

run only RMSD calculations against this input, don’t do actual AnchoredDesign

C++: protocols::anchored_design::AnchoredDesignMover::get_RMSD_only_this() const –> const std::string &

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.

Supported in JD2. Will attempt to grab additional poses until a nullptr is returned.

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

get_autoinitialize(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredDesignMover) → bool

whether to automatically initialize from the options system; defaults to true

C++: protocols::anchored_design::AnchoredDesignMover::get_autoinitialize() const –> bool

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

delete the input sidechains (independently from use_input_sc in the packer) - used to prevent leakage of sidechains in benchmarking mode

C++: protocols::anchored_design::AnchoredDesignMover::get_delete_interface_native_sidechains() const –> bool

get_filter_SASA(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredDesignMover) → float

filter based on complex SASA

C++: protocols::anchored_design::AnchoredDesignMover::get_filter_SASA() const –> double

get_filter_omega(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredDesignMover) → bool

filter based on omega angles in the loops - filter out cis omegas

C++: protocols::anchored_design::AnchoredDesignMover::get_filter_omega() const –> bool

get_filter_score(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredDesignMover) → float

filter based on total complex score

C++: protocols::anchored_design::AnchoredDesignMover::get_filter_score() const –> double

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.anchored_design.AnchoredDesignMover) → str

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

randomize_input_sequence to complement loop extension in forgetting the input

C++: protocols::anchored_design::AnchoredDesignMover::get_randomize_input_sequence() const –> bool

get_refine_only(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredDesignMover) → bool

skip the perturbation step - useful when you already have a good structure

C++: protocols::anchored_design::AnchoredDesignMover::get_refine_only() const –> bool

get_rmsd(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredDesignMover) → bool

run RMSD calculations

C++: protocols::anchored_design::AnchoredDesignMover::get_rmsd() const –> bool

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

show_extended demonstrates that the code really forgets the input structure

C++: protocols::anchored_design::AnchoredDesignMover::get_show_extended() const –> bool

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

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

get_vary_cutpoints(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredDesignMover) → bool

pick a different cutpoint than the input; useful when you want to sample cutpoints

C++: protocols::anchored_design::AnchoredDesignMover::get_vary_cutpoints() const –> bool

info(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.list_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

static name() → str

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

parse_my_tag(self: pyrosetta.rosetta.protocols.moves.Mover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None

Called by MoverFactory when constructing new Movers. Takes care of the specific mover’s parsing.

C++: protocols::moves::Mover::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

perturb_anchor(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredDesignMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

handles perturbing the initial anchor placement

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

provide_citation_info(self: pyrosetta.rosetta.protocols.moves.Mover, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None

Provide citations to the passed CitationCollectionList

Subclasses should add the info for themselves and any other classes they use.

The default implementation of this function does nothing. It may be overriden by movers wishing to provide citation information.

C++: protocols::moves::Mover::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

randomize_input_sequence(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredDesignMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

randomize the input loop sequence. Useful if you have reason to believe the starting loop sequence is biasing to a particular unwanted structure in centroid mode. Acts only on designable positions.

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

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

read in options from the options system

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

static 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.anchored_design.AnchoredDesignMover) → bool

C++: protocols::anchored_design::AnchoredDesignMover::reinitialize_for_each_job() const –> bool

reinitialize_for_new_input(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredDesignMover) → bool

C++: protocols::anchored_design::AnchoredDesignMover::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_RMSD_only_this(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredDesignMover, RMSD_only_this: str) → None

run only RMSD calculations against this input, don’t do actual AnchoredDesign

C++: protocols::anchored_design::AnchoredDesignMover::set_RMSD_only_this(const std::string &) –> void

set_autoinitialize(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredDesignMover, autoinitialize: bool) → None

whether to automatically initialize from the options system; defaults to true

C++: protocols::anchored_design::AnchoredDesignMover::set_autoinitialize(const bool) –> void

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

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 std::string &) –> void

set_delete_interface_native_sidechains(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredDesignMover, delete_interface_native_sidechains: bool) → None

delete the input sidechains (independently from use_input_sc in the packer) - used to prevent leakage of sidechains in benchmarking mode

C++: protocols::anchored_design::AnchoredDesignMover::set_delete_interface_native_sidechains(const bool) –> void

set_filter_SASA(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredDesignMover, filter_SASA: float) → None

filter based on complex SASA

C++: protocols::anchored_design::AnchoredDesignMover::set_filter_SASA(const double) –> void

set_filter_omega(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredDesignMover, filter_omega: bool) → None

filter based on omega angles in the loops - filter out cis omegas

C++: protocols::anchored_design::AnchoredDesignMover::set_filter_omega(const bool) –> void

set_filter_score(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredDesignMover, filter_score: float) → None

filter based on total complex score

C++: protocols::anchored_design::AnchoredDesignMover::set_filter_score(const double) –> void

set_fold_tree_and_cutpoints(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredDesignMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

creates the anchored design fold tree and applies it to the pose

C++: protocols::anchored_design::AnchoredDesignMover::set_fold_tree_and_cutpoints(class core::pose::Pose &) –> 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_randomize_input_sequence(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredDesignMover, randomize_input_sequence: bool) → None

randomize_input_sequence to complement loop extension in forgetting the input

C++: protocols::anchored_design::AnchoredDesignMover::set_randomize_input_sequence(const bool) –> void

set_refine_only(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredDesignMover, refine_only: bool) → None

skip the perturbation step - useful when you already have a good structure

C++: protocols::anchored_design::AnchoredDesignMover::set_refine_only(const bool) –> void

set_rmsd(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredDesignMover, rmsd: bool) → None

run RMSD calculations

C++: protocols::anchored_design::AnchoredDesignMover::set_rmsd(const bool) –> void

set_show_extended(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredDesignMover, show_extended: bool) → None

show_extended demonstrates that the code really forsets the input structure

C++: protocols::anchored_design::AnchoredDesignMover::set_show_extended(const bool) –> void

set_type(self: pyrosetta.rosetta.protocols.moves.Mover, setting: str) → None

Set the ‘type’ string

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

set_vary_cutpoints(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredDesignMover, vary_cutpoints: bool) → None

pick a different cutpoint than the input; useful when you want to sample cutpoints

C++: protocols::anchored_design::AnchoredDesignMover::set_vary_cutpoints(const bool) –> 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(std::ostream &) 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, type_in: str) -> None

Set the ‘type’ string

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

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

Get the set ‘type’ string

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

class pyrosetta.rosetta.protocols.anchored_design.AnchoredPerturbMover

Bases: Mover

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.

Supported in JD2. Will attempt to grab additional poses until a nullptr is returned.

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

static name() → str

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

parse_my_tag(self: pyrosetta.rosetta.protocols.moves.Mover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None

Called by MoverFactory when constructing new Movers. Takes care of the specific mover’s parsing.

C++: protocols::moves::Mover::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.moves.Mover, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None

Provide citations to the passed CitationCollectionList

Subclasses should add the info for themselves and any other classes they use.

The default implementation of this function does nothing. It may be overriden by movers wishing to provide citation information.

C++: protocols::moves::Mover::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

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

static 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

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 std::string &) –> 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 std::string &) –> 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

Set the ‘type’ string

C++: protocols::moves::Mover::set_type(const std::string &) –> 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(std::ostream &) 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, type_in: str) -> None

Set the ‘type’ string

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

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

Get the set ‘type’ string

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

class pyrosetta.rosetta.protocols.anchored_design.AnchoredRefineMover

Bases: Mover

apply(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredRefineMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

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

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

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

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.

Supported in JD2. Will attempt to grab additional poses until a nullptr is returned.

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.AnchoredRefineMover) → bool

debugging mode activates a bunch of extra output

C++: protocols::anchored_design::AnchoredRefineMover::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.AnchoredRefineMover) → str

what minimizer type to use?

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

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

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

use nonpivot torsion sampling for KIC?

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

get_refine_CCD_off(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredRefineMover) → bool

do not perform CCD style closure (use KIC only)

C++: protocols::anchored_design::AnchoredRefineMover::get_refine_CCD_off() const –> bool

get_refine_KIC_off(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredRefineMover) → bool

do not perform KIC style closure (use CCD only)

C++: protocols::anchored_design::AnchoredRefineMover::get_refine_KIC_off() const –> bool

get_refine_cycles(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredRefineMover) → int

number of MC cycles

C++: protocols::anchored_design::AnchoredRefineMover::get_refine_cycles() const –> unsigned long

get_refine_repack_cycles(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredRefineMover) → int

how many cycles between repack/design opportunities?

C++: protocols::anchored_design::AnchoredRefineMover::get_refine_repack_cycles() const –> unsigned long

get_refine_temp(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredRefineMover) → float

MC temperature

C++: protocols::anchored_design::AnchoredRefineMover::get_refine_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

get_vicinity_degree(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredRefineMover) → float

KIC vicinity sampling degrees

C++: protocols::anchored_design::AnchoredRefineMover::get_vicinity_degree() const –> double

get_vicinity_sampling(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredRefineMover) → bool

KIC use vicinity sampling?

C++: protocols::anchored_design::AnchoredRefineMover::get_vicinity_sampling() const –> bool

info(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.list_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

static name() → str

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

parse_my_tag(self: pyrosetta.rosetta.protocols.moves.Mover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None

Called by MoverFactory when constructing new Movers. Takes care of the specific mover’s parsing.

C++: protocols::moves::Mover::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.moves.Mover, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None

Provide citations to the passed CitationCollectionList

Subclasses should add the info for themselves and any other classes they use.

The default implementation of this function does nothing. It may be overriden by movers wishing to provide citation information.

C++: protocols::moves::Mover::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

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

read in options from the options system

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

static 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

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 std::string &) –> void

set_debug(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredRefineMover, debug: bool) → None

debugging mode activates a bunch of extra output

C++: protocols::anchored_design::AnchoredRefineMover::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.AnchoredRefineMover, min_type: str) → None

what minimizer type to use?

C++: protocols::anchored_design::AnchoredRefineMover::set_min_type(const std::string &) –> 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_nonpivot_torsion_sampling(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredRefineMover, nonpivot_torsion_sampling: bool) → None

use nonpivot torsion sampling for KIC?

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

set_refine_CCD_off(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredRefineMover, refine_CCD_off: bool) → None

do not perform CCD style closure (use KIC only)

C++: protocols::anchored_design::AnchoredRefineMover::set_refine_CCD_off(const bool) –> void

set_refine_KIC_off(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredRefineMover, refine_KIC_off: bool) → None

do not perform KIC style closure (use CCD only)

C++: protocols::anchored_design::AnchoredRefineMover::set_refine_KIC_off(const bool) –> void

set_refine_cycles(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredRefineMover, refine_cycles: int) → None

number of MC cycles

C++: protocols::anchored_design::AnchoredRefineMover::set_refine_cycles(const unsigned long) –> void

set_refine_repack_cycles(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredRefineMover, refine_repack_cycles: int) → None

how many cycles between repack/design opportunities?

C++: protocols::anchored_design::AnchoredRefineMover::set_refine_repack_cycles(const unsigned long) –> void

set_refine_temp(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredRefineMover, refine_temp: float) → None

MC temperature

C++: protocols::anchored_design::AnchoredRefineMover::set_refine_temp(const double) –> void

set_type(self: pyrosetta.rosetta.protocols.moves.Mover, setting: str) → None

Set the ‘type’ string

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

set_vicinity_degree(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredRefineMover, vicinity_degree: int) → None

KIC vicinity sampling degrees

C++: protocols::anchored_design::AnchoredRefineMover::set_vicinity_degree(const unsigned long) –> void

set_vicinity_sampling(self: pyrosetta.rosetta.protocols.anchored_design.AnchoredRefineMover, vicinity_sampling: bool) → None

KIC use vicinity sampling?

C++: protocols::anchored_design::AnchoredRefineMover::set_vicinity_sampling(const bool) –> 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(std::ostream &) 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, type_in: str) -> None

Set the ‘type’ string

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

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

Get the set ‘type’ string

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