relax

• loop
• membrane

Bindings for protocols::relax namespace

class pyrosetta.rosetta.protocols.relax.AcceptToBestMover

Bases: Mover

apply(self: pyrosetta.rosetta.protocols.relax.AcceptToBestMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::relax::AcceptToBestMover::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.relax.AcceptToBestMover, : pyrosetta.rosetta.protocols.relax.AcceptToBestMover) → pyrosetta.rosetta.protocols.relax.AcceptToBestMover

C++: protocols::relax::AcceptToBestMover::operator=(const class protocols::relax::AcceptToBestMover &) –> class protocols::relax::AcceptToBestMover &

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

C++: protocols::relax::AcceptToBestMover::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.relax.AcceptToBestMover) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::relax::AcceptToBestMover::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_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.relax.AcceptToBestMover) → str

C++: protocols::relax::AcceptToBestMover::get_name() const –> std::string

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

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

get_self_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.protocols.moves.Mover

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

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.weak_ptr_protocols_moves_Mover_t

C++: protocols::moves::Mover::get_self_weak_ptr() –> class std::weak_ptr<class protocols::moves::Mover>

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

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

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

C++: protocols::relax::AcceptToBestMover::mover_name() –> std::string

static name() → str

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

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

C++: protocols::relax::AcceptToBestMover::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

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None

C++: protocols::relax::AcceptToBestMover::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> 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_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_sfxn(self: pyrosetta.rosetta.protocols.relax.AcceptToBestMover, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: protocols::relax::AcceptToBestMover::set_sfxn(const class std::shared_ptr<class core::scoring::ScoreFunction> &) –> 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.relax.AcceptToBestMoverCreator

Bases: MoverCreator

assign(self: pyrosetta.rosetta.protocols.relax.AcceptToBestMoverCreator, : pyrosetta.rosetta.protocols.relax.AcceptToBestMoverCreator) → pyrosetta.rosetta.protocols.relax.AcceptToBestMoverCreator

C++: protocols::relax::AcceptToBestMoverCreator::operator=(const class protocols::relax::AcceptToBestMoverCreator &) –> class protocols::relax::AcceptToBestMoverCreator &

create_mover(self: pyrosetta.rosetta.protocols.relax.AcceptToBestMoverCreator) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::relax::AcceptToBestMoverCreator::create_mover() const –> class std::shared_ptr<class protocols::moves::Mover>

keyname(self: pyrosetta.rosetta.protocols.relax.AcceptToBestMoverCreator) → str

C++: protocols::relax::AcceptToBestMoverCreator::keyname() const –> std::string

static mover_name() → str

C++: protocols::relax::AcceptToBestMoverCreator::mover_name() –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.relax.AcceptToBestMoverCreator, xsd: utility::tag::XMLSchemaDefinition) → None

C++: protocols::relax::AcceptToBestMoverCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.protocols.relax.AtomCoordinateCstMover

Bases: Mover

ambiguous_hnq(*args, **kwargs)

Overloaded function.

1. ambiguous_hnq(self: pyrosetta.rosetta.protocols.relax.AtomCoordinateCstMover, flip_hnq: bool) -> None

C++: protocols::relax::AtomCoordinateCstMover::ambiguous_hnq(bool) –> void

2. ambiguous_hnq(self: pyrosetta.rosetta.protocols.relax.AtomCoordinateCstMover) -> bool

C++: protocols::relax::AtomCoordinateCstMover::ambiguous_hnq() const –> bool

apply(self: pyrosetta.rosetta.protocols.relax.AtomCoordinateCstMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::relax::AtomCoordinateCstMover::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.relax.AtomCoordinateCstMover, : pyrosetta.rosetta.protocols.relax.AtomCoordinateCstMover) → pyrosetta.rosetta.protocols.relax.AtomCoordinateCstMover

C++: protocols::relax::AtomCoordinateCstMover::operator=(const class protocols::relax::AtomCoordinateCstMover &) –> class protocols::relax::AtomCoordinateCstMover &

bounded(*args, **kwargs)

Overloaded function.

1. bounded(self: pyrosetta.rosetta.protocols.relax.AtomCoordinateCstMover, bound: bool) -> None

C++: protocols::relax::AtomCoordinateCstMover::bounded(bool) –> void

2. bounded(self: pyrosetta.rosetta.protocols.relax.AtomCoordinateCstMover) -> bool

C++: protocols::relax::AtomCoordinateCstMover::bounded() const –> bool

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

C++: protocols::relax::AtomCoordinateCstMover::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>

cst_sd(*args, **kwargs)

Overloaded function.

1. cst_sd(self: pyrosetta.rosetta.protocols.relax.AtomCoordinateCstMover, sd: float) -> None

C++: protocols::relax::AtomCoordinateCstMover::cst_sd(double) –> void

2. cst_sd(self: pyrosetta.rosetta.protocols.relax.AtomCoordinateCstMover) -> float

C++: protocols::relax::AtomCoordinateCstMover::cst_sd() const –> double

cst_sidechain(*args, **kwargs)

Overloaded function.

1. cst_sidechain(self: pyrosetta.rosetta.protocols.relax.AtomCoordinateCstMover, sidechains: bool) -> None

C++: protocols::relax::AtomCoordinateCstMover::cst_sidechain(bool) –> void

2. cst_sidechain(self: pyrosetta.rosetta.protocols.relax.AtomCoordinateCstMover) -> bool

C++: protocols::relax::AtomCoordinateCstMover::cst_sidechain() const –> bool

cst_width(*args, **kwargs)

Overloaded function.

1. cst_width(self: pyrosetta.rosetta.protocols.relax.AtomCoordinateCstMover, width: float) -> None

C++: protocols::relax::AtomCoordinateCstMover::cst_width(double) –> void

2. cst_width(self: pyrosetta.rosetta.protocols.relax.AtomCoordinateCstMover) -> float

C++: protocols::relax::AtomCoordinateCstMover::cst_width() const –> double

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

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

func_groups(*args, **kwargs)

Overloaded function.

1. func_groups(self: pyrosetta.rosetta.protocols.relax.AtomCoordinateCstMover, b: bool) -> None

C++: protocols::relax::AtomCoordinateCstMover::func_groups(bool) –> void

2. func_groups(self: pyrosetta.rosetta.protocols.relax.AtomCoordinateCstMover) -> bool

C++: protocols::relax::AtomCoordinateCstMover::func_groups() const –> bool

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_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.relax.AtomCoordinateCstMover) → str

C++: protocols::relax::AtomCoordinateCstMover::get_name() const –> std::string

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

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

get_self_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.protocols.moves.Mover

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

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.weak_ptr_protocols_moves_Mover_t

C++: protocols::moves::Mover::get_self_weak_ptr() –> class std::weak_ptr<class protocols::moves::Mover>

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

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

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

C++: protocols::relax::AtomCoordinateCstMover::mover_name() –> std::string

static name() → str

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

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

C++: protocols::relax::AtomCoordinateCstMover::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

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None

C++: protocols::relax::AtomCoordinateCstMover::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> 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_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_loop_segments(self: pyrosetta.rosetta.protocols.relax.AtomCoordinateCstMover, loops: pyrosetta.rosetta.protocols.loops.Loops) → None

C++: protocols::relax::AtomCoordinateCstMover::set_loop_segments(class std::shared_ptr<const class protocols::loops::Loops>) –> 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_refstruct(self: pyrosetta.rosetta.protocols.relax.AtomCoordinateCstMover, ref: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::relax::AtomCoordinateCstMover::set_refstruct(class std::shared_ptr<const class core::pose::Pose>) –> void

set_task_segments(self: pyrosetta.rosetta.protocols.relax.AtomCoordinateCstMover, taskfactory: pyrosetta.rosetta.core.pack.task.TaskFactory) → None

C++: protocols::relax::AtomCoordinateCstMover::set_task_segments(class std::shared_ptr<const class core::pack::task::TaskFactory>) –> 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.relax.AtomCoordinateCstMoverCreator

Bases: MoverCreator

assign(self: pyrosetta.rosetta.protocols.relax.AtomCoordinateCstMoverCreator, : pyrosetta.rosetta.protocols.relax.AtomCoordinateCstMoverCreator) → pyrosetta.rosetta.protocols.relax.AtomCoordinateCstMoverCreator

C++: protocols::relax::AtomCoordinateCstMoverCreator::operator=(const class protocols::relax::AtomCoordinateCstMoverCreator &) –> class protocols::relax::AtomCoordinateCstMoverCreator &

create_mover(self: pyrosetta.rosetta.protocols.relax.AtomCoordinateCstMoverCreator) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::relax::AtomCoordinateCstMoverCreator::create_mover() const –> class std::shared_ptr<class protocols::moves::Mover>

keyname(self: pyrosetta.rosetta.protocols.relax.AtomCoordinateCstMoverCreator) → str

C++: protocols::relax::AtomCoordinateCstMoverCreator::keyname() const –> std::string

static mover_name() → str

C++: protocols::relax::AtomCoordinateCstMoverCreator::mover_name() –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.relax.AtomCoordinateCstMoverCreator, xsd: utility::tag::XMLSchemaDefinition) → None

C++: protocols::relax::AtomCoordinateCstMoverCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.protocols.relax.CentroidRelax

Bases: RelaxProtocolBase

Relax a pose using Frank Dimaio’s smooth centroid statistics. Currently under optimization.

Minimize a centroid representation of a pose. Ramp VDW/Rama or both.

May tweak structure by up to ~2.5 A without constraints. Use custom constraints or coordinate constraints through relax options for best results. Using starting coordinate constraints, structure is tweaked by ~.3/.4 A Use increased VDW radii option for bb to improve bb-geometry when not using constraints

apply(self: pyrosetta.rosetta.protocols.relax.CentroidRelax, pose: pyrosetta.rosetta.core.pose.Pose) → None

Applies the protocol, See notes

Setting ramp_rama and ramp_vdw to false switches to the BASIC protocol which is rounds of the centroid minmover

C++: protocols::relax::CentroidRelax::apply(class core::pose::Pose &) –> void

apply_disulfides(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::relax::RelaxProtocolBase::apply_disulfides(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.relax.CentroidRelax, : pyrosetta.rosetta.protocols.relax.CentroidRelax) → pyrosetta.rosetta.protocols.relax.CentroidRelax

C++: protocols::relax::CentroidRelax::operator=(const class protocols::relax::CentroidRelax &) –> class protocols::relax::CentroidRelax &

cartesian(*args, **kwargs)

Overloaded function.

1. cartesian(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::cartesian() const –> bool

2. cartesian(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, newval: bool) -> None

Use cartesian (minimization step)

Sets to use the lbfgs_armijo_nonmonotone if true or FR default if false Recommended to set max_iter to 200. Requires scorefunction setup for non-ideal minimization.

C++: protocols::relax::RelaxProtocolBase::cartesian(bool) –> 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.relax.CentroidRelax) → pyrosetta.rosetta.protocols.moves.Mover

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

constrain_coords(*args, **kwargs)

Overloaded function.

1. constrain_coords(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::constrain_coords() const –> bool

2. constrain_coords(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, constrain_coords: bool) -> None

C++: protocols::relax::RelaxProtocolBase::constrain_coords(bool) –> void

constrain_relax_segments(*args, **kwargs)

Overloaded function.

1. constrain_relax_segments(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::constrain_relax_segments() const –> bool

2. constrain_relax_segments(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, constrain_relax_segments: bool) -> None

C++: protocols::relax::RelaxProtocolBase::constrain_relax_segments(bool) –> void

constrain_relax_to_native_coords(*args, **kwargs)

Overloaded function.

1. constrain_relax_to_native_coords(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::constrain_relax_to_native_coords() const –> bool

2. constrain_relax_to_native_coords(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, constrain_relax_to_native_coords: bool) -> None

C++: protocols::relax::RelaxProtocolBase::constrain_relax_to_native_coords(bool) –> void

constrain_relax_to_start_coords(*args, **kwargs)

Overloaded function.

1. constrain_relax_to_start_coords(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::constrain_relax_to_start_coords() const –> bool

2. constrain_relax_to_start_coords(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, constrain_relax_to_start_coords: bool) -> None

C++: protocols::relax::RelaxProtocolBase::constrain_relax_to_start_coords(bool) –> void

coord_constrain_sidechains(*args, **kwargs)

Overloaded function.

1. coord_constrain_sidechains(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::coord_constrain_sidechains() const –> bool

2. coord_constrain_sidechains(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, coord_constrain_sidechains: bool) -> None

C++: protocols::relax::RelaxProtocolBase::coord_constrain_sidechains(bool) –> void

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>

do_final_repack(self: pyrosetta.rosetta.protocols.relax.CentroidRelax, repack_sc: bool) → None

If a fullatom pose is passed, should we repack sidechains according to movemap?

C++: protocols::relax::CentroidRelax::do_final_repack(bool) –> void

dry_run(*args, **kwargs)

Overloaded function.

1. dry_run(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::dry_run() const –> bool

2. dry_run(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, setting: bool) -> None

C++: protocols::relax::RelaxProtocolBase::dry_run(bool) –> void

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

C++: protocols::relax::RelaxProtocolBase::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_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_movemap(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) → pyrosetta.rosetta.core.kinematics.MoveMap

C++: protocols::relax::RelaxProtocolBase::get_movemap() –> class std::shared_ptr<class core::kinematics::MoveMap>

get_name(self: pyrosetta.rosetta.protocols.relax.CentroidRelax) → str

C++: protocols::relax::CentroidRelax::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_scorefxn(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) → pyrosetta.rosetta.core.scoring.ScoreFunction

C++: protocols::relax::RelaxProtocolBase::get_scorefxn() const –> const class std::shared_ptr<const class core::scoring::ScoreFunction>

get_self_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.protocols.moves.Mover

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

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.weak_ptr_protocols_moves_Mover_t

C++: protocols::moves::Mover::get_self_weak_ptr() –> class std::weak_ptr<class protocols::moves::Mover>

get_task_factory(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) → pyrosetta.rosetta.core.pack.task.TaskFactory

C++: protocols::relax::RelaxProtocolBase::get_task_factory() const –> const class std::shared_ptr<class core::pack::task::TaskFactory> &

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

max_iter(*args, **kwargs)

Overloaded function.

1. max_iter(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> int

C++: protocols::relax::RelaxProtocolBase::max_iter() const –> unsigned long

2. max_iter(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, max_iter: int) -> None

C++: protocols::relax::RelaxProtocolBase::max_iter(unsigned long) –> void

min_type(*args, **kwargs)

Overloaded function.

1. min_type(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> str

C++: protocols::relax::RelaxProtocolBase::min_type() const –> std::string

2. min_type(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, min_type: str) -> None

C++: protocols::relax::RelaxProtocolBase::min_type(std::string) –> void

minimize_bond_angles(*args, **kwargs)

Overloaded function.

1. minimize_bond_angles(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::minimize_bond_angles() const –> bool

2. minimize_bond_angles(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, minimize_bond_angles: bool) -> None

C++: protocols::relax::RelaxProtocolBase::minimize_bond_angles(bool) –> void

minimize_bond_lengths(*args, **kwargs)

Overloaded function.

1. minimize_bond_lengths(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::minimize_bond_lengths() const –> bool

2. minimize_bond_lengths(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, minimize_bond_lengths: bool) -> None

C++: protocols::relax::RelaxProtocolBase::minimize_bond_lengths(bool) –> void

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.relax.RelaxProtocolBase, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None

Provide the citation.

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

ramp_down_constraints(*args, **kwargs)

Overloaded function.

1. ramp_down_constraints(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::ramp_down_constraints() const –> bool

2. ramp_down_constraints(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, ramp_down_constraints: bool) -> None

C++: protocols::relax::RelaxProtocolBase::ramp_down_constraints(bool) –> void

static register_options() → None

C++: protocols::relax::RelaxProtocolBase::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_cartesian(self: pyrosetta.rosetta.protocols.relax.CentroidRelax, cart: bool) → None

Sets to use the cartesian minimizer.

C++: protocols::relax::CentroidRelax::set_cartesian(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_default_coordinate_settings(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) → None

C++: protocols::relax::RelaxProtocolBase::set_default_coordinate_settings() –> void

set_default_minimization_settings(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) → None

C++: protocols::relax::RelaxProtocolBase::set_default_minimization_settings() –> void

set_default_movemap(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) → None

C++: protocols::relax::RelaxProtocolBase::set_default_movemap() –> void

set_defaults(self: pyrosetta.rosetta.protocols.relax.CentroidRelax) → None

C++: protocols::relax::CentroidRelax::set_defaults() –> void

set_fa_score_function(self: pyrosetta.rosetta.protocols.relax.CentroidRelax, fa_score: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

Sets fullatom scorefunction - only used for scoring the full atom pose before and after protocol.

C++: protocols::relax::CentroidRelax::set_fa_score_function(class std::shared_ptr<class core::scoring::ScoreFunction>) –> void

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

setter for poses contained for rms

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

set_min_type(self: pyrosetta.rosetta.protocols.relax.CentroidRelax, min: str) → None

Sets the minimizer type.

C++: protocols::relax::CentroidRelax::set_min_type(std::string) –> void

set_movemap(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, movemap: pyrosetta.rosetta.core.kinematics.MoveMap) → None

C++: protocols::relax::RelaxProtocolBase::set_movemap(class std::shared_ptr<class core::kinematics::MoveMap>) –> void

set_movemap_factory(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, mm_factory: pyrosetta.rosetta.core.select.movemap.MoveMapFactory) → None

C++: protocols::relax::RelaxProtocolBase::set_movemap_factory(class std::shared_ptr<class core::select::movemap::MoveMapFactory>) –> 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_ramp_rama(self: pyrosetta.rosetta.protocols.relax.CentroidRelax, use: bool) → None

Ramp Rama according to centroid relax parameters

C++: protocols::relax::CentroidRelax::set_ramp_rama(bool) –> void

set_ramp_vdw(self: pyrosetta.rosetta.protocols.relax.CentroidRelax, use: bool) → None

Ramp VDW according to centroid relax parameters

C++: protocols::relax::CentroidRelax::set_ramp_vdw(bool) –> void

set_rounds(self: pyrosetta.rosetta.protocols.relax.CentroidRelax, rounds: int) → None

C++: protocols::relax::CentroidRelax::set_rounds(unsigned long) –> void

set_score_function(self: pyrosetta.rosetta.protocols.relax.CentroidRelax, cen_score: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

Sets main scorefunction used for centroid minimization.

C++: protocols::relax::CentroidRelax::set_score_function(class std::shared_ptr<class core::scoring::ScoreFunction>) –> void

set_scorefxn(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: protocols::relax::RelaxProtocolBase::set_scorefxn(class std::shared_ptr<class core::scoring::ScoreFunction>) –> void

set_task_factory(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, task_factory: pyrosetta.rosetta.core.pack.task.TaskFactory) → None

C++: protocols::relax::RelaxProtocolBase::set_task_factory(class std::shared_ptr<class core::pack::task::TaskFactory>) –> 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_use_increased_vdw_radii(self: pyrosetta.rosetta.protocols.relax.CentroidRelax, use: bool) → None

use larger VDW radii for atoms - bb for now - default True (Courtesy of Frank Dimaio)

C++: protocols::relax::CentroidRelax::set_use_increased_vdw_radii(bool) –> void

set_use_rama2b(self: pyrosetta.rosetta.protocols.relax.CentroidRelax, use: bool) → None

Sets to use Rama2b instead of Rama - default True

C++: protocols::relax::CentroidRelax::set_use_rama2b(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.relax.ClassicRelax

Bases: RelaxProtocolBase

A functor class which implements the classic Rosetta++ pose_relax protocol

apply(self: pyrosetta.rosetta.protocols.relax.ClassicRelax, pose: pyrosetta.rosetta.core.pose.Pose) → None

Central Apply function

C++: protocols::relax::ClassicRelax::apply(class core::pose::Pose &) –> void

apply_disulfides(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::relax::RelaxProtocolBase::apply_disulfides(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.relax.ClassicRelax, : pyrosetta.rosetta.protocols.relax.ClassicRelax) → pyrosetta.rosetta.protocols.relax.ClassicRelax

C++: protocols::relax::ClassicRelax::operator=(const class protocols::relax::ClassicRelax &) –> class protocols::relax::ClassicRelax &

cartesian(*args, **kwargs)

Overloaded function.

1. cartesian(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::cartesian() const –> bool

2. cartesian(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, newval: bool) -> None

Use cartesian (minimization step)

Sets to use the lbfgs_armijo_nonmonotone if true or FR default if false Recommended to set max_iter to 200. Requires scorefunction setup for non-ideal minimization.

C++: protocols::relax::RelaxProtocolBase::cartesian(bool) –> 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.relax.ClassicRelax) → pyrosetta.rosetta.protocols.moves.Mover

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

constrain_coords(*args, **kwargs)

Overloaded function.

1. constrain_coords(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::constrain_coords() const –> bool

2. constrain_coords(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, constrain_coords: bool) -> None

C++: protocols::relax::RelaxProtocolBase::constrain_coords(bool) –> void

constrain_relax_segments(*args, **kwargs)

Overloaded function.

1. constrain_relax_segments(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::constrain_relax_segments() const –> bool

2. constrain_relax_segments(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, constrain_relax_segments: bool) -> None

C++: protocols::relax::RelaxProtocolBase::constrain_relax_segments(bool) –> void

constrain_relax_to_native_coords(*args, **kwargs)

Overloaded function.

1. constrain_relax_to_native_coords(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::constrain_relax_to_native_coords() const –> bool

2. constrain_relax_to_native_coords(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, constrain_relax_to_native_coords: bool) -> None

C++: protocols::relax::RelaxProtocolBase::constrain_relax_to_native_coords(bool) –> void

constrain_relax_to_start_coords(*args, **kwargs)

Overloaded function.

1. constrain_relax_to_start_coords(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::constrain_relax_to_start_coords() const –> bool

2. constrain_relax_to_start_coords(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, constrain_relax_to_start_coords: bool) -> None

C++: protocols::relax::RelaxProtocolBase::constrain_relax_to_start_coords(bool) –> void

coord_constrain_sidechains(*args, **kwargs)

Overloaded function.

1. coord_constrain_sidechains(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::coord_constrain_sidechains() const –> bool

2. coord_constrain_sidechains(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, coord_constrain_sidechains: bool) -> None

C++: protocols::relax::RelaxProtocolBase::coord_constrain_sidechains(bool) –> void

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>

dry_run(*args, **kwargs)

Overloaded function.

1. dry_run(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::dry_run() const –> bool

2. dry_run(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, setting: bool) -> None

C++: protocols::relax::RelaxProtocolBase::dry_run(bool) –> void

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

C++: protocols::relax::RelaxProtocolBase::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_checkpoints(self: pyrosetta.rosetta.protocols.relax.ClassicRelax) → pyrosetta.rosetta.protocols.checkpoint.CheckPointer

C++: protocols::relax::ClassicRelax::get_checkpoints() –> class protocols::checkpoint::CheckPointer &

get_current_job(self: pyrosetta.rosetta.protocols.moves.Mover) → protocols::jobdist::BasicJob

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

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

A tag is a unique identifier used to identify structures produced

by this Mover. get_current_tag() returns the tag, and set_current_tag( std::string tag ) sets the tag. This functionality is not intended for use with the 2008 job distributor.

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

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

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

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

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

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

get_mc(self: pyrosetta.rosetta.protocols.relax.ClassicRelax, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.protocols.moves.MonteCarlo

Accessors

C++: protocols::relax::ClassicRelax::get_mc(class core::pose::Pose &) –> class std::shared_ptr<class protocols::moves::MonteCarlo>

get_movemap(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) → pyrosetta.rosetta.core.kinematics.MoveMap

C++: protocols::relax::RelaxProtocolBase::get_movemap() –> class std::shared_ptr<class core::kinematics::MoveMap>

get_name(self: pyrosetta.rosetta.protocols.relax.ClassicRelax) → str

C++: protocols::relax::ClassicRelax::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_scorefxn(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) → pyrosetta.rosetta.core.scoring.ScoreFunction

C++: protocols::relax::RelaxProtocolBase::get_scorefxn() const –> const class std::shared_ptr<const class core::scoring::ScoreFunction>

get_self_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.protocols.moves.Mover

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

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.weak_ptr_protocols_moves_Mover_t

C++: protocols::moves::Mover::get_self_weak_ptr() –> class std::weak_ptr<class protocols::moves::Mover>

get_task_factory(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) → pyrosetta.rosetta.core.pack.task.TaskFactory

C++: protocols::relax::RelaxProtocolBase::get_task_factory() const –> const class std::shared_ptr<class core::pack::task::TaskFactory> &

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

max_iter(*args, **kwargs)

Overloaded function.

1. max_iter(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> int

C++: protocols::relax::RelaxProtocolBase::max_iter() const –> unsigned long

2. max_iter(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, max_iter: int) -> None

C++: protocols::relax::RelaxProtocolBase::max_iter(unsigned long) –> void

min_type(*args, **kwargs)

Overloaded function.

1. min_type(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> str

C++: protocols::relax::RelaxProtocolBase::min_type() const –> std::string

2. min_type(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, min_type: str) -> None

C++: protocols::relax::RelaxProtocolBase::min_type(std::string) –> void

minimize_bond_angles(*args, **kwargs)

Overloaded function.

1. minimize_bond_angles(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::minimize_bond_angles() const –> bool

2. minimize_bond_angles(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, minimize_bond_angles: bool) -> None

C++: protocols::relax::RelaxProtocolBase::minimize_bond_angles(bool) –> void

minimize_bond_lengths(*args, **kwargs)

Overloaded function.

1. minimize_bond_lengths(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::minimize_bond_lengths() const –> bool

2. minimize_bond_lengths(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, minimize_bond_lengths: bool) -> None

C++: protocols::relax::RelaxProtocolBase::minimize_bond_lengths(bool) –> void

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.relax.RelaxProtocolBase, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None

Provide the citation.

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

ramp_down_constraints(*args, **kwargs)

Overloaded function.

1. ramp_down_constraints(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::ramp_down_constraints() const –> bool

2. ramp_down_constraints(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, ramp_down_constraints: bool) -> None

C++: protocols::relax::RelaxProtocolBase::ramp_down_constraints(bool) –> void

static register_options() → None

C++: protocols::relax::ClassicRelax::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

setPoseExtraScore(self: pyrosetta.rosetta.protocols.relax.ClassicRelax, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::relax::ClassicRelax::setPoseExtraScore(class core::pose::Pose &) –> 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_default(*args, **kwargs)

Overloaded function.

1. set_default(self: pyrosetta.rosetta.protocols.relax.ClassicRelax, scorefxn_in: pyrosetta.rosetta.core.scoring.ScoreFunction) -> None

C++: protocols::relax::ClassicRelax::set_default(class std::shared_ptr<class core::scoring::ScoreFunction>) –> void

2. set_default(self: pyrosetta.rosetta.protocols.relax.ClassicRelax) -> None

3. set_default(self: pyrosetta.rosetta.protocols.relax.ClassicRelax, use_default_movemap: bool) -> None

Set default options from outside

C++: protocols::relax::ClassicRelax::set_default(const bool) –> void

set_default_coordinate_settings(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) → None

C++: protocols::relax::RelaxProtocolBase::set_default_coordinate_settings() –> void

set_default_minimization_settings(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) → None

C++: protocols::relax::RelaxProtocolBase::set_default_minimization_settings() –> void

set_default_minimizer(self: pyrosetta.rosetta.protocols.relax.ClassicRelax) → None

C++: protocols::relax::ClassicRelax::set_default_minimizer() –> void

set_default_movemap(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) → None

C++: protocols::relax::RelaxProtocolBase::set_default_movemap() –> void

set_default_moveset_phase1(self: pyrosetta.rosetta.protocols.relax.ClassicRelax) → None

C++: protocols::relax::ClassicRelax::set_default_moveset_phase1() –> void

set_default_moveset_phase2(self: pyrosetta.rosetta.protocols.relax.ClassicRelax) → None

C++: protocols::relax::ClassicRelax::set_default_moveset_phase2() –> void

set_default_moveset_phase3(self: pyrosetta.rosetta.protocols.relax.ClassicRelax) → None

C++: protocols::relax::ClassicRelax::set_default_moveset_phase3() –> void

set_defaults(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) → None

C++: protocols::relax::RelaxProtocolBase::set_defaults() –> void

set_full_repack(self: pyrosetta.rosetta.protocols.relax.ClassicRelax, new_pack_full_repack: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover) → None

C++: protocols::relax::ClassicRelax::set_full_repack(class std::shared_ptr<class protocols::minimization_packing::PackRotamersMover>) –> 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_lj_ramp_cycles(self: pyrosetta.rosetta.protocols.relax.ClassicRelax, param: int) → None

Set options from outside

C++: protocols::relax::ClassicRelax::set_lj_ramp_cycles(int) –> void

set_lj_ramp_inner_cycles(self: pyrosetta.rosetta.protocols.relax.ClassicRelax, param: int) → None

C++: protocols::relax::ClassicRelax::set_lj_ramp_inner_cycles(int) –> void

set_mc(self: pyrosetta.rosetta.protocols.relax.ClassicRelax, new_mc_: pyrosetta.rosetta.protocols.moves.MonteCarlo) → None

C++: protocols::relax::ClassicRelax::set_mc(class std::shared_ptr<class protocols::moves::MonteCarlo>) –> void

set_movemap(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, movemap: pyrosetta.rosetta.core.kinematics.MoveMap) → None

C++: protocols::relax::RelaxProtocolBase::set_movemap(class std::shared_ptr<class core::kinematics::MoveMap>) –> void

set_movemap_factory(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, mm_factory: pyrosetta.rosetta.core.select.movemap.MoveMapFactory) → None

C++: protocols::relax::RelaxProtocolBase::set_movemap_factory(class std::shared_ptr<class core::select::movemap::MoveMapFactory>) –> 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_rottrial(self: pyrosetta.rosetta.protocols.relax.ClassicRelax, new_pack_rottrial: pyrosetta.rosetta.protocols.minimization_packing.RotamerTrialsMover) → None

C++: protocols::relax::ClassicRelax::set_rottrial(class std::shared_ptr<class protocols::minimization_packing::RotamerTrialsMover>) –> void

set_scorefxn(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: protocols::relax::RelaxProtocolBase::set_scorefxn(class std::shared_ptr<class core::scoring::ScoreFunction>) –> void

set_stage2_cycles(self: pyrosetta.rosetta.protocols.relax.ClassicRelax, cycles2: int) → None

C++: protocols::relax::ClassicRelax::set_stage2_cycles(int) –> void

set_stage2_repack_period(self: pyrosetta.rosetta.protocols.relax.ClassicRelax, repack2: int) → None

C++: protocols::relax::ClassicRelax::set_stage2_repack_period(int) –> void

set_stage3_cycles(self: pyrosetta.rosetta.protocols.relax.ClassicRelax, cycles3: int) → None

C++: protocols::relax::ClassicRelax::set_stage3_cycles(int) –> void

set_start_rep_weight(self: pyrosetta.rosetta.protocols.relax.ClassicRelax, param: float) → None

C++: protocols::relax::ClassicRelax::set_start_rep_weight(double) –> void

set_task_factory(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, task_factory: pyrosetta.rosetta.core.pack.task.TaskFactory) → None

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

set_tolerance(self: pyrosetta.rosetta.protocols.relax.ClassicRelax, new_tolerance: float) → None

C++: protocols::relax::ClassicRelax::set_tolerance(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 &

use_coarse_vdw(self: pyrosetta.rosetta.protocols.relax.ClassicRelax) → None

C++: protocols::relax::ClassicRelax::use_coarse_vdw() –> void

class pyrosetta.rosetta.protocols.relax.ClassicRelaxCreator

Bases: MoverCreator

assign(self: pyrosetta.rosetta.protocols.relax.ClassicRelaxCreator, : pyrosetta.rosetta.protocols.relax.ClassicRelaxCreator) → pyrosetta.rosetta.protocols.relax.ClassicRelaxCreator

C++: protocols::relax::ClassicRelaxCreator::operator=(const class protocols::relax::ClassicRelaxCreator &) –> class protocols::relax::ClassicRelaxCreator &

create_mover(self: pyrosetta.rosetta.protocols.relax.ClassicRelaxCreator) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::relax::ClassicRelaxCreator::create_mover() const –> class std::shared_ptr<class protocols::moves::Mover>

keyname(self: pyrosetta.rosetta.protocols.relax.ClassicRelaxCreator) → str

C++: protocols::relax::ClassicRelaxCreator::keyname() const –> std::string

static mover_name() → str

C++: protocols::relax::ClassicRelaxCreator::mover_name() –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.moves.MoverCreator, xsd: utility::tag::XMLSchemaDefinition) → None

Describe the schema for the Mover that this Creator is responsible for

C++: protocols::moves::MoverCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.protocols.relax.DatabaseRelaxScript

Bases: pybind11_object

Represents a single line of database/sampling/relax_scripts/index.dat

assign(self: pyrosetta.rosetta.protocols.relax.DatabaseRelaxScript, : pyrosetta.rosetta.protocols.relax.DatabaseRelaxScript) → pyrosetta.rosetta.protocols.relax.DatabaseRelaxScript

C++: protocols::relax::DatabaseRelaxScript::operator=(const struct protocols::relax::DatabaseRelaxScript &) –> struct protocols::relax::DatabaseRelaxScript &

property sfxn_specialized

property sfxns_supported

property title

class pyrosetta.rosetta.protocols.relax.EnergyMapContainer

Bases: pybind11_object

A class for storing energy maps, since they’re not created by owning pointer by default.

assign(self: pyrosetta.rosetta.protocols.relax.EnergyMapContainer, : pyrosetta.rosetta.protocols.relax.EnergyMapContainer) → pyrosetta.rosetta.protocols.relax.EnergyMapContainer

C++: protocols::relax::EnergyMapContainer::operator=(const class protocols::relax::EnergyMapContainer &) –> class protocols::relax::EnergyMapContainer &

get_energy_map(self: pyrosetta.rosetta.protocols.relax.EnergyMapContainer) → pyrosetta.rosetta.core.scoring.EMapVector

Access the energy map.

C++: protocols::relax::EnergyMapContainer::get_energy_map() const –> const class core::scoring::EMapVector &

class pyrosetta.rosetta.protocols.relax.FastRelax

Bases: RelaxProtocolBase

apply(self: pyrosetta.rosetta.protocols.relax.FastRelax, pose: pyrosetta.rosetta.core.pose.Pose) → None

Apply the FastRelax. Overloaded apply function from mover base class.

C++: protocols::relax::FastRelax::apply(class core::pose::Pose &) –> void

apply_disulfides(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::relax::RelaxProtocolBase::apply_disulfides(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.relax.FastRelax, : pyrosetta.rosetta.protocols.relax.FastRelax) → pyrosetta.rosetta.protocols.relax.FastRelax

C++: protocols::relax::FastRelax::operator=(const class protocols::relax::FastRelax &) –> class protocols::relax::FastRelax &

batch_apply(*args, **kwargs)

Overloaded function.

1. batch_apply(self: pyrosetta.rosetta.protocols.relax.FastRelax, input_structs: pyrosetta.rosetta.std.vector_std_shared_ptr_core_io_silent_SilentStruct_t) -> None

2. batch_apply(self: pyrosetta.rosetta.protocols.relax.FastRelax, input_structs: pyrosetta.rosetta.std.vector_std_shared_ptr_core_io_silent_SilentStruct_t, input_csts: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet) -> None

3. batch_apply(self: pyrosetta.rosetta.protocols.relax.FastRelax, input_structs: pyrosetta.rosetta.std.vector_std_shared_ptr_core_io_silent_SilentStruct_t, input_csts: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet, decay_rate: float) -> None

Batch Relax, a new even faster way to relax entire batches of structures.

C++: protocols::relax::FastRelax::batch_apply(class std::vector<class std::shared_ptr<class core::io::silent::SilentStruct>, class std::allocator<class std::shared_ptr<class core::io::silent::SilentStruct> > > &, class std::shared_ptr<class core::scoring::constraints::ConstraintSet>, double) –> void

cartesian(*args, **kwargs)

Overloaded function.

1. cartesian(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::cartesian() const –> bool

2. cartesian(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, newval: bool) -> None

Use cartesian (minimization step)

Sets to use the lbfgs_armijo_nonmonotone if true or FR default if false Recommended to set max_iter to 200. Requires scorefunction setup for non-ideal minimization.

C++: protocols::relax::RelaxProtocolBase::cartesian(bool) –> 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.relax.FastRelax) → pyrosetta.rosetta.protocols.moves.Mover

return a fresh instance of this class in an owning pointer

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

static complex_type_generator_for_fast_relax(: utility::tag::XMLSchemaDefinition) → utility::tag::XMLSchemaComplexTypeGenerator

C++: protocols::relax::FastRelax::complex_type_generator_for_fast_relax(class utility::tag::XMLSchemaDefinition &) –> class std::shared_ptr<class utility::tag::XMLSchemaComplexTypeGenerator>

constrain_coords(*args, **kwargs)

Overloaded function.

1. constrain_coords(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::constrain_coords() const –> bool

2. constrain_coords(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, constrain_coords: bool) -> None

C++: protocols::relax::RelaxProtocolBase::constrain_coords(bool) –> void

constrain_relax_segments(*args, **kwargs)

Overloaded function.

1. constrain_relax_segments(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::constrain_relax_segments() const –> bool

2. constrain_relax_segments(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, constrain_relax_segments: bool) -> None

C++: protocols::relax::RelaxProtocolBase::constrain_relax_segments(bool) –> void

constrain_relax_to_native_coords(*args, **kwargs)

Overloaded function.

1. constrain_relax_to_native_coords(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::constrain_relax_to_native_coords() const –> bool

2. constrain_relax_to_native_coords(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, constrain_relax_to_native_coords: bool) -> None

C++: protocols::relax::RelaxProtocolBase::constrain_relax_to_native_coords(bool) –> void

constrain_relax_to_start_coords(*args, **kwargs)

Overloaded function.

1. constrain_relax_to_start_coords(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::constrain_relax_to_start_coords() const –> bool

2. constrain_relax_to_start_coords(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, constrain_relax_to_start_coords: bool) -> None

C++: protocols::relax::RelaxProtocolBase::constrain_relax_to_start_coords(bool) –> void

coord_constrain_sidechains(*args, **kwargs)

Overloaded function.

1. coord_constrain_sidechains(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::coord_constrain_sidechains() const –> bool

2. coord_constrain_sidechains(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, coord_constrain_sidechains: bool) -> None

C++: protocols::relax::RelaxProtocolBase::coord_constrain_sidechains(bool) –> void

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>

default_repeats(self: pyrosetta.rosetta.protocols.relax.FastRelax) → int

Return the number of repeats

C++: protocols::relax::FastRelax::default_repeats() const –> unsigned long

dry_run(*args, **kwargs)

Overloaded function.

1. dry_run(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::dry_run() const –> bool

2. dry_run(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, setting: bool) -> None

C++: protocols::relax::RelaxProtocolBase::dry_run(bool) –> void

dualspace(*args, **kwargs)

Overloaded function.

1. dualspace(self: pyrosetta.rosetta.protocols.relax.FastRelax, val: bool) -> None

Use the dualspace (Dihedral + Cartesian) relax protocol (Default false)

Sets to use the lbfgs_armijo_nonmonotone if true or FR default if false Recommended to set max_iter to 200. Recommended to set minimize_bond_angles to true as well. Requires scorefunction setup for non-ideal minimization.

C++: protocols::relax::FastRelax::dualspace(bool) –> void

2. dualspace(self: pyrosetta.rosetta.protocols.relax.FastRelax) -> bool

C++: protocols::relax::FastRelax::dualspace() –> bool

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

C++: protocols::relax::RelaxProtocolBase::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_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_movemap(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) → pyrosetta.rosetta.core.kinematics.MoveMap

C++: protocols::relax::RelaxProtocolBase::get_movemap() –> class std::shared_ptr<class core::kinematics::MoveMap>

get_name(self: pyrosetta.rosetta.protocols.relax.FastRelax) → str

Return the name of this mover.

C++: protocols::relax::FastRelax::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_scorefxn(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) → pyrosetta.rosetta.core.scoring.ScoreFunction

C++: protocols::relax::RelaxProtocolBase::get_scorefxn() const –> const class std::shared_ptr<const class core::scoring::ScoreFunction>

get_self_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.protocols.moves.Mover

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

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.weak_ptr_protocols_moves_Mover_t

C++: protocols::moves::Mover::get_self_weak_ptr() –> class std::weak_ptr<class protocols::moves::Mover>

get_task_factory(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) → pyrosetta.rosetta.core.pack.task.TaskFactory

C++: protocols::relax::RelaxProtocolBase::get_task_factory() const –> const class std::shared_ptr<class core::pack::task::TaskFactory> &

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

max_iter(*args, **kwargs)

Overloaded function.

1. max_iter(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> int

C++: protocols::relax::RelaxProtocolBase::max_iter() const –> unsigned long

2. max_iter(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, max_iter: int) -> None

C++: protocols::relax::RelaxProtocolBase::max_iter(unsigned long) –> void

min_type(*args, **kwargs)

Overloaded function.

1. min_type(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> str

C++: protocols::relax::RelaxProtocolBase::min_type() const –> std::string

2. min_type(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, min_type: str) -> None

C++: protocols::relax::RelaxProtocolBase::min_type(std::string) –> void

minimize_bond_angles(*args, **kwargs)

Overloaded function.

1. minimize_bond_angles(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::minimize_bond_angles() const –> bool

2. minimize_bond_angles(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, minimize_bond_angles: bool) -> None

C++: protocols::relax::RelaxProtocolBase::minimize_bond_angles(bool) –> void

minimize_bond_lengths(*args, **kwargs)

Overloaded function.

1. minimize_bond_lengths(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::minimize_bond_lengths() const –> bool

2. minimize_bond_lengths(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, minimize_bond_lengths: bool) -> None

C++: protocols::relax::RelaxProtocolBase::minimize_bond_lengths(bool) –> void

movemap_disables_packing_of_fixed_chi_positions(self: pyrosetta.rosetta.protocols.relax.FastRelax) → bool

Get whether the MoveMap can automatically disable packing of positions

where sidechain minimization is prohibited. Default false.

C++: protocols::relax::FastRelax::movemap_disables_packing_of_fixed_chi_positions() const –> bool

static mover_name() → str

Return the name of this mover.

C++: protocols::relax::FastRelax::mover_name() –> std::string

static name() → str

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

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

Parses the FastRelaxTags

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

provide_citation_info(self: pyrosetta.rosetta.protocols.relax.FastRelax, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None

Provide the citation.

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

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None

C++: protocols::relax::FastRelax::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

ramp_down_constraints(*args, **kwargs)

Overloaded function.

1. ramp_down_constraints(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::ramp_down_constraints() const –> bool

2. ramp_down_constraints(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, ramp_down_constraints: bool) -> None

C++: protocols::relax::RelaxProtocolBase::ramp_down_constraints(bool) –> void

static register_options() → None

C++: protocols::relax::RelaxProtocolBase::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_default_coordinate_settings(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) → None

C++: protocols::relax::RelaxProtocolBase::set_default_coordinate_settings() –> void

set_default_minimization_settings(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) → None

C++: protocols::relax::RelaxProtocolBase::set_default_minimization_settings() –> void

set_default_movemap(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) → None

C++: protocols::relax::RelaxProtocolBase::set_default_movemap() –> void

set_defaults(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) → None

C++: protocols::relax::RelaxProtocolBase::set_defaults() –> void

set_enable_design(self: pyrosetta.rosetta.protocols.relax.FastRelax, val: bool) → None

sets the enable_design option.

Note - (Only used by ParseMyTag! Class will respect the passed TF otherwise, as it should.)

C++: protocols::relax::FastRelax::set_enable_design(const bool) –> void

set_force_nonideal(self: pyrosetta.rosetta.protocols.relax.FastRelax, val: bool) → None

Force us to batchrelax with nonideal geometry (using additional memory)

C++: protocols::relax::FastRelax::set_force_nonideal(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_movemap(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, movemap: pyrosetta.rosetta.core.kinematics.MoveMap) → None

C++: protocols::relax::RelaxProtocolBase::set_movemap(class std::shared_ptr<class core::kinematics::MoveMap>) –> void

set_movemap_disables_packing_of_fixed_chi_positions(self: pyrosetta.rosetta.protocols.relax.FastRelax, setting: bool) → None

Set whether the MoveMap can automatically disable packing of positions

where sidechain minimization is prohibited. Default false.

C++: protocols::relax::FastRelax::set_movemap_disables_packing_of_fixed_chi_positions(const bool) –> void

set_movemap_factory(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, mm_factory: pyrosetta.rosetta.core.select.movemap.MoveMapFactory) → None

C++: protocols::relax::RelaxProtocolBase::set_movemap_factory(class std::shared_ptr<class core::select::movemap::MoveMapFactory>) –> 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_scorefxn(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: protocols::relax::RelaxProtocolBase::set_scorefxn(class std::shared_ptr<class core::scoring::ScoreFunction>) –> void

set_script_from_lines(self: pyrosetta.rosetta.protocols.relax.FastRelax, filelines: pyrosetta.rosetta.std.vector_std_string) → None

replace schedule by providing lines of commands explicitly

C++: protocols::relax::FastRelax::set_script_from_lines(const class std::vector<std::string, class std::allocator<std::string > > &) –> void

set_script_to_batchrelax_default(*args, **kwargs)

Overloaded function.

1. set_script_to_batchrelax_default(self: pyrosetta.rosetta.protocols.relax.FastRelax) -> None

2. set_script_to_batchrelax_default(self: pyrosetta.rosetta.protocols.relax.FastRelax, standard_repeats: int) -> None

Override the stored script with the default script for batchrelax

Ignores ‘-default_repeat’ value

C++: protocols::relax::FastRelax::set_script_to_batchrelax_default(unsigned long) –> void

set_task_factory(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, task_factory: pyrosetta.rosetta.core.pack.task.TaskFactory) → None

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

set_to_default(self: pyrosetta.rosetta.protocols.relax.FastRelax) → None

Initializes class using option system. This is called by the constructors

C++: protocols::relax::FastRelax::set_to_default() –> 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.relax.FastRelaxCreator

Bases: MoverCreator

assign(self: pyrosetta.rosetta.protocols.relax.FastRelaxCreator, : pyrosetta.rosetta.protocols.relax.FastRelaxCreator) → pyrosetta.rosetta.protocols.relax.FastRelaxCreator

C++: protocols::relax::FastRelaxCreator::operator=(const class protocols::relax::FastRelaxCreator &) –> class protocols::relax::FastRelaxCreator &

create_mover(self: pyrosetta.rosetta.protocols.relax.FastRelaxCreator) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::relax::FastRelaxCreator::create_mover() const –> class std::shared_ptr<class protocols::moves::Mover>

keyname(self: pyrosetta.rosetta.protocols.relax.FastRelaxCreator) → str

C++: protocols::relax::FastRelaxCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.relax.FastRelaxCreator, xsd: utility::tag::XMLSchemaDefinition) → None

C++: protocols::relax::FastRelaxCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.protocols.relax.LocalRelax

Bases: Mover

apply(self: pyrosetta.rosetta.protocols.relax.LocalRelax, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::relax::LocalRelax::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.relax.LocalRelax, : pyrosetta.rosetta.protocols.relax.LocalRelax) → pyrosetta.rosetta.protocols.relax.LocalRelax

C++: protocols::relax::LocalRelax::operator=(const class protocols::relax::LocalRelax &) –> class protocols::relax::LocalRelax &

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

return a fresh instance of this class in an owning pointer

C++: protocols::relax::LocalRelax::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_K(self: pyrosetta.rosetta.protocols.relax.LocalRelax) → float

C++: protocols::relax::LocalRelax::get_K() const –> double

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_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_max_iter(self: pyrosetta.rosetta.protocols.relax.LocalRelax) → float

C++: protocols::relax::LocalRelax::get_max_iter() const –> double

get_min_sfxn(self: pyrosetta.rosetta.protocols.relax.LocalRelax) → pyrosetta.rosetta.core.scoring.ScoreFunction

C++: protocols::relax::LocalRelax::get_min_sfxn() const –> class std::shared_ptr<class core::scoring::ScoreFunction>

get_name(self: pyrosetta.rosetta.protocols.relax.LocalRelax) → str

C++: protocols::relax::LocalRelax::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_ncyc(self: pyrosetta.rosetta.protocols.relax.LocalRelax) → int

C++: protocols::relax::LocalRelax::get_ncyc() const –> unsigned long

get_neighbor_graph(self: pyrosetta.rosetta.protocols.relax.LocalRelax, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.utility.vector1_utility_vector1_bool_std_allocator_bool_t

get matrix of interacting residues

C++: protocols::relax::LocalRelax::get_neighbor_graph(const class core::pose::Pose &) –> class utility::vector1<class utility::vector1<bool, class std::allocator<bool> >, class std::allocator<class utility::vector1<bool, class std::allocator<bool> > > >

get_nexp(self: pyrosetta.rosetta.protocols.relax.LocalRelax) → int

C++: protocols::relax::LocalRelax::get_nexp() const –> unsigned long

get_pack_sfxn(self: pyrosetta.rosetta.protocols.relax.LocalRelax) → pyrosetta.rosetta.core.scoring.ScoreFunction

C++: protocols::relax::LocalRelax::get_pack_sfxn() const –> class std::shared_ptr<class core::scoring::ScoreFunction>

get_self_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.protocols.moves.Mover

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

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.weak_ptr_protocols_moves_Mover_t

C++: protocols::moves::Mover::get_self_weak_ptr() –> class std::weak_ptr<class protocols::moves::Mover>

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

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

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

C++: protocols::relax::LocalRelax::mover_name() –> std::string

static name() → str

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

optimization_loop(self: pyrosetta.rosetta.protocols.relax.LocalRelax, pose: pyrosetta.rosetta.core.pose.Pose, ptask: pyrosetta.rosetta.core.pack.task.PackerTask, mm: pyrosetta.rosetta.core.kinematics.MoveMap, : float, : float) → None

one cycle of local optimization

C++: protocols::relax::LocalRelax::optimization_loop(class core::pose::Pose &, class std::shared_ptr<class core::pack::task::PackerTask>, class std::shared_ptr<class core::kinematics::MoveMap>, double, double) –> void

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

RS integration

C++: protocols::relax::LocalRelax::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

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None

C++: protocols::relax::LocalRelax::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> 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_K(self: pyrosetta.rosetta.protocols.relax.LocalRelax, K: float) → None

C++: protocols::relax::LocalRelax::set_K(const double) –> 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_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_max_iter(self: pyrosetta.rosetta.protocols.relax.LocalRelax, max_iter: float) → None

C++: protocols::relax::LocalRelax::set_max_iter(const double) –> void

set_min_sfxn(self: pyrosetta.rosetta.protocols.relax.LocalRelax, sf: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: protocols::relax::LocalRelax::set_min_sfxn(const class std::shared_ptr<class core::scoring::ScoreFunction> &) –> 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_ncyc(self: pyrosetta.rosetta.protocols.relax.LocalRelax, ncyc: int) → None

C++: protocols::relax::LocalRelax::set_ncyc(const unsigned long) –> void

set_nexp(self: pyrosetta.rosetta.protocols.relax.LocalRelax, nexp: int) → None

C++: protocols::relax::LocalRelax::set_nexp(const unsigned long) –> void

set_pack_sfxn(self: pyrosetta.rosetta.protocols.relax.LocalRelax, sf: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: protocols::relax::LocalRelax::set_pack_sfxn(const class std::shared_ptr<class core::scoring::ScoreFunction> &) –> void

set_sfxn(self: pyrosetta.rosetta.protocols.relax.LocalRelax, sf: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: protocols::relax::LocalRelax::set_sfxn(const class std::shared_ptr<class core::scoring::ScoreFunction> &) –> 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.relax.LocalRelaxCreator

Bases: MoverCreator

assign(self: pyrosetta.rosetta.protocols.relax.LocalRelaxCreator, : pyrosetta.rosetta.protocols.relax.LocalRelaxCreator) → pyrosetta.rosetta.protocols.relax.LocalRelaxCreator

C++: protocols::relax::LocalRelaxCreator::operator=(const class protocols::relax::LocalRelaxCreator &) –> class protocols::relax::LocalRelaxCreator &

create_mover(self: pyrosetta.rosetta.protocols.relax.LocalRelaxCreator) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::relax::LocalRelaxCreator::create_mover() const –> class std::shared_ptr<class protocols::moves::Mover>

keyname(self: pyrosetta.rosetta.protocols.relax.LocalRelaxCreator) → str

C++: protocols::relax::LocalRelaxCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.relax.LocalRelaxCreator, xsd: utility::tag::XMLSchemaDefinition) → None

C++: protocols::relax::LocalRelaxCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.protocols.relax.MiniRelax

Bases: RelaxProtocolBase

apply(self: pyrosetta.rosetta.protocols.relax.MiniRelax, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::relax::MiniRelax::apply(class core::pose::Pose &) –> void

apply_disulfides(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::relax::RelaxProtocolBase::apply_disulfides(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.relax.MiniRelax, : pyrosetta.rosetta.protocols.relax.MiniRelax) → pyrosetta.rosetta.protocols.relax.MiniRelax

C++: protocols::relax::MiniRelax::operator=(const class protocols::relax::MiniRelax &) –> class protocols::relax::MiniRelax &

cartesian(*args, **kwargs)

Overloaded function.

1. cartesian(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::cartesian() const –> bool

2. cartesian(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, newval: bool) -> None

Use cartesian (minimization step)

Sets to use the lbfgs_armijo_nonmonotone if true or FR default if false Recommended to set max_iter to 200. Requires scorefunction setup for non-ideal minimization.

C++: protocols::relax::RelaxProtocolBase::cartesian(bool) –> 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.relax.MiniRelax) → pyrosetta.rosetta.protocols.moves.Mover

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

constrain_coords(*args, **kwargs)

Overloaded function.

1. constrain_coords(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::constrain_coords() const –> bool

2. constrain_coords(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, constrain_coords: bool) -> None

C++: protocols::relax::RelaxProtocolBase::constrain_coords(bool) –> void

constrain_relax_segments(*args, **kwargs)

Overloaded function.

1. constrain_relax_segments(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::constrain_relax_segments() const –> bool

2. constrain_relax_segments(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, constrain_relax_segments: bool) -> None

C++: protocols::relax::RelaxProtocolBase::constrain_relax_segments(bool) –> void

constrain_relax_to_native_coords(*args, **kwargs)

Overloaded function.

1. constrain_relax_to_native_coords(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::constrain_relax_to_native_coords() const –> bool

2. constrain_relax_to_native_coords(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, constrain_relax_to_native_coords: bool) -> None

C++: protocols::relax::RelaxProtocolBase::constrain_relax_to_native_coords(bool) –> void

constrain_relax_to_start_coords(*args, **kwargs)

Overloaded function.

1. constrain_relax_to_start_coords(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::constrain_relax_to_start_coords() const –> bool

2. constrain_relax_to_start_coords(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, constrain_relax_to_start_coords: bool) -> None

C++: protocols::relax::RelaxProtocolBase::constrain_relax_to_start_coords(bool) –> void

coord_constrain_sidechains(*args, **kwargs)

Overloaded function.

1. coord_constrain_sidechains(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::coord_constrain_sidechains() const –> bool

2. coord_constrain_sidechains(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, coord_constrain_sidechains: bool) -> None

C++: protocols::relax::RelaxProtocolBase::coord_constrain_sidechains(bool) –> void

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>

dry_run(*args, **kwargs)

Overloaded function.

1. dry_run(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::dry_run() const –> bool

2. dry_run(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, setting: bool) -> None

C++: protocols::relax::RelaxProtocolBase::dry_run(bool) –> void

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

C++: protocols::relax::RelaxProtocolBase::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_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_movemap(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) → pyrosetta.rosetta.core.kinematics.MoveMap

C++: protocols::relax::RelaxProtocolBase::get_movemap() –> class std::shared_ptr<class core::kinematics::MoveMap>

get_name(self: pyrosetta.rosetta.protocols.relax.MiniRelax) → str

C++: protocols::relax::MiniRelax::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_scorefxn(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) → pyrosetta.rosetta.core.scoring.ScoreFunction

C++: protocols::relax::RelaxProtocolBase::get_scorefxn() const –> const class std::shared_ptr<const class core::scoring::ScoreFunction>

get_self_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.protocols.moves.Mover

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

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.weak_ptr_protocols_moves_Mover_t

C++: protocols::moves::Mover::get_self_weak_ptr() –> class std::weak_ptr<class protocols::moves::Mover>

get_task_factory(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) → pyrosetta.rosetta.core.pack.task.TaskFactory

C++: protocols::relax::RelaxProtocolBase::get_task_factory() const –> const class std::shared_ptr<class core::pack::task::TaskFactory> &

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

max_iter(*args, **kwargs)

Overloaded function.

1. max_iter(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> int

C++: protocols::relax::RelaxProtocolBase::max_iter() const –> unsigned long

2. max_iter(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, max_iter: int) -> None

C++: protocols::relax::RelaxProtocolBase::max_iter(unsigned long) –> void

min_type(*args, **kwargs)

Overloaded function.

1. min_type(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> str

C++: protocols::relax::RelaxProtocolBase::min_type() const –> std::string

2. min_type(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, min_type: str) -> None

C++: protocols::relax::RelaxProtocolBase::min_type(std::string) –> void

minimize_bond_angles(*args, **kwargs)

Overloaded function.

1. minimize_bond_angles(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::minimize_bond_angles() const –> bool

2. minimize_bond_angles(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, minimize_bond_angles: bool) -> None

C++: protocols::relax::RelaxProtocolBase::minimize_bond_angles(bool) –> void

minimize_bond_lengths(*args, **kwargs)

Overloaded function.

1. minimize_bond_lengths(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::minimize_bond_lengths() const –> bool

2. minimize_bond_lengths(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, minimize_bond_lengths: bool) -> None

C++: protocols::relax::RelaxProtocolBase::minimize_bond_lengths(bool) –> void

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.relax.RelaxProtocolBase, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None

Provide the citation.

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

ramp_down_constraints(*args, **kwargs)

Overloaded function.

1. ramp_down_constraints(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::ramp_down_constraints() const –> bool

2. ramp_down_constraints(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, ramp_down_constraints: bool) -> None

C++: protocols::relax::RelaxProtocolBase::ramp_down_constraints(bool) –> void

static register_options() → None

C++: protocols::relax::RelaxProtocolBase::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_default_coordinate_settings(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) → None

C++: protocols::relax::RelaxProtocolBase::set_default_coordinate_settings() –> void

set_default_minimization_settings(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) → None

C++: protocols::relax::RelaxProtocolBase::set_default_minimization_settings() –> void

set_default_movemap(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) → None

C++: protocols::relax::RelaxProtocolBase::set_default_movemap() –> void

set_defaults(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) → None

C++: protocols::relax::RelaxProtocolBase::set_defaults() –> 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_movemap(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, movemap: pyrosetta.rosetta.core.kinematics.MoveMap) → None

C++: protocols::relax::RelaxProtocolBase::set_movemap(class std::shared_ptr<class core::kinematics::MoveMap>) –> void

set_movemap_factory(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, mm_factory: pyrosetta.rosetta.core.select.movemap.MoveMapFactory) → None

C++: protocols::relax::RelaxProtocolBase::set_movemap_factory(class std::shared_ptr<class core::select::movemap::MoveMapFactory>) –> 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_scorefxn(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: protocols::relax::RelaxProtocolBase::set_scorefxn(class std::shared_ptr<class core::scoring::ScoreFunction>) –> void

set_task_factory(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, task_factory: pyrosetta.rosetta.core.pack.task.TaskFactory) → None

C++: protocols::relax::RelaxProtocolBase::set_task_factory(class std::shared_ptr<class core::pack::task::TaskFactory>) –> 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.relax.RangeRelaxMover

Bases: Mover

add_membrane_again(self: pyrosetta.rosetta.protocols.relax.RangeRelaxMover, yesno: bool) → None

Run AddMembraneMover before?

If you want to keep your anchor point for MEM, then pick no

This is only needed for the native, not the pose itself

C++: protocols::relax::RangeRelaxMover::add_membrane_again(bool) –> void

apply(self: pyrosetta.rosetta.protocols.relax.RangeRelaxMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

Run RangeRelax

C++: protocols::relax::RangeRelaxMover::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.relax.RangeRelaxMover, src: pyrosetta.rosetta.protocols.relax.RangeRelaxMover) → pyrosetta.rosetta.protocols.relax.RangeRelaxMover

Assignment Operator

C++: protocols::relax::RangeRelaxMover::operator=(const class protocols::relax::RangeRelaxMover &) –> class protocols::relax::RangeRelaxMover &

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_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.relax.RangeRelaxMover) → str

Get the name of this Mover (RangeRelaxMover)

C++: protocols::relax::RangeRelaxMover::get_name() const –> std::string

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

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

get_self_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.protocols.moves.Mover

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

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.weak_ptr_protocols_moves_Mover_t

C++: protocols::moves::Mover::get_self_weak_ptr() –> class std::weak_ptr<class protocols::moves::Mover>

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

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

idealize(self: pyrosetta.rosetta.protocols.relax.RangeRelaxMover, yesno: bool) → None

Idealize pose after run?

Might lead to better decoy but takes longer

C++: protocols::relax::RangeRelaxMover::idealize(bool) –> void

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

optimize_membrane(self: pyrosetta.rosetta.protocols.relax.RangeRelaxMover, yesno: bool) → None

Optimize membrane

C++: protocols::relax::RangeRelaxMover::optimize_membrane(bool) –> void

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

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_angle_max(self: pyrosetta.rosetta.protocols.relax.RangeRelaxMover, angle_max: float) → None

Set maximum dihedral angle perturbation

C++: protocols::relax::RangeRelaxMover::set_angle_max(double) –> 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_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(self: pyrosetta.rosetta.protocols.relax.RangeRelaxMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

Set native

C++: protocols::relax::RangeRelaxMover::set_native(class std::shared_ptr<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_nmoves(self: pyrosetta.rosetta.protocols.relax.RangeRelaxMover, nmoves: str) → None

Set number of moves, can be “nres” or a number

C++: protocols::relax::RangeRelaxMover::set_nmoves(std::string) –> void

set_scorefunction(self: pyrosetta.rosetta.protocols.relax.RangeRelaxMover, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

Use scorefunction

C++: protocols::relax::RangeRelaxMover::set_scorefunction(class std::shared_ptr<class core::scoring::ScoreFunction>) –> 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.relax.RelaxProtocolBase

Bases: Mover

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

Main Method

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

apply_disulfides(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::relax::RelaxProtocolBase::apply_disulfides(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, : pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) → pyrosetta.rosetta.protocols.relax.RelaxProtocolBase

C++: protocols::relax::RelaxProtocolBase::operator=(const class protocols::relax::RelaxProtocolBase &) –> class protocols::relax::RelaxProtocolBase &

cartesian(*args, **kwargs)

Overloaded function.

1. cartesian(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::cartesian() const –> bool

2. cartesian(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, newval: bool) -> None

Use cartesian (minimization step)

Sets to use the lbfgs_armijo_nonmonotone if true or FR default if false Recommended to set max_iter to 200. Requires scorefunction setup for non-ideal minimization.

C++: protocols::relax::RelaxProtocolBase::cartesian(bool) –> 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.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>

constrain_coords(*args, **kwargs)

Overloaded function.

1. constrain_coords(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::constrain_coords() const –> bool

2. constrain_coords(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, constrain_coords: bool) -> None

C++: protocols::relax::RelaxProtocolBase::constrain_coords(bool) –> void

constrain_relax_segments(*args, **kwargs)

Overloaded function.

1. constrain_relax_segments(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::constrain_relax_segments() const –> bool

2. constrain_relax_segments(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, constrain_relax_segments: bool) -> None

C++: protocols::relax::RelaxProtocolBase::constrain_relax_segments(bool) –> void

constrain_relax_to_native_coords(*args, **kwargs)

Overloaded function.

1. constrain_relax_to_native_coords(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::constrain_relax_to_native_coords() const –> bool

2. constrain_relax_to_native_coords(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, constrain_relax_to_native_coords: bool) -> None

C++: protocols::relax::RelaxProtocolBase::constrain_relax_to_native_coords(bool) –> void

constrain_relax_to_start_coords(*args, **kwargs)

Overloaded function.

1. constrain_relax_to_start_coords(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::constrain_relax_to_start_coords() const –> bool

2. constrain_relax_to_start_coords(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, constrain_relax_to_start_coords: bool) -> None

C++: protocols::relax::RelaxProtocolBase::constrain_relax_to_start_coords(bool) –> void

coord_constrain_sidechains(*args, **kwargs)

Overloaded function.

1. coord_constrain_sidechains(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::coord_constrain_sidechains() const –> bool

2. coord_constrain_sidechains(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, coord_constrain_sidechains: bool) -> None

C++: protocols::relax::RelaxProtocolBase::coord_constrain_sidechains(bool) –> void

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>

dry_run(*args, **kwargs)

Overloaded function.

1. dry_run(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::dry_run() const –> bool

2. dry_run(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, setting: bool) -> None

C++: protocols::relax::RelaxProtocolBase::dry_run(bool) –> void

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

C++: protocols::relax::RelaxProtocolBase::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_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_movemap(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) → pyrosetta.rosetta.core.kinematics.MoveMap

C++: protocols::relax::RelaxProtocolBase::get_movemap() –> class std::shared_ptr<class core::kinematics::MoveMap>

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

Each derived class must specify its name. The class name.

C++: protocols::moves::Mover::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_scorefxn(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) → pyrosetta.rosetta.core.scoring.ScoreFunction

C++: protocols::relax::RelaxProtocolBase::get_scorefxn() const –> const class std::shared_ptr<const class core::scoring::ScoreFunction>

get_self_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.protocols.moves.Mover

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

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.weak_ptr_protocols_moves_Mover_t

C++: protocols::moves::Mover::get_self_weak_ptr() –> class std::weak_ptr<class protocols::moves::Mover>

get_task_factory(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) → pyrosetta.rosetta.core.pack.task.TaskFactory

C++: protocols::relax::RelaxProtocolBase::get_task_factory() const –> const class std::shared_ptr<class core::pack::task::TaskFactory> &

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

max_iter(*args, **kwargs)

Overloaded function.

1. max_iter(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> int

C++: protocols::relax::RelaxProtocolBase::max_iter() const –> unsigned long

2. max_iter(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, max_iter: int) -> None

C++: protocols::relax::RelaxProtocolBase::max_iter(unsigned long) –> void

min_type(*args, **kwargs)

Overloaded function.

1. min_type(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> str

C++: protocols::relax::RelaxProtocolBase::min_type() const –> std::string

2. min_type(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, min_type: str) -> None

C++: protocols::relax::RelaxProtocolBase::min_type(std::string) –> void

minimize_bond_angles(*args, **kwargs)

Overloaded function.

1. minimize_bond_angles(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::minimize_bond_angles() const –> bool

2. minimize_bond_angles(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, minimize_bond_angles: bool) -> None

C++: protocols::relax::RelaxProtocolBase::minimize_bond_angles(bool) –> void

minimize_bond_lengths(*args, **kwargs)

Overloaded function.

1. minimize_bond_lengths(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::minimize_bond_lengths() const –> bool

2. minimize_bond_lengths(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, minimize_bond_lengths: bool) -> None

C++: protocols::relax::RelaxProtocolBase::minimize_bond_lengths(bool) –> void

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.relax.RelaxProtocolBase, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None

Provide the citation.

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

ramp_down_constraints(*args, **kwargs)

Overloaded function.

1. ramp_down_constraints(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::ramp_down_constraints() const –> bool

2. ramp_down_constraints(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, ramp_down_constraints: bool) -> None

C++: protocols::relax::RelaxProtocolBase::ramp_down_constraints(bool) –> void

static register_options() → None

C++: protocols::relax::RelaxProtocolBase::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_default_coordinate_settings(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) → None

C++: protocols::relax::RelaxProtocolBase::set_default_coordinate_settings() –> void

set_default_minimization_settings(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) → None

C++: protocols::relax::RelaxProtocolBase::set_default_minimization_settings() –> void

set_default_movemap(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) → None

C++: protocols::relax::RelaxProtocolBase::set_default_movemap() –> void

set_defaults(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) → None

C++: protocols::relax::RelaxProtocolBase::set_defaults() –> 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_movemap(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, movemap: pyrosetta.rosetta.core.kinematics.MoveMap) → None

C++: protocols::relax::RelaxProtocolBase::set_movemap(class std::shared_ptr<class core::kinematics::MoveMap>) –> void

set_movemap_factory(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, mm_factory: pyrosetta.rosetta.core.select.movemap.MoveMapFactory) → None

C++: protocols::relax::RelaxProtocolBase::set_movemap_factory(class std::shared_ptr<class core::select::movemap::MoveMapFactory>) –> 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_scorefxn(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: protocols::relax::RelaxProtocolBase::set_scorefxn(class std::shared_ptr<class core::scoring::ScoreFunction>) –> void

set_task_factory(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, task_factory: pyrosetta.rosetta.core.pack.task.TaskFactory) → None

C++: protocols::relax::RelaxProtocolBase::set_task_factory(class std::shared_ptr<class core::pack::task::TaskFactory>) –> 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.relax.RelaxScriptCommand

Bases: pybind11_object

assign(self: pyrosetta.rosetta.protocols.relax.RelaxScriptCommand, : pyrosetta.rosetta.protocols.relax.RelaxScriptCommand) → pyrosetta.rosetta.protocols.relax.RelaxScriptCommand

C++: protocols::relax::RelaxScriptCommand::operator=(const struct protocols::relax::RelaxScriptCommand &) –> struct protocols::relax::RelaxScriptCommand &

property command

property nparams

property param1

property param2

property param3

property param4

property params_vec

class pyrosetta.rosetta.protocols.relax.RelaxScriptFileContents

Bases: pybind11_object

A simple wrapper class to store a vector of file contents.

Used because owning pointers to vectors behave in a wonky way.

Vikram K. Mulligan (vmulligan.org)

assign(self: pyrosetta.rosetta.protocols.relax.RelaxScriptFileContents, : pyrosetta.rosetta.protocols.relax.RelaxScriptFileContents) → pyrosetta.rosetta.protocols.relax.RelaxScriptFileContents

C++: protocols::relax::RelaxScriptFileContents::operator=(const class protocols::relax::RelaxScriptFileContents &) –> class protocols::relax::RelaxScriptFileContents &

clone(self: pyrosetta.rosetta.protocols.relax.RelaxScriptFileContents) → pyrosetta.rosetta.protocols.relax.RelaxScriptFileContents

Clone function: make a copy of this object and return an owning pointer to the copy.

C++: protocols::relax::RelaxScriptFileContents::clone() const –> class std::shared_ptr<class protocols::relax::RelaxScriptFileContents>

get_file_lines(self: pyrosetta.rosetta.protocols.relax.RelaxScriptFileContents) → pyrosetta.rosetta.utility.vector1_std_string

C++: protocols::relax::RelaxScriptFileContents::get_file_lines() const –> const class utility::vector1<std::string, class std::allocator<std::string > > &

class pyrosetta.rosetta.protocols.relax.RelaxScriptManager

Bases: SingletonBase_protocols_relax_RelaxScriptManager_t

A singleton class for managing relax scripts, to ensure that they are loaded once and only once from disk.

Vikram K. Mulligan (vmulligan.org)

static get_instance() → protocols::relax::RelaxScriptManager

C++: utility::SingletonBase<protocols::relax::RelaxScriptManager>::get_instance() –> class protocols::relax::RelaxScriptManager *

get_relax_script(self: pyrosetta.rosetta.protocols.relax.RelaxScriptManager, filename: str, mover_sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, dualspace: bool) → pyrosetta.rosetta.protocols.relax.RelaxScriptFileContents

Get a relax script. Load it from disk if it has not already been loaded.

Threadsafe and lazily loaded. Requires the FastRelax or FastDesign mover’s scorefunction to be provided.

C++: protocols::relax::RelaxScriptManager::get_relax_script(const std::string &, const class std::shared_ptr<const class core::scoring::ScoreFunction> &, const bool) const –> const class protocols::relax::RelaxScriptFileContents &

pyrosetta.rosetta.protocols.relax.Relax_main(: bool) → int

C++: protocols::relax::Relax_main(bool) –> int

class pyrosetta.rosetta.protocols.relax.RepeatProteinRelax

Bases: RelaxProtocolBase

add_residue_labels_back(self: pyrosetta.rosetta.protocols.relax.RepeatProteinRelax, pose: pyrosetta.rosetta.core.pose.Pose, res_label_map: pyrosetta.rosetta.std.map_unsigned_long_utility_vector1_std_string_std_allocator_std_string_t_std_allocator_std_pair_const_unsigned_long_utility_vector1_std_string_std_allocator_std_string_t, symmetry_resid_offset: int) → None

C++: protocols::relax::RepeatProteinRelax::add_residue_labels_back(class core::pose::Pose &, class std::map<unsigned long, class utility::vector1<std::string, class std::allocator<std::string > >, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class utility::vector1<std::string, class std::allocator<std::string > > > > >, int) –> void

apply(self: pyrosetta.rosetta.protocols.relax.RepeatProteinRelax, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::relax::RepeatProteinRelax::apply(class core::pose::Pose &) –> void

apply_disulfides(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::relax::RelaxProtocolBase::apply_disulfides(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.relax.RepeatProteinRelax, : pyrosetta.rosetta.protocols.relax.RepeatProteinRelax) → pyrosetta.rosetta.protocols.relax.RepeatProteinRelax

C++: protocols::relax::RepeatProteinRelax::operator=(const class protocols::relax::RepeatProteinRelax &) –> class protocols::relax::RepeatProteinRelax &

cartesian(*args, **kwargs)

Overloaded function.

1. cartesian(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::cartesian() const –> bool

2. cartesian(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, newval: bool) -> None

Use cartesian (minimization step)

Sets to use the lbfgs_armijo_nonmonotone if true or FR default if false Recommended to set max_iter to 200. Requires scorefunction setup for non-ideal minimization.

C++: protocols::relax::RelaxProtocolBase::cartesian(bool) –> 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.relax.RepeatProteinRelax) → pyrosetta.rosetta.protocols.moves.Mover

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

constrain_coords(*args, **kwargs)

Overloaded function.

1. constrain_coords(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::constrain_coords() const –> bool

2. constrain_coords(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, constrain_coords: bool) -> None

C++: protocols::relax::RelaxProtocolBase::constrain_coords(bool) –> void

constrain_relax_segments(*args, **kwargs)

Overloaded function.

1. constrain_relax_segments(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::constrain_relax_segments() const –> bool

2. constrain_relax_segments(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, constrain_relax_segments: bool) -> None

C++: protocols::relax::RelaxProtocolBase::constrain_relax_segments(bool) –> void

constrain_relax_to_native_coords(*args, **kwargs)

Overloaded function.

1. constrain_relax_to_native_coords(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::constrain_relax_to_native_coords() const –> bool

2. constrain_relax_to_native_coords(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, constrain_relax_to_native_coords: bool) -> None

C++: protocols::relax::RelaxProtocolBase::constrain_relax_to_native_coords(bool) –> void

constrain_relax_to_start_coords(*args, **kwargs)

Overloaded function.

1. constrain_relax_to_start_coords(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::constrain_relax_to_start_coords() const –> bool

2. constrain_relax_to_start_coords(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, constrain_relax_to_start_coords: bool) -> None

C++: protocols::relax::RelaxProtocolBase::constrain_relax_to_start_coords(bool) –> void

coord_constrain_sidechains(*args, **kwargs)

Overloaded function.

1. coord_constrain_sidechains(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::coord_constrain_sidechains() const –> bool

2. coord_constrain_sidechains(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, coord_constrain_sidechains: bool) -> None

C++: protocols::relax::RelaxProtocolBase::coord_constrain_sidechains(bool) –> void

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>

dry_run(*args, **kwargs)

Overloaded function.

1. dry_run(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::dry_run() const –> bool

2. dry_run(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, setting: bool) -> None

C++: protocols::relax::RelaxProtocolBase::dry_run(bool) –> void

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

C++: protocols::relax::RelaxProtocolBase::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_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_midpoint_longest_loop(self: pyrosetta.rosetta.protocols.relax.RepeatProteinRelax, pose: pyrosetta.rosetta.core.pose.Pose, repeat_length: int) → int

C++: protocols::relax::RepeatProteinRelax::get_midpoint_longest_loop(const class core::pose::Pose &, const unsigned long) –> unsigned long

get_movemap(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) → pyrosetta.rosetta.core.kinematics.MoveMap

C++: protocols::relax::RelaxProtocolBase::get_movemap() –> class std::shared_ptr<class core::kinematics::MoveMap>

get_name(self: pyrosetta.rosetta.protocols.relax.RepeatProteinRelax) → str

C++: protocols::relax::RepeatProteinRelax::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_scorefxn(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) → pyrosetta.rosetta.core.scoring.ScoreFunction

C++: protocols::relax::RelaxProtocolBase::get_scorefxn() const –> const class std::shared_ptr<const class core::scoring::ScoreFunction>

get_self_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.protocols.moves.Mover

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

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.weak_ptr_protocols_moves_Mover_t

C++: protocols::moves::Mover::get_self_weak_ptr() –> class std::weak_ptr<class protocols::moves::Mover>

get_task_factory(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) → pyrosetta.rosetta.core.pack.task.TaskFactory

C++: protocols::relax::RelaxProtocolBase::get_task_factory() const –> const class std::shared_ptr<class core::pack::task::TaskFactory> &

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

max_iter(*args, **kwargs)

Overloaded function.

1. max_iter(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> int

C++: protocols::relax::RelaxProtocolBase::max_iter() const –> unsigned long

2. max_iter(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, max_iter: int) -> None

C++: protocols::relax::RelaxProtocolBase::max_iter(unsigned long) –> void

min_type(*args, **kwargs)

Overloaded function.

1. min_type(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> str

C++: protocols::relax::RelaxProtocolBase::min_type() const –> std::string

2. min_type(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, min_type: str) -> None

C++: protocols::relax::RelaxProtocolBase::min_type(std::string) –> void

minimize_bond_angles(*args, **kwargs)

Overloaded function.

1. minimize_bond_angles(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::minimize_bond_angles() const –> bool

2. minimize_bond_angles(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, minimize_bond_angles: bool) -> None

C++: protocols::relax::RelaxProtocolBase::minimize_bond_angles(bool) –> void

minimize_bond_lengths(*args, **kwargs)

Overloaded function.

1. minimize_bond_lengths(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::minimize_bond_lengths() const –> bool

2. minimize_bond_lengths(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, minimize_bond_lengths: bool) -> None

C++: protocols::relax::RelaxProtocolBase::minimize_bond_lengths(bool) –> void

minimize_pose(self: pyrosetta.rosetta.protocols.relax.RepeatProteinRelax, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::relax::RepeatProteinRelax::minimize_pose(class core::pose::Pose &) –> void

static mover_name() → str

C++: protocols::relax::RepeatProteinRelax::mover_name() –> std::string

static name() → str

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

parse_my_tag(self: pyrosetta.rosetta.protocols.relax.RepeatProteinRelax, tag: pyrosetta.rosetta.utility.tag.Tag, datamap: pyrosetta.rosetta.basic.datacache.DataMap) → None

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

provide_citation_info(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None

Provide the citation.

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

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None

C++: protocols::relax::RepeatProteinRelax::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

ramp_down_constraints(*args, **kwargs)

Overloaded function.

1. ramp_down_constraints(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) -> bool

C++: protocols::relax::RelaxProtocolBase::ramp_down_constraints() const –> bool

2. ramp_down_constraints(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, ramp_down_constraints: bool) -> None

C++: protocols::relax::RelaxProtocolBase::ramp_down_constraints(bool) –> void

static register_options() → None

C++: protocols::relax::RelaxProtocolBase::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

relax_pose(self: pyrosetta.rosetta.protocols.relax.RepeatProteinRelax, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::relax::RepeatProteinRelax::relax_pose(class core::pose::Pose &) –> void

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

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

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

seal_jumps(self: pyrosetta.rosetta.protocols.relax.RepeatProteinRelax, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::relax::RepeatProteinRelax::seal_jumps(class core::pose::Pose &) –> 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_default_coordinate_settings(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) → None

C++: protocols::relax::RelaxProtocolBase::set_default_coordinate_settings() –> void

set_default_minimization_settings(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) → None

C++: protocols::relax::RelaxProtocolBase::set_default_minimization_settings() –> void

set_default_movemap(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) → None

C++: protocols::relax::RelaxProtocolBase::set_default_movemap() –> void

set_defaults(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase) → None

C++: protocols::relax::RelaxProtocolBase::set_defaults() –> 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_movemap(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, movemap: pyrosetta.rosetta.core.kinematics.MoveMap) → None

C++: protocols::relax::RelaxProtocolBase::set_movemap(class std::shared_ptr<class core::kinematics::MoveMap>) –> void

set_movemap_factory(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, mm_factory: pyrosetta.rosetta.core.select.movemap.MoveMapFactory) → None

C++: protocols::relax::RelaxProtocolBase::set_movemap_factory(class std::shared_ptr<class core::select::movemap::MoveMapFactory>) –> 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_scorefxn(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: protocols::relax::RelaxProtocolBase::set_scorefxn(class std::shared_ptr<class core::scoring::ScoreFunction>) –> void

set_task_factory(self: pyrosetta.rosetta.protocols.relax.RelaxProtocolBase, task_factory: pyrosetta.rosetta.core.pack.task.TaskFactory) → None

C++: protocols::relax::RelaxProtocolBase::set_task_factory(class std::shared_ptr<class core::pack::task::TaskFactory>) –> 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

setup_movemap(self: pyrosetta.rosetta.protocols.relax.RepeatProteinRelax, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::relax::RepeatProteinRelax::setup_movemap(class core::pose::Pose &) –> void

setup_repeat_pose(self: pyrosetta.rosetta.protocols.relax.RepeatProteinRelax, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::relax::RepeatProteinRelax::setup_repeat_pose(class core::pose::Pose &) –> void

setup_repeat_pose_jumping(self: pyrosetta.rosetta.protocols.relax.RepeatProteinRelax, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::relax::RepeatProteinRelax::setup_repeat_pose_jumping(class core::pose::Pose &) –> void

setup_repeat_symminfo(self: pyrosetta.rosetta.protocols.relax.RepeatProteinRelax, repeatlen: int, nrepeat: int, base_repeat: int, with_jumping: bool, symminfo: pyrosetta.rosetta.core.conformation.symmetry.SymmetryInfo) → None

C++: protocols::relax::RepeatProteinRelax::setup_repeat_symminfo(const unsigned long, const unsigned long, const unsigned long, const bool, class core::conformation::symmetry::SymmetryInfo &) –> 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.relax.RepeatProteinRelaxCreator

Bases: MoverCreator

assign(self: pyrosetta.rosetta.protocols.relax.RepeatProteinRelaxCreator, : pyrosetta.rosetta.protocols.relax.RepeatProteinRelaxCreator) → pyrosetta.rosetta.protocols.relax.RepeatProteinRelaxCreator

C++: protocols::relax::RepeatProteinRelaxCreator::operator=(const class protocols::relax::RepeatProteinRelaxCreator &) –> class protocols::relax::RepeatProteinRelaxCreator &

create_mover(self: pyrosetta.rosetta.protocols.relax.RepeatProteinRelaxCreator) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::relax::RepeatProteinRelaxCreator::create_mover() const –> class std::shared_ptr<class protocols::moves::Mover>

keyname(self: pyrosetta.rosetta.protocols.relax.RepeatProteinRelaxCreator) → str

C++: protocols::relax::RepeatProteinRelaxCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.relax.RepeatProteinRelaxCreator, xsd: utility::tag::XMLSchemaDefinition) → None

C++: protocols::relax::RepeatProteinRelaxCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.protocols.relax.VariableSubstitutionPair

Bases: pybind11_object

assign(self: pyrosetta.rosetta.protocols.relax.VariableSubstitutionPair, : pyrosetta.rosetta.protocols.relax.VariableSubstitutionPair) → pyrosetta.rosetta.protocols.relax.VariableSubstitutionPair

C++: protocols::relax::VariableSubstitutionPair::operator=(const struct protocols::relax::VariableSubstitutionPair &) –> struct protocols::relax::VariableSubstitutionPair &

property string_being_added

property string_being_replaced

class pyrosetta.rosetta.protocols.relax.WorkUnit_BatchRelax

Bases: WorkUnit_SilentStructStore

class WU_Header

Bases: pybind11_object

this structure can contain any non-dynamicly allocated data. Any simple data types can be used here, ints, real, floats, char, etc..

assign(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase.WU_Header, : pyrosetta.rosetta.protocols.wum.WorkUnitBase.WU_Header) → pyrosetta.rosetta.protocols.wum.WorkUnitBase.WU_Header

C++: protocols::wum::WorkUnitBase::WU_Header::operator=(const struct protocols::wum::WorkUnitBase::WU_Header &) –> struct protocols::wum::WorkUnitBase::WU_Header &

property extra_data_1_

property extra_data_2_

property extra_data_3_

property extra_data_4_

property id_

property unixtime_creation_

property unixtime_start_

property unixtime_stop_

add_blacklist(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase, mpi_rank: int) → None

Adds to the blacklist

C++: protocols::wum::WorkUnitBase::add_blacklist(int) –> void

assign(self: pyrosetta.rosetta.protocols.relax.WorkUnit_BatchRelax, : pyrosetta.rosetta.protocols.relax.WorkUnit_BatchRelax) → pyrosetta.rosetta.protocols.relax.WorkUnit_BatchRelax

C++: protocols::relax::WorkUnit_BatchRelax::operator=(const class protocols::relax::WorkUnit_BatchRelax &) –> class protocols::relax::WorkUnit_BatchRelax &

clear_blacklist(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase) → None

Erases the blacklist

C++: protocols::wum::WorkUnitBase::clear_blacklist() –> void

clear_serial_data(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase) → None

Remove all data, make sure that the memory is also cleared, hence the cals to reserve

C++: protocols::wum::WorkUnitBase::clear_serial_data() –> void

clone(self: pyrosetta.rosetta.protocols.relax.WorkUnit_BatchRelax) → pyrosetta.rosetta.protocols.wum.WorkUnitBase

C++: protocols::relax::WorkUnit_BatchRelax::clone() const –> class std::shared_ptr<class protocols::wum::WorkUnitBase>

decoys(self: pyrosetta.rosetta.protocols.wum.WorkUnit_SilentStructStore) → pyrosetta.rosetta.protocols.wum.SilentStructStore

Accessor for decoy store

C++: protocols::wum::WorkUnit_SilentStructStore::decoys() –> class protocols::wum::SilentStructStore &

deserialize(self: pyrosetta.rosetta.protocols.wum.WorkUnit_SilentStructStore) → None

Make ready for working

C++: protocols::wum::WorkUnit_SilentStructStore::deserialize() –> void

extra_data_1(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase) → int

Accessor to the extra_data_1 and 3 field of the header

C++: protocols::wum::WorkUnitBase::extra_data_1() –> unsigned long

extra_data_2(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase) → int

C++: protocols::wum::WorkUnitBase::extra_data_2() –> unsigned long

extra_data_3(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase) → int

C++: protocols::wum::WorkUnitBase::extra_data_3() –> unsigned long

get_options(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase) → str

Optain the options string from the header

C++: protocols::wum::WorkUnitBase::get_options() const –> std::string

get_run_time(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase) → int

Returns the differrence between unix start and stop times

C++: protocols::wum::WorkUnitBase::get_run_time() –> unsigned long

get_wu_type(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase) → str

Accessor to header structure, return the WorkUnit Type

C++: protocols::wum::WorkUnitBase::get_wu_type() const –> std::string

id(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase) → int

Accessor to the ID of the WorkUnit

C++: protocols::wum::WorkUnitBase::id() –> unsigned long

in_blacklist(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase, mpi_rank: int) → bool

Finds in blacklist, true if is, false if it isn’t

C++: protocols::wum::WorkUnitBase::in_blacklist(int) –> bool

last_received_from(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase) → int

C++: protocols::wum::WorkUnitBase::last_received_from() –> unsigned long

mem_footprint(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase) → int

Return the memory usage of this WorkUnit

C++: protocols::wum::WorkUnitBase::mem_footprint() const –> unsigned long

post_process(self: pyrosetta.rosetta.protocols.relax.WorkUnit_BatchRelax) → None

C++: protocols::relax::WorkUnit_BatchRelax::post_process() –> void

pre_process(self: pyrosetta.rosetta.protocols.relax.WorkUnit_BatchRelax) → None

C++: protocols::relax::WorkUnit_BatchRelax::pre_process() –> void

print(*args, **kwargs)

Overloaded function.

1. print(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase, out: pyrosetta.rosetta.std.ostream) -> None

2. print(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase, out: pyrosetta.rosetta.std.ostream, verbose: bool) -> None

Print header information to the stream, single line by default or verbose if verbose is set to true

C++: protocols::wum::WorkUnitBase::print(std::ostream &, bool) const –> void

run(self: pyrosetta.rosetta.protocols.relax.WorkUnit_BatchRelax) → None

C++: protocols::relax::WorkUnit_BatchRelax::run() –> void

serialize(self: pyrosetta.rosetta.protocols.wum.WorkUnit_SilentStructStore) → None

write decoys into serial data store overwritinge whatever was there before. It basically syncs the silent struct store with the derial data

C++: protocols::wum::WorkUnit_SilentStructStore::serialize() –> void

set_extra_data_1(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase, value: int) → None

C++: protocols::wum::WorkUnitBase::set_extra_data_1(const unsigned long) –> void

set_extra_data_2(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase, value: int) → None

C++: protocols::wum::WorkUnitBase::set_extra_data_2(const unsigned long) –> void

set_extra_data_3(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase, value: int) → None

C++: protocols::wum::WorkUnitBase::set_extra_data_3(const unsigned long) –> void

set_native_pose(self: pyrosetta.rosetta.protocols.relax.WorkUnit_BatchRelax, native_pose: pyrosetta.rosetta.core.pose.Pose) → None

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

set_options(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase, text: str) → None

Accesor to the “options” text field

C++: protocols::wum::WorkUnitBase::set_options(const std::string &) –> void

set_wu_type(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase, text: str) → None

Accessor to header structure, sets the WorkUnit Type

C++: protocols::wum::WorkUnitBase::set_wu_type(const std::string &) –> void

class pyrosetta.rosetta.protocols.relax.WorkUnit_BatchRelax_and_PostRescore

Bases: WorkUnit_BatchRelax

class WU_Header

Bases: pybind11_object

this structure can contain any non-dynamicly allocated data. Any simple data types can be used here, ints, real, floats, char, etc..

assign(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase.WU_Header, : pyrosetta.rosetta.protocols.wum.WorkUnitBase.WU_Header) → pyrosetta.rosetta.protocols.wum.WorkUnitBase.WU_Header

C++: protocols::wum::WorkUnitBase::WU_Header::operator=(const struct protocols::wum::WorkUnitBase::WU_Header &) –> struct protocols::wum::WorkUnitBase::WU_Header &

property extra_data_1_

property extra_data_2_

property extra_data_3_

property extra_data_4_

property id_

property unixtime_creation_

property unixtime_start_

property unixtime_stop_

add_blacklist(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase, mpi_rank: int) → None

Adds to the blacklist

C++: protocols::wum::WorkUnitBase::add_blacklist(int) –> void

assign(self: pyrosetta.rosetta.protocols.relax.WorkUnit_BatchRelax_and_PostRescore, : pyrosetta.rosetta.protocols.relax.WorkUnit_BatchRelax_and_PostRescore) → pyrosetta.rosetta.protocols.relax.WorkUnit_BatchRelax_and_PostRescore

C++: protocols::relax::WorkUnit_BatchRelax_and_PostRescore::operator=(const class protocols::relax::WorkUnit_BatchRelax_and_PostRescore &) –> class protocols::relax::WorkUnit_BatchRelax_and_PostRescore &

clear_blacklist(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase) → None

Erases the blacklist

C++: protocols::wum::WorkUnitBase::clear_blacklist() –> void

clear_serial_data(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase) → None

Remove all data, make sure that the memory is also cleared, hence the cals to reserve

C++: protocols::wum::WorkUnitBase::clear_serial_data() –> void

clone(self: pyrosetta.rosetta.protocols.relax.WorkUnit_BatchRelax_and_PostRescore) → pyrosetta.rosetta.protocols.wum.WorkUnitBase

C++: protocols::relax::WorkUnit_BatchRelax_and_PostRescore::clone() const –> class std::shared_ptr<class protocols::wum::WorkUnitBase>

decoys(self: pyrosetta.rosetta.protocols.wum.WorkUnit_SilentStructStore) → pyrosetta.rosetta.protocols.wum.SilentStructStore

Accessor for decoy store

C++: protocols::wum::WorkUnit_SilentStructStore::decoys() –> class protocols::wum::SilentStructStore &

deserialize(self: pyrosetta.rosetta.protocols.wum.WorkUnit_SilentStructStore) → None

Make ready for working

C++: protocols::wum::WorkUnit_SilentStructStore::deserialize() –> void

extra_data_1(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase) → int

Accessor to the extra_data_1 and 3 field of the header

C++: protocols::wum::WorkUnitBase::extra_data_1() –> unsigned long

extra_data_2(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase) → int

C++: protocols::wum::WorkUnitBase::extra_data_2() –> unsigned long

extra_data_3(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase) → int

C++: protocols::wum::WorkUnitBase::extra_data_3() –> unsigned long

get_options(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase) → str

Optain the options string from the header

C++: protocols::wum::WorkUnitBase::get_options() const –> std::string

get_run_time(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase) → int

Returns the differrence between unix start and stop times

C++: protocols::wum::WorkUnitBase::get_run_time() –> unsigned long

get_wu_type(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase) → str

Accessor to header structure, return the WorkUnit Type

C++: protocols::wum::WorkUnitBase::get_wu_type() const –> std::string

id(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase) → int

Accessor to the ID of the WorkUnit

C++: protocols::wum::WorkUnitBase::id() –> unsigned long

in_blacklist(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase, mpi_rank: int) → bool

Finds in blacklist, true if is, false if it isn’t

C++: protocols::wum::WorkUnitBase::in_blacklist(int) –> bool

last_received_from(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase) → int

C++: protocols::wum::WorkUnitBase::last_received_from() –> unsigned long

mem_footprint(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase) → int

Return the memory usage of this WorkUnit

C++: protocols::wum::WorkUnitBase::mem_footprint() const –> unsigned long

post_process(self: pyrosetta.rosetta.protocols.relax.WorkUnit_BatchRelax_and_PostRescore) → None

C++: protocols::relax::WorkUnit_BatchRelax_and_PostRescore::post_process() –> void

pre_process(self: pyrosetta.rosetta.protocols.relax.WorkUnit_BatchRelax_and_PostRescore) → None

C++: protocols::relax::WorkUnit_BatchRelax_and_PostRescore::pre_process() –> void

print(*args, **kwargs)

Overloaded function.

1. print(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase, out: pyrosetta.rosetta.std.ostream) -> None

2. print(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase, out: pyrosetta.rosetta.std.ostream, verbose: bool) -> None

Print header information to the stream, single line by default or verbose if verbose is set to true

C++: protocols::wum::WorkUnitBase::print(std::ostream &, bool) const –> void

rescore_all_decoys(self: pyrosetta.rosetta.protocols.relax.WorkUnit_BatchRelax_and_PostRescore) → None

C++: protocols::relax::WorkUnit_BatchRelax_and_PostRescore::rescore_all_decoys() –> void

run(self: pyrosetta.rosetta.protocols.relax.WorkUnit_BatchRelax) → None

C++: protocols::relax::WorkUnit_BatchRelax::run() –> void

serialize(self: pyrosetta.rosetta.protocols.wum.WorkUnit_SilentStructStore) → None

write decoys into serial data store overwritinge whatever was there before. It basically syncs the silent struct store with the derial data

C++: protocols::wum::WorkUnit_SilentStructStore::serialize() –> void

set_defaults(self: pyrosetta.rosetta.protocols.relax.WorkUnit_BatchRelax_and_PostRescore) → None

C++: protocols::relax::WorkUnit_BatchRelax_and_PostRescore::set_defaults() –> void

set_extra_data_1(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase, value: int) → None

C++: protocols::wum::WorkUnitBase::set_extra_data_1(const unsigned long) –> void

set_extra_data_2(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase, value: int) → None

C++: protocols::wum::WorkUnitBase::set_extra_data_2(const unsigned long) –> void

set_extra_data_3(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase, value: int) → None

C++: protocols::wum::WorkUnitBase::set_extra_data_3(const unsigned long) –> void

set_native_pose(self: pyrosetta.rosetta.protocols.relax.WorkUnit_BatchRelax, native_pose: pyrosetta.rosetta.core.pose.Pose) → None

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

set_options(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase, text: str) → None

Accesor to the “options” text field

C++: protocols::wum::WorkUnitBase::set_options(const std::string &) –> void

set_wu_type(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase, text: str) → None

Accessor to header structure, sets the WorkUnit Type

C++: protocols::wum::WorkUnitBase::set_wu_type(const std::string &) –> void

pyrosetta.rosetta.protocols.relax.add_coordinate_constraint_func_atoms(pose: pyrosetta.rosetta.core.pose.Pose, resnum: int, rsd_i: pyrosetta.rosetta.core.conformation.Residue, coord_cst_func: pyrosetta.rosetta.core.scoring.func.HarmonicFunc, anchor_atom: pyrosetta.rosetta.core.id.AtomID) → pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t

C++: protocols::relax::add_coordinate_constraint_func_atoms(const class core::pose::Pose &, const unsigned long, const class core::conformation::Residue &, class std::shared_ptr<class core::scoring::func::HarmonicFunc>, const class core::id::AtomID &) –> class utility::vector1<class std::shared_ptr<const class core::scoring::constraints::Constraint>, class std::allocator<class std::shared_ptr<const class core::scoring::constraints::Constraint> > >

pyrosetta.rosetta.protocols.relax.add_coordinate_constraints_to_pose(pose: pyrosetta.rosetta.core.pose.Pose, constraint_target_pose: pyrosetta.rosetta.core.pose.Pose, exclude_regions: pyrosetta.rosetta.protocols.loops.Loops) → None

C++: protocols::relax::add_coordinate_constraints_to_pose(class core::pose::Pose &, const class core::pose::Pose &, class protocols::loops::Loops &) –> void

pyrosetta.rosetta.protocols.relax.add_virtual_residue_to_cterm(pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::relax::add_virtual_residue_to_cterm(class core::pose::Pose &) –> void

pyrosetta.rosetta.protocols.relax.coordinate_constrain_selection(pose: pyrosetta.rosetta.core.pose.Pose, aln: pyrosetta.rosetta.core.sequence.SequenceAlignment, coord_sdev: float) → None

C++: protocols::relax::coordinate_constrain_selection(class core::pose::Pose &, class core::sequence::SequenceAlignment, double) –> void

pyrosetta.rosetta.protocols.relax.cyclize_pose(pose: pyrosetta.rosetta.core.pose.Pose) → None

Add terminal peptide bond and cyclic constraints to pose.

Gaurav Bhardwaj, Baker laboratory

Vikram K. Mulligan, Baker laboratory (vmullig.edu) – moved from protocols/forge/methods/util.hh/cc

C++: protocols::relax::cyclize_pose(class core::pose::Pose &) –> void

pyrosetta.rosetta.protocols.relax.delete_virtual_residues(pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::relax::delete_virtual_residues(class core::pose::Pose &) –> void

pyrosetta.rosetta.protocols.relax.derive_sc_sc_restraints(pose: pyrosetta.rosetta.core.pose.Pose, upper_dist_cutoff: float) → None

C++: protocols::relax::derive_sc_sc_restraints(class core::pose::Pose &, const double) –> void

pyrosetta.rosetta.protocols.relax.fixH(pose: pyrosetta.rosetta.core.pose.Pose) → None

Rebuild all polymer bond-dependent atoms in the pose.

Rewritten from an earlier, uglier function that manually placed H atom in non-pro.

Vikram K. Mulligan, Baker laboratory (vmullig.edu).

C++: protocols::relax::fixH(class core::pose::Pose &) –> void

pyrosetta.rosetta.protocols.relax.fix_worst_bad_ramas(*args, **kwargs)

Overloaded function.

1. fix_worst_bad_ramas(original_pose: pyrosetta.rosetta.core.pose.Pose) -> None

2. fix_worst_bad_ramas(original_pose: pyrosetta.rosetta.core.pose.Pose, how_many: int) -> None

3. fix_worst_bad_ramas(original_pose: pyrosetta.rosetta.core.pose.Pose, how_many: int, skip_prob: float) -> None

4. fix_worst_bad_ramas(original_pose: pyrosetta.rosetta.core.pose.Pose, how_many: int, skip_prob: float, limit_rms: float) -> None

5. fix_worst_bad_ramas(original_pose: pyrosetta.rosetta.core.pose.Pose, how_many: int, skip_prob: float, limit_rms: float, limit_rama: float) -> None

C++: protocols::relax::fix_worst_bad_ramas(class core::pose::Pose &, unsigned long, double, double, double) –> void

pyrosetta.rosetta.protocols.relax.generate_bb_coordinate_constraints(pose: pyrosetta.rosetta.core.pose.Pose, coord_sdevs: pyrosetta.rosetta.utility.vector1_double) → pyrosetta.rosetta.core.scoring.constraints.ConstraintSet

Generate a set of coordinate constraints to backbone atoms using the

given standard deviations, with one sd per-reside. If no constraint should be applied to a given residue, give a -1 for the value of the sdev.

C++: protocols::relax::generate_bb_coordinate_constraints(class core::pose::Pose &, const class utility::vector1<double, class std::allocator<double> > &) –> class std::shared_ptr<class core::scoring::constraints::ConstraintSet>

pyrosetta.rosetta.protocols.relax.generate_relax_from_cmd(*args, **kwargs)

Overloaded function.

1. generate_relax_from_cmd() -> pyrosetta.rosetta.protocols.relax.RelaxProtocolBase

2. generate_relax_from_cmd(NULL_if_no_cmd: bool) -> pyrosetta.rosetta.protocols.relax.RelaxProtocolBase

Create a relax mover reading from the global options collection

C++: protocols::relax::generate_relax_from_cmd(bool) –> class std::shared_ptr<class protocols::relax::RelaxProtocolBase>

3. generate_relax_from_cmd(options: pyrosetta.rosetta.utility.options.OptionCollection) -> pyrosetta.rosetta.protocols.relax.RelaxProtocolBase

4. generate_relax_from_cmd(options: pyrosetta.rosetta.utility.options.OptionCollection, NULL_if_no_flag: bool) -> pyrosetta.rosetta.protocols.relax.RelaxProtocolBase

C++: protocols::relax::generate_relax_from_cmd(const class utility::options::OptionCollection &, bool) –> class std::shared_ptr<class protocols::relax::RelaxProtocolBase>

pyrosetta.rosetta.protocols.relax.get_per_residue_scores(pose: pyrosetta.rosetta.core.pose.Pose, scoretype: pyrosetta.rosetta.core.scoring.ScoreType) → pyrosetta.rosetta.utility.vector1_double

C++: protocols::relax::get_per_residue_scores(class core::pose::Pose &, enum core::scoring::ScoreType) –> class utility::vector1<double, class std::allocator<double> >

pyrosetta.rosetta.protocols.relax.make_dna_rigid(pose: pyrosetta.rosetta.core.pose.Pose, mm: pyrosetta.rosetta.core.kinematics.MoveMap) → None

Make DNA Rigid in movemap if found in pose

C++: protocols::relax::make_dna_rigid(class core::pose::Pose &, class core::kinematics::MoveMap &) –> void

pyrosetta.rosetta.protocols.relax.options_for_generate_relax_from_cmd(opts: pyrosetta.rosetta.std.list_utility_keys_VariantKey_utility_options_OptionKey_t) → None

C++: protocols::relax::options_for_generate_relax_from_cmd(class std::list<class utility::keys::VariantKey<class utility::options::OptionKey>, class std::allocator<class utility::keys::VariantKey<class utility::options::OptionKey> > > &) –> void

pyrosetta.rosetta.protocols.relax.relax_pose(pose: pyrosetta.rosetta.core.pose.Pose, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction, tag: str) → None

C++: protocols::relax::relax_pose(class core::pose::Pose &, class std::shared_ptr<class core::scoring::ScoreFunction>, const std::string &) –> void

pyrosetta.rosetta.protocols.relax.setup_for_dna(scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

Set energy method options for DNA-DNA. Any other optimization for DNA relax should go here.

C++: protocols::relax::setup_for_dna(class core::scoring::ScoreFunction &) –> void

pyrosetta.rosetta.protocols.relax.setup_membrane_topology(pose: pyrosetta.rosetta.core.pose.Pose, spanfile: str) → None

(pba) read in membrane topology

C++: protocols::relax::setup_membrane_topology(class core::pose::Pose &, std::string) –> void