hybridization

Bindings for protocols::hybridization namespace

class pyrosetta.rosetta.protocols.hybridization.AlignOption

Bases: pybind11_object

Members:

all_chunks

random_chunk

all_chunks = <AlignOption.all_chunks: 0>

property name

random_chunk = <AlignOption.random_chunk: 1>

property value

class pyrosetta.rosetta.protocols.hybridization.AllResiduesChanged

Bases: PoseCondition

(helper) functor class which keeps track of initial phi/psi values.

calls of operator ( pose ) compare the initial phi/psi values

/to the current values of the given pose. Returns false once all phi/psi values

have been modified.

assign(self: pyrosetta.rosetta.protocols.hybridization.AllResiduesChanged, : pyrosetta.rosetta.protocols.hybridization.AllResiduesChanged) → pyrosetta.rosetta.protocols.hybridization.AllResiduesChanged

C++: protocols::hybridization::AllResiduesChanged::operator=(const class protocols::hybridization::AllResiduesChanged &) –> class protocols::hybridization::AllResiduesChanged &

show_unmoved(self: pyrosetta.rosetta.protocols.hybridization.AllResiduesChanged, pose: pyrosetta.rosetta.core.pose.Pose, out: pyrosetta.rosetta.std.ostream) → None

C++: protocols::hybridization::AllResiduesChanged::show_unmoved(const class core::pose::Pose &, std::ostream &) –> void

class pyrosetta.rosetta.protocols.hybridization.BackboneTorsionPerturbation

Bases: Mover

apply(self: pyrosetta.rosetta.protocols.hybridization.BackboneTorsionPerturbation, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::hybridization::BackboneTorsionPerturbation::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.hybridization.BackboneTorsionPerturbation, : pyrosetta.rosetta.protocols.hybridization.BackboneTorsionPerturbation) → pyrosetta.rosetta.protocols.hybridization.BackboneTorsionPerturbation

C++: protocols::hybridization::BackboneTorsionPerturbation::operator=(const class protocols::hybridization::BackboneTorsionPerturbation &) –> class protocols::hybridization::BackboneTorsionPerturbation &

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

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

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

C++: protocols::hybridization::BackboneTorsionPerturbation::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 > > &

init(self: pyrosetta.rosetta.protocols.hybridization.BackboneTorsionPerturbation) → None

C++: protocols::hybridization::BackboneTorsionPerturbation::init() –> void

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::hybridization::BackboneTorsionPerturbation::mover_name() –> std::string

static name() → str

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

parse_my_tag(self: pyrosetta.rosetta.protocols.hybridization.BackboneTorsionPerturbation, tag: pyrosetta.rosetta.utility.tag.Tag, datamap: pyrosetta.rosetta.basic.datacache.DataMap) → None

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

perturb(*args, **kwargs)

Overloaded function.

1. perturb(self: pyrosetta.rosetta.protocols.hybridization.BackboneTorsionPerturbation, pose: pyrosetta.rosetta.core.pose.Pose, max_delta_torsion: float) -> None

C++: protocols::hybridization::BackboneTorsionPerturbation::perturb(class core::pose::Pose &, double) –> void

2. perturb(self: pyrosetta.rosetta.protocols.hybridization.BackboneTorsionPerturbation, pose: pyrosetta.rosetta.core.pose.Pose, level: int, max_delta_torsion: float, local: int, rama_biased: bool, repack: bool, minimize: bool) -> None

C++: protocols::hybridization::BackboneTorsionPerturbation::perturb(class core::pose::Pose &, unsigned long, double, unsigned long, bool, bool, bool) –> 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::hybridization::BackboneTorsionPerturbation::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_scorefunction(self: pyrosetta.rosetta.protocols.hybridization.BackboneTorsionPerturbation, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: protocols::hybridization::BackboneTorsionPerturbation::set_scorefunction(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

task_factory(self: pyrosetta.rosetta.protocols.hybridization.BackboneTorsionPerturbation, tf: pyrosetta.rosetta.core.pack.task.TaskFactory) → None

C++: protocols::hybridization::BackboneTorsionPerturbation::task_factory(class std::shared_ptr<const class core::pack::task::TaskFactory>) –> 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.hybridization.BackboneTorsionPerturbationCreator

Bases: MoverCreator

assign(self: pyrosetta.rosetta.protocols.hybridization.BackboneTorsionPerturbationCreator, : pyrosetta.rosetta.protocols.hybridization.BackboneTorsionPerturbationCreator) → pyrosetta.rosetta.protocols.hybridization.BackboneTorsionPerturbationCreator

C++: protocols::hybridization::BackboneTorsionPerturbationCreator::operator=(const class protocols::hybridization::BackboneTorsionPerturbationCreator &) –> class protocols::hybridization::BackboneTorsionPerturbationCreator &

create_mover(self: pyrosetta.rosetta.protocols.hybridization.BackboneTorsionPerturbationCreator) → pyrosetta.rosetta.protocols.moves.Mover

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

keyname(self: pyrosetta.rosetta.protocols.hybridization.BackboneTorsionPerturbationCreator) → str

C++: protocols::hybridization::BackboneTorsionPerturbationCreator::keyname() const –> std::string

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

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

class pyrosetta.rosetta.protocols.hybridization.BackboneTorsionSampler

Bases: Mover

apply(self: pyrosetta.rosetta.protocols.hybridization.BackboneTorsionSampler, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::hybridization::BackboneTorsionSampler::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.hybridization.BackboneTorsionSampler, : pyrosetta.rosetta.protocols.hybridization.BackboneTorsionSampler) → pyrosetta.rosetta.protocols.hybridization.BackboneTorsionSampler

C++: protocols::hybridization::BackboneTorsionSampler::operator=(const class protocols::hybridization::BackboneTorsionSampler &) –> class protocols::hybridization::BackboneTorsionSampler &

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

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

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

C++: protocols::hybridization::BackboneTorsionSampler::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 > > &

init(self: pyrosetta.rosetta.protocols.hybridization.BackboneTorsionSampler) → None

C++: protocols::hybridization::BackboneTorsionSampler::init() –> void

last_proposal_density_ratio(self: pyrosetta.rosetta.protocols.moves.Mover) → float

C++: protocols::moves::Mover::last_proposal_density_ratio() –> double

local_perturb(self: pyrosetta.rosetta.protocols.hybridization.BackboneTorsionSampler, pose: pyrosetta.rosetta.core.pose.Pose, max_delta_torsion: float) → None

C++: protocols::hybridization::BackboneTorsionSampler::local_perturb(class core::pose::Pose, double) –> void

static mover_name() → str

C++: protocols::hybridization::BackboneTorsionSampler::mover_name() –> std::string

static name() → str

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

parse_my_tag(self: pyrosetta.rosetta.protocols.hybridization.BackboneTorsionSampler, tag: pyrosetta.rosetta.utility.tag.Tag, datamap: pyrosetta.rosetta.basic.datacache.DataMap) → None

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

perturb(self: pyrosetta.rosetta.protocols.hybridization.BackboneTorsionSampler, pose: pyrosetta.rosetta.core.pose.Pose, level: int, max_delta_torsion: float, local: int, rama_biased: bool, repack: bool, minimize: bool) → None

C++: protocols::hybridization::BackboneTorsionSampler::perturb(class core::pose::Pose &, unsigned long, double, unsigned long, bool, bool, bool) –> 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::hybridization::BackboneTorsionSampler::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_scorefunction(self: pyrosetta.rosetta.protocols.hybridization.BackboneTorsionSampler, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: protocols::hybridization::BackboneTorsionSampler::set_scorefunction(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

task_factory(self: pyrosetta.rosetta.protocols.hybridization.BackboneTorsionSampler, tf: pyrosetta.rosetta.core.pack.task.TaskFactory) → None

C++: protocols::hybridization::BackboneTorsionSampler::task_factory(class std::shared_ptr<const class core::pack::task::TaskFactory>) –> 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.hybridization.BackboneTorsionSamplerCreator

Bases: MoverCreator

assign(self: pyrosetta.rosetta.protocols.hybridization.BackboneTorsionSamplerCreator, : pyrosetta.rosetta.protocols.hybridization.BackboneTorsionSamplerCreator) → pyrosetta.rosetta.protocols.hybridization.BackboneTorsionSamplerCreator

C++: protocols::hybridization::BackboneTorsionSamplerCreator::operator=(const class protocols::hybridization::BackboneTorsionSamplerCreator &) –> class protocols::hybridization::BackboneTorsionSamplerCreator &

create_mover(self: pyrosetta.rosetta.protocols.hybridization.BackboneTorsionSamplerCreator) → pyrosetta.rosetta.protocols.moves.Mover

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

keyname(self: pyrosetta.rosetta.protocols.hybridization.BackboneTorsionSamplerCreator) → str

C++: protocols::hybridization::BackboneTorsionSamplerCreator::keyname() const –> std::string

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

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

class pyrosetta.rosetta.protocols.hybridization.CartesianHybridize

Bases: Mover

apply(self: pyrosetta.rosetta.protocols.hybridization.CartesianHybridize, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::hybridization::CartesianHybridize::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.hybridization.CartesianHybridize, : pyrosetta.rosetta.protocols.hybridization.CartesianHybridize) → pyrosetta.rosetta.protocols.hybridization.CartesianHybridize

C++: protocols::hybridization::CartesianHybridize::operator=(const class protocols::hybridization::CartesianHybridize &) –> class protocols::hybridization::CartesianHybridize &

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

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

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

C++: protocols::hybridization::CartesianHybridize::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 > > &

init(self: pyrosetta.rosetta.protocols.hybridization.CartesianHybridize) → None

C++: protocols::hybridization::CartesianHybridize::init() –> void

last_proposal_density_ratio(self: pyrosetta.rosetta.protocols.moves.Mover) → float

C++: protocols::moves::Mover::last_proposal_density_ratio() –> double

static name() → str

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

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

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

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

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

Provide citations to the passed CitationCollectionList

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

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

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

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_cartfrag_overlap(self: pyrosetta.rosetta.protocols.hybridization.CartesianHybridize, cartfrag_overlap_in: int) → None

C++: protocols::hybridization::CartesianHybridize::set_cartfrag_overlap(unsigned long) –> void

set_cenrot(self: pyrosetta.rosetta.protocols.hybridization.CartesianHybridize, cenrot_in: bool) → None

C++: protocols::hybridization::CartesianHybridize::set_cenrot(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_fragment_probs(self: pyrosetta.rosetta.protocols.hybridization.CartesianHybridize, prob: float, randprob: float) → None

C++: protocols::hybridization::CartesianHybridize::set_fragment_probs(double, double) –> void

set_increase_cycles(self: pyrosetta.rosetta.protocols.hybridization.CartesianHybridize, increase_cycles_in: float) → None

C++: protocols::hybridization::CartesianHybridize::set_increase_cycles(double) –> 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_linmin_only(self: pyrosetta.rosetta.protocols.hybridization.CartesianHybridize, linmin_only_in: bool) → None

C++: protocols::hybridization::CartesianHybridize::set_linmin_only(bool) –> void

set_max_insertion(self: pyrosetta.rosetta.protocols.hybridization.CartesianHybridize, max_in: int) → None

C++: protocols::hybridization::CartesianHybridize::set_max_insertion(int) –> void

set_min_scorefunction(self: pyrosetta.rosetta.protocols.hybridization.CartesianHybridize, scorefxn_in: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: protocols::hybridization::CartesianHybridize::set_min_scorefunction(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_no_global_frame(self: pyrosetta.rosetta.protocols.hybridization.CartesianHybridize, no_global_frame_in: bool) → None

C++: protocols::hybridization::CartesianHybridize::set_no_global_frame(bool) –> void

set_pack_scorefunction(self: pyrosetta.rosetta.protocols.hybridization.CartesianHybridize, scorefxn_in: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: protocols::hybridization::CartesianHybridize::set_pack_scorefunction(class std::shared_ptr<class core::scoring::ScoreFunction>) –> void

set_per_residue_controls(self: pyrosetta.rosetta.protocols.hybridization.CartesianHybridize, residue_sample_template_in: pyrosetta.rosetta.utility.vector1_bool, residue_sample_abinitio_in: pyrosetta.rosetta.utility.vector1_bool) → None

C++: protocols::hybridization::CartesianHybridize::set_per_residue_controls(const class utility::vector1<bool, class std::allocator<bool> > &, const class utility::vector1<bool, class std::allocator<bool> > &) –> void

set_scorefunction(self: pyrosetta.rosetta.protocols.hybridization.CartesianHybridize, scorefxn_in: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: protocols::hybridization::CartesianHybridize::set_scorefunction(class std::shared_ptr<class core::scoring::ScoreFunction>) –> void

set_seqfrags_only(self: pyrosetta.rosetta.protocols.hybridization.CartesianHybridize, seqfrags_only_in: bool) → None

C++: protocols::hybridization::CartesianHybridize::set_seqfrags_only(bool) –> void

set_skip_long_min(self: pyrosetta.rosetta.protocols.hybridization.CartesianHybridize, skip_long_min_in: bool) → None

C++: protocols::hybridization::CartesianHybridize::set_skip_long_min(bool) –> void

set_temperature(self: pyrosetta.rosetta.protocols.hybridization.CartesianHybridize, temp_in: float) → None

C++: protocols::hybridization::CartesianHybridize::set_temperature(double) –> void

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

Set the ‘type’ string

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

show(*args, **kwargs)

Overloaded function.

1. show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None

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

Outputs details about the Mover, including current settings.

C++: protocols::moves::Mover::show(std::ostream &) const –> void

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

: Unit test support function. Apply one move to a given pose.

Allows extra test specific functions to be called before applying

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

type(*args, **kwargs)

Overloaded function.

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

Set the ‘type’ string

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

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

Get the set ‘type’ string

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

class pyrosetta.rosetta.protocols.hybridization.CartesianSampler

Bases: Mover

apply(self: pyrosetta.rosetta.protocols.hybridization.CartesianSampler, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::hybridization::CartesianSampler::apply(class core::pose::Pose &) –> void

apply_frame(self: pyrosetta.rosetta.protocols.hybridization.CartesianSampler, pose: pyrosetta.rosetta.core.pose.Pose, frame: pyrosetta.rosetta.core.fragment.Frame) → bool

C++: protocols::hybridization::CartesianSampler::apply_frame(class core::pose::Pose &, class core::fragment::Frame &) –> bool

assign(self: pyrosetta.rosetta.protocols.hybridization.CartesianSampler, : pyrosetta.rosetta.protocols.hybridization.CartesianSampler) → pyrosetta.rosetta.protocols.hybridization.CartesianSampler

C++: protocols::hybridization::CartesianSampler::operator=(const class protocols::hybridization::CartesianSampler &) –> class protocols::hybridization::CartesianSampler &

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

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

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

C++: protocols::hybridization::CartesianSampler::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 > > &

init(self: pyrosetta.rosetta.protocols.hybridization.CartesianSampler) → None

C++: protocols::hybridization::CartesianSampler::init() –> void

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::hybridization::CartesianSampler::mover_name() –> std::string

static name() → str

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

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

C++: protocols::hybridization::CartesianSampler::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::hybridization::CartesianSampler::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_bbmove(self: pyrosetta.rosetta.protocols.hybridization.CartesianSampler, bbmove_in: bool) → None

C++: protocols::hybridization::CartesianSampler::set_bbmove(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_fa_scorefunction(self: pyrosetta.rosetta.protocols.hybridization.CartesianSampler, scorefxn_in: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: protocols::hybridization::CartesianSampler::set_fa_scorefunction(class std::shared_ptr<class core::scoring::ScoreFunction>) –> void

set_frag_sizes(self: pyrosetta.rosetta.protocols.hybridization.CartesianSampler, frag_sizes_in: pyrosetta.rosetta.utility.vector1_unsigned_long) → None

C++: protocols::hybridization::CartesianSampler::set_frag_sizes(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> void

set_fullatom(self: pyrosetta.rosetta.protocols.hybridization.CartesianSampler, fullatom_in: bool) → None

C++: protocols::hybridization::CartesianSampler::set_fullatom(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_mc_scorefunction(self: pyrosetta.rosetta.protocols.hybridization.CartesianSampler, scorefxn_in: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: protocols::hybridization::CartesianSampler::set_mc_scorefunction(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_ncycles(self: pyrosetta.rosetta.protocols.hybridization.CartesianSampler, ncycles_in: int) → None

C++: protocols::hybridization::CartesianSampler::set_ncycles(unsigned long) –> void

set_nfrags(self: pyrosetta.rosetta.protocols.hybridization.CartesianSampler, nfrags_in: int) → None

C++: protocols::hybridization::CartesianSampler::set_nfrags(unsigned long) –> void

set_nminsteps(self: pyrosetta.rosetta.protocols.hybridization.CartesianSampler, nminsteps_in: int) → None

C++: protocols::hybridization::CartesianSampler::set_nminsteps(unsigned long) –> void

set_overlap(self: pyrosetta.rosetta.protocols.hybridization.CartesianSampler, overlap_in: int) → None

C++: protocols::hybridization::CartesianSampler::set_overlap(unsigned long) –> void

set_restore_csts(self: pyrosetta.rosetta.protocols.hybridization.CartesianSampler, restore_csts_in: bool) → None

C++: protocols::hybridization::CartesianSampler::set_restore_csts(bool) –> void

set_rms_cutoff(self: pyrosetta.rosetta.protocols.hybridization.CartesianSampler, rms_cutoff_in: float) → None

C++: protocols::hybridization::CartesianSampler::set_rms_cutoff(double) –> void

set_scorefunction(self: pyrosetta.rosetta.protocols.hybridization.CartesianSampler, scorefxn_in: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: protocols::hybridization::CartesianSampler::set_scorefunction(class std::shared_ptr<class core::scoring::ScoreFunction>) –> void

set_strategy(self: pyrosetta.rosetta.protocols.hybridization.CartesianSampler, strategy_in: str) → None

C++: protocols::hybridization::CartesianSampler::set_strategy(std::string) –> void

set_temp(self: pyrosetta.rosetta.protocols.hybridization.CartesianSampler, temp_in: float) → None

C++: protocols::hybridization::CartesianSampler::set_temp(double) –> void

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

Set the ‘type’ string

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

set_userpos(self: pyrosetta.rosetta.protocols.hybridization.CartesianSampler, user_pos_in: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector) → None

C++: protocols::hybridization::CartesianSampler::set_userpos(const class std::shared_ptr<const class core::select::residue_selector::ResidueSelector> &) –> 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.hybridization.CartesianSamplerCreator

Bases: MoverCreator

assign(self: pyrosetta.rosetta.protocols.hybridization.CartesianSamplerCreator, : pyrosetta.rosetta.protocols.hybridization.CartesianSamplerCreator) → pyrosetta.rosetta.protocols.hybridization.CartesianSamplerCreator

C++: protocols::hybridization::CartesianSamplerCreator::operator=(const class protocols::hybridization::CartesianSamplerCreator &) –> class protocols::hybridization::CartesianSamplerCreator &

create_mover(self: pyrosetta.rosetta.protocols.hybridization.CartesianSamplerCreator) → pyrosetta.rosetta.protocols.moves.Mover

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

keyname(self: pyrosetta.rosetta.protocols.hybridization.CartesianSamplerCreator) → str

C++: protocols::hybridization::CartesianSamplerCreator::keyname() const –> std::string

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

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

class pyrosetta.rosetta.protocols.hybridization.ChunkTrialMover

Bases: Mover

apply(self: pyrosetta.rosetta.protocols.hybridization.ChunkTrialMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::hybridization::ChunkTrialMover::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.hybridization.ChunkTrialMover, : pyrosetta.rosetta.protocols.hybridization.ChunkTrialMover) → pyrosetta.rosetta.protocols.hybridization.ChunkTrialMover

C++: protocols::hybridization::ChunkTrialMover::operator=(const class protocols::hybridization::ChunkTrialMover &) –> class protocols::hybridization::ChunkTrialMover &

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_alignment_from_template(self: pyrosetta.rosetta.protocols.hybridization.ChunkTrialMover, template_pose: pyrosetta.rosetta.core.pose.Pose, seqpos_alignment: pyrosetta.rosetta.std.map_unsigned_long_unsigned_long) → None

C++: protocols::hybridization::ChunkTrialMover::get_alignment_from_template(class std::shared_ptr<const class core::pose::Pose>, class std::map<unsigned long, unsigned long, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, unsigned long> > > &) –> void

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.hybridization.ChunkTrialMover) → str

C++: protocols::hybridization::ChunkTrialMover::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

has_valid_moves(self: pyrosetta.rosetta.protocols.hybridization.ChunkTrialMover) → bool

C++: protocols::hybridization::ChunkTrialMover::has_valid_moves() –> bool

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

non-const accessor

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

last_proposal_density_ratio(self: pyrosetta.rosetta.protocols.moves.Mover) → float

C++: protocols::moves::Mover::last_proposal_density_ratio() –> double

static name() → str

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

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

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

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

pick_random_chunk(self: pyrosetta.rosetta.protocols.hybridization.ChunkTrialMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::hybridization::ChunkTrialMover::pick_random_chunk(class core::pose::Pose &) –> void

pick_random_template(self: pyrosetta.rosetta.protocols.hybridization.ChunkTrialMover) → None

C++: protocols::hybridization::ChunkTrialMover::pick_random_template() –> 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_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_registry_shift(self: pyrosetta.rosetta.protocols.hybridization.ChunkTrialMover, max_registry_shift_in: int) → None

C++: protocols::hybridization::ChunkTrialMover::set_max_registry_shift(unsigned long) –> 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_template(self: pyrosetta.rosetta.protocols.hybridization.ChunkTrialMover, template_number: int) → None

C++: protocols::hybridization::ChunkTrialMover::set_template(const unsigned long) –> void

set_templates_to_ignore(self: pyrosetta.rosetta.protocols.hybridization.ChunkTrialMover, template_indices_in: pyrosetta.rosetta.std.set_unsigned_long_t) → None

C++: protocols::hybridization::ChunkTrialMover::set_templates_to_ignore(class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >) –> 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

template_number(self: pyrosetta.rosetta.protocols.hybridization.ChunkTrialMover) → int

C++: protocols::hybridization::ChunkTrialMover::template_number() –> unsigned long

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

trial_counter(self: pyrosetta.rosetta.protocols.hybridization.ChunkTrialMover, ires: int) → int

C++: protocols::hybridization::ChunkTrialMover::trial_counter(unsigned long) –> unsigned long

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.hybridization.DDomainParse

Bases: pybind11_object

split(self: pyrosetta.rosetta.protocols.hybridization.DDomainParse, templ: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.utility.vector1_protocols_loops_Loops

C++: protocols::hybridization::DDomainParse::split(const class core::pose::Pose &) –> class utility::vector1<class protocols::loops::Loops, class std::allocator<class protocols::loops::Loops> >

class pyrosetta.rosetta.protocols.hybridization.DomainAssembly

Bases: Mover

apply(self: pyrosetta.rosetta.protocols.hybridization.DomainAssembly, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::hybridization::DomainAssembly::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.hybridization.DomainAssembly, : pyrosetta.rosetta.protocols.hybridization.DomainAssembly) → pyrosetta.rosetta.protocols.hybridization.DomainAssembly

C++: protocols::hybridization::DomainAssembly::operator=(const class protocols::hybridization::DomainAssembly &) –> class protocols::hybridization::DomainAssembly &

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.hybridization.DomainAssembly) → str

C++: protocols::hybridization::DomainAssembly::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 name() → str

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

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

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

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

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

Provide citations to the passed CitationCollectionList

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

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

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

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

run(self: pyrosetta.rosetta.protocols.hybridization.DomainAssembly) → None

C++: protocols::hybridization::DomainAssembly::run() –> 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_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.hybridization.FoldTreeHybridize

Bases: Mover

apply(self: pyrosetta.rosetta.protocols.hybridization.FoldTreeHybridize, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::hybridization::FoldTreeHybridize::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.hybridization.FoldTreeHybridize, : pyrosetta.rosetta.protocols.hybridization.FoldTreeHybridize) → pyrosetta.rosetta.protocols.hybridization.FoldTreeHybridize

C++: protocols::hybridization::FoldTreeHybridize::operator=(const class protocols::hybridization::FoldTreeHybridize &) –> class protocols::hybridization::FoldTreeHybridize &

center_of_mass(self: pyrosetta.rosetta.protocols.hybridization.FoldTreeHybridize, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.numeric.xyzVector_double_t

C++: protocols::hybridization::FoldTreeHybridize::center_of_mass(const class core::pose::Pose &) –> class numeric::xyzVector<double>

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.hybridization.FoldTreeHybridize) → str

C++: protocols::hybridization::FoldTreeHybridize::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_pairings_residues(self: pyrosetta.rosetta.protocols.hybridization.FoldTreeHybridize) → pyrosetta.rosetta.std.set_unsigned_long_t

C++: protocols::hybridization::FoldTreeHybridize::get_pairings_residues() –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

get_residue_weights(self: pyrosetta.rosetta.protocols.hybridization.FoldTreeHybridize, pose: pyrosetta.rosetta.core.pose.Pose, wt1: pyrosetta.rosetta.utility.vector1_double, wt3: pyrosetta.rosetta.utility.vector1_double, wt9: pyrosetta.rosetta.utility.vector1_double) → None

C++: protocols::hybridization::FoldTreeHybridize::get_residue_weights(class core::pose::Pose &, class utility::vector1<double, class std::allocator<double> > &, class utility::vector1<double, class std::allocator<double> > &, class utility::vector1<double, class std::allocator<double> > &) –> void

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_strand_pairs(self: pyrosetta.rosetta.protocols.hybridization.FoldTreeHybridize) → pyrosetta.rosetta.utility.vector1_std_pair_unsigned_long_unsigned_long_t

C++: protocols::hybridization::FoldTreeHybridize::get_strand_pairs() –> class utility::vector1<struct std::pair<unsigned long, unsigned long>, class std::allocator<struct std::pair<unsigned long, unsigned long> > >

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

init(self: pyrosetta.rosetta.protocols.hybridization.FoldTreeHybridize) → None

C++: protocols::hybridization::FoldTreeHybridize::init() –> void

last_proposal_density_ratio(self: pyrosetta.rosetta.protocols.moves.Mover) → float

C++: protocols::moves::Mover::last_proposal_density_ratio() –> double

static name() → str

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

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

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

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

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

Provide citations to the passed CitationCollectionList

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

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

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

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

restore_original_foldtree(self: pyrosetta.rosetta.protocols.hybridization.FoldTreeHybridize, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::hybridization::FoldTreeHybridize::restore_original_foldtree(class core::pose::Pose &) –> void

set_add_hetatm(self: pyrosetta.rosetta.protocols.hybridization.FoldTreeHybridize, add_hetatm_in: bool, hetatm_self_cst_weight_in: float, hetatm_prot_cst_weight_in: float) → None

C++: protocols::hybridization::FoldTreeHybridize::set_add_hetatm(bool, double, double) –> void

set_add_non_init_chunks(self: pyrosetta.rosetta.protocols.hybridization.FoldTreeHybridize, add_non_init_chunks_in: float) → None

C++: protocols::hybridization::FoldTreeHybridize::set_add_non_init_chunks(double) –> void

set_auto_frag_insertion_weight(self: pyrosetta.rosetta.protocols.hybridization.FoldTreeHybridize, auto_frag_insertion_weight_in: bool) → None

C++: protocols::hybridization::FoldTreeHybridize::set_auto_frag_insertion_weight(bool) –> void

set_big_frag_insertion_weight(self: pyrosetta.rosetta.protocols.hybridization.FoldTreeHybridize, big_frag_insertion_weight_in: float) → None

C++: protocols::hybridization::FoldTreeHybridize::set_big_frag_insertion_weight(double) –> void

set_chunk_insertion_weight(self: pyrosetta.rosetta.protocols.hybridization.FoldTreeHybridize, chunk_insertion_weight_in: float) → None

C++: protocols::hybridization::FoldTreeHybridize::set_chunk_insertion_weight(double) –> void

set_constraint(self: pyrosetta.rosetta.protocols.hybridization.FoldTreeHybridize, cst_in: str) → None

C++: protocols::hybridization::FoldTreeHybridize::set_constraint(std::string &) –> void

set_constraint_file(self: pyrosetta.rosetta.protocols.hybridization.FoldTreeHybridize, cst_file_in: str) → None

C++: protocols::hybridization::FoldTreeHybridize::set_constraint_file(std::string) –> 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_filter_templates(self: pyrosetta.rosetta.protocols.hybridization.FoldTreeHybridize, filter_templates_in: bool) → None

C++: protocols::hybridization::FoldTreeHybridize::set_filter_templates(bool) –> void

set_frag_1mer_insertion_weight(self: pyrosetta.rosetta.protocols.hybridization.FoldTreeHybridize, frag_1mer_insertion_weight_in: float) → None

C++: protocols::hybridization::FoldTreeHybridize::set_frag_1mer_insertion_weight(double) –> void

set_frag_weight_aligned(self: pyrosetta.rosetta.protocols.hybridization.FoldTreeHybridize, frag_weight_aligned_in: float) → None

C++: protocols::hybridization::FoldTreeHybridize::set_frag_weight_aligned(double) –> void

set_increase_cycles(self: pyrosetta.rosetta.protocols.hybridization.FoldTreeHybridize, increase_cycles_in: float) → None

C++: protocols::hybridization::FoldTreeHybridize::set_increase_cycles(double) –> 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_insertion(self: pyrosetta.rosetta.protocols.hybridization.FoldTreeHybridize, max_in: int) → None

C++: protocols::hybridization::FoldTreeHybridize::set_max_insertion(int) –> void

set_max_registry_shift(self: pyrosetta.rosetta.protocols.hybridization.FoldTreeHybridize, max_registry_shift_in: int) → None

C++: protocols::hybridization::FoldTreeHybridize::set_max_registry_shift(unsigned long) –> void

set_minimize_at_end(self: pyrosetta.rosetta.protocols.hybridization.FoldTreeHybridize, min_at_end_in: bool) → None

C++: protocols::hybridization::FoldTreeHybridize::set_minimize_at_end(bool) –> void

set_minimize_sf(self: pyrosetta.rosetta.protocols.hybridization.FoldTreeHybridize, minscorefxn_in: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: protocols::hybridization::FoldTreeHybridize::set_minimize_sf(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_pairings_file(self: pyrosetta.rosetta.protocols.hybridization.FoldTreeHybridize, pairings_file_in: str) → None

C++: protocols::hybridization::FoldTreeHybridize::set_pairings_file(std::string) –> void

set_per_residue_controls(self: pyrosetta.rosetta.protocols.hybridization.FoldTreeHybridize, residue_sample_template_in: pyrosetta.rosetta.utility.vector1_bool, residue_sample_abinitio_in: pyrosetta.rosetta.utility.vector1_bool) → None

C++: protocols::hybridization::FoldTreeHybridize::set_per_residue_controls(const class utility::vector1<bool, class std::allocator<bool> > &, const class utility::vector1<bool, class std::allocator<bool> > &) –> void

set_random_sheets(self: pyrosetta.rosetta.protocols.hybridization.FoldTreeHybridize, random_sheets_in: pyrosetta.rosetta.utility.vector1_unsigned_long) → None

C++: protocols::hybridization::FoldTreeHybridize::set_random_sheets(class utility::vector1<unsigned long, class std::allocator<unsigned long> >) –> void

set_scorefunction(self: pyrosetta.rosetta.protocols.hybridization.FoldTreeHybridize, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: protocols::hybridization::FoldTreeHybridize::set_scorefunction(class std::shared_ptr<class core::scoring::ScoreFunction>) –> void

set_sheets(self: pyrosetta.rosetta.protocols.hybridization.FoldTreeHybridize, sheets_in: pyrosetta.rosetta.utility.vector1_unsigned_long) → None

C++: protocols::hybridization::FoldTreeHybridize::set_sheets(class utility::vector1<unsigned long, class std::allocator<unsigned long> >) –> void

set_small_frag_insertion_weight(self: pyrosetta.rosetta.protocols.hybridization.FoldTreeHybridize, small_frag_insertion_weight_in: float) → None

C++: protocols::hybridization::FoldTreeHybridize::set_small_frag_insertion_weight(double) –> void

set_stage1_1_cycles(self: pyrosetta.rosetta.protocols.hybridization.FoldTreeHybridize, stage1_1_cycles_in: int) → None

C++: protocols::hybridization::FoldTreeHybridize::set_stage1_1_cycles(unsigned long) –> void

set_stage1_2_cycles(self: pyrosetta.rosetta.protocols.hybridization.FoldTreeHybridize, stage1_2_cycles_in: int) → None

C++: protocols::hybridization::FoldTreeHybridize::set_stage1_2_cycles(unsigned long) –> void

set_stage1_3_cycles(self: pyrosetta.rosetta.protocols.hybridization.FoldTreeHybridize, stage1_3_cycles_in: int) → None

C++: protocols::hybridization::FoldTreeHybridize::set_stage1_3_cycles(unsigned long) –> void

set_stage1_4_cycles(self: pyrosetta.rosetta.protocols.hybridization.FoldTreeHybridize, stage1_4_cycles_in: int) → None

C++: protocols::hybridization::FoldTreeHybridize::set_stage1_4_cycles(unsigned long) –> void

set_top_n_big_frag(self: pyrosetta.rosetta.protocols.hybridization.FoldTreeHybridize, top_n_big_frag_in: int) → None

C++: protocols::hybridization::FoldTreeHybridize::set_top_n_big_frag(unsigned long) –> void

set_top_n_small_frag(self: pyrosetta.rosetta.protocols.hybridization.FoldTreeHybridize, top_n_small_frag_in: int) → None

C++: protocols::hybridization::FoldTreeHybridize::set_top_n_small_frag(unsigned long) –> 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_user_csts(self: pyrosetta.rosetta.protocols.hybridization.FoldTreeHybridize, user_csts_in: pyrosetta.rosetta.utility.vector1_unsigned_long) → None

C++: protocols::hybridization::FoldTreeHybridize::set_user_csts(class utility::vector1<unsigned long, class std::allocator<unsigned long> >) –> void

setup_foldtree(self: pyrosetta.rosetta.protocols.hybridization.FoldTreeHybridize, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::hybridization::FoldTreeHybridize::setup_foldtree(class core::pose::Pose &) –> void

setup_scorefunctions(self: pyrosetta.rosetta.protocols.hybridization.FoldTreeHybridize, score0: pyrosetta.rosetta.core.scoring.ScoreFunction, score1: pyrosetta.rosetta.core.scoring.ScoreFunction, score2: pyrosetta.rosetta.core.scoring.ScoreFunction, score5: pyrosetta.rosetta.core.scoring.ScoreFunction, score3: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: protocols::hybridization::FoldTreeHybridize::setup_scorefunctions(class std::shared_ptr<class core::scoring::ScoreFunction>, class std::shared_ptr<class core::scoring::ScoreFunction>, class std::shared_ptr<class core::scoring::ScoreFunction>, class std::shared_ptr<class core::scoring::ScoreFunction>, class std::shared_ptr<class core::scoring::ScoreFunction>) –> 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

translate_virt_to_CoM(self: pyrosetta.rosetta.protocols.hybridization.FoldTreeHybridize, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::hybridization::FoldTreeHybridize::translate_virt_to_CoM(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.hybridization.FragmentBiasAssigner

Bases: pybind11_object

assign(self: pyrosetta.rosetta.protocols.hybridization.FragmentBiasAssigner, : pyrosetta.rosetta.protocols.hybridization.FragmentBiasAssigner) → pyrosetta.rosetta.protocols.hybridization.FragmentBiasAssigner

C++: protocols::hybridization::FragmentBiasAssigner::operator=(const class protocols::hybridization::FragmentBiasAssigner &) –> class protocols::hybridization::FragmentBiasAssigner &

automode(self: pyrosetta.rosetta.protocols.hybridization.FragmentBiasAssigner, pose: pyrosetta.rosetta.core.pose.Pose, score_cut: float) → None

C++: protocols::hybridization::FragmentBiasAssigner::automode(class core::pose::Pose &, double) –> void

automode_scores(self: pyrosetta.rosetta.protocols.hybridization.FragmentBiasAssigner, pose: pyrosetta.rosetta.core.pose.Pose, scores: pyrosetta.rosetta.std.map_unsigned_long_double) → None

C++: protocols::hybridization::FragmentBiasAssigner::automode_scores(class core::pose::Pose &, class std::map<unsigned long, double, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, double> > > &) –> void

bfactors(self: pyrosetta.rosetta.protocols.hybridization.FragmentBiasAssigner, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::hybridization::FragmentBiasAssigner::bfactors(class core::pose::Pose &) –> void

chainbreak(self: pyrosetta.rosetta.protocols.hybridization.FragmentBiasAssigner, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::hybridization::FragmentBiasAssigner::chainbreak(class core::pose::Pose &) –> void

compute_frag_bias(self: pyrosetta.rosetta.protocols.hybridization.FragmentBiasAssigner, frag_bias: pyrosetta.rosetta.utility.vector1_numeric_random_WeightedSampler, pose: pyrosetta.rosetta.core.pose.Pose, fragments: pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_fragment_FragSet_t) → None

C++: protocols::hybridization::FragmentBiasAssigner::compute_frag_bias(class utility::vector1<class numeric::random::WeightedSampler, class std::allocator<class numeric::random::WeightedSampler> > &, class core::pose::Pose &, class utility::vector1<class std::shared_ptr<class core::fragment::FragSet>, class std::allocator<class std::shared_ptr<class core::fragment::FragSet> > >) –> void

cumulate_probability(self: pyrosetta.rosetta.protocols.hybridization.FragmentBiasAssigner) → None

C++: protocols::hybridization::FragmentBiasAssigner::cumulate_probability() –> void

density(self: pyrosetta.rosetta.protocols.hybridization.FragmentBiasAssigner, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::hybridization::FragmentBiasAssigner::density(class core::pose::Pose &) –> void

density_nbr(self: pyrosetta.rosetta.protocols.hybridization.FragmentBiasAssigner, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::hybridization::FragmentBiasAssigner::density_nbr(class core::pose::Pose &) –> void

exclude_residues(self: pyrosetta.rosetta.protocols.hybridization.FragmentBiasAssigner, residues_to_exclude: pyrosetta.rosetta.std.set_unsigned_long_t) → None

C++: protocols::hybridization::FragmentBiasAssigner::exclude_residues(class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >) –> void

fragbias_reporter(self: pyrosetta.rosetta.protocols.hybridization.FragmentBiasAssigner, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::hybridization::FragmentBiasAssigner::fragbias_reporter(class core::pose::Pose &) –> void

geometry(*args, **kwargs)

Overloaded function.

1. geometry(self: pyrosetta.rosetta.protocols.hybridization.FragmentBiasAssigner, pose: pyrosetta.rosetta.core.pose.Pose) -> None

2. geometry(self: pyrosetta.rosetta.protocols.hybridization.FragmentBiasAssigner, pose: pyrosetta.rosetta.core.pose.Pose, weight: float) -> None

C++: protocols::hybridization::FragmentBiasAssigner::geometry(class core::pose::Pose &, double) –> void

include_residues(self: pyrosetta.rosetta.protocols.hybridization.FragmentBiasAssigner, residues_to_include: pyrosetta.rosetta.std.set_unsigned_long_t) → None

C++: protocols::hybridization::FragmentBiasAssigner::include_residues(class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >) –> void

init(self: pyrosetta.rosetta.protocols.hybridization.FragmentBiasAssigner, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::hybridization::FragmentBiasAssigner::init(class core::pose::Pose &) –> void

rama(*args, **kwargs)

Overloaded function.

1. rama(self: pyrosetta.rosetta.protocols.hybridization.FragmentBiasAssigner, pose: pyrosetta.rosetta.core.pose.Pose) -> None

2. rama(self: pyrosetta.rosetta.protocols.hybridization.FragmentBiasAssigner, pose: pyrosetta.rosetta.core.pose.Pose, weight: float) -> None

C++: protocols::hybridization::FragmentBiasAssigner::rama(class core::pose::Pose &, double) –> void

set_rsd_wdw_to_assign_prob(*args, **kwargs)

Overloaded function.

1. set_rsd_wdw_to_assign_prob(self: pyrosetta.rosetta.protocols.hybridization.FragmentBiasAssigner) -> None

2. set_rsd_wdw_to_assign_prob(self: pyrosetta.rosetta.protocols.hybridization.FragmentBiasAssigner, wdw: int) -> None

C++: protocols::hybridization::FragmentBiasAssigner::set_rsd_wdw_to_assign_prob(int) –> void

set_score_threshold(self: pyrosetta.rosetta.protocols.hybridization.FragmentBiasAssigner, threshold: float) → None

C++: protocols::hybridization::FragmentBiasAssigner::set_score_threshold(double) –> void

set_wdw_to_freeze(*args, **kwargs)

Overloaded function.

1. set_wdw_to_freeze(self: pyrosetta.rosetta.protocols.hybridization.FragmentBiasAssigner) -> None

2. set_wdw_to_freeze(self: pyrosetta.rosetta.protocols.hybridization.FragmentBiasAssigner, wdw: int) -> None

C++: protocols::hybridization::FragmentBiasAssigner::set_wdw_to_freeze(int) –> void

uniform(self: pyrosetta.rosetta.protocols.hybridization.FragmentBiasAssigner) → None

C++: protocols::hybridization::FragmentBiasAssigner::uniform() –> void

user(self: pyrosetta.rosetta.protocols.hybridization.FragmentBiasAssigner, user_pos: pyrosetta.rosetta.std.set_unsigned_long_t, loops: pyrosetta.rosetta.protocols.loops.Loops) → None

C++: protocols::hybridization::FragmentBiasAssigner::user(class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >, class std::shared_ptr<class protocols::loops::Loops>) –> void

class pyrosetta.rosetta.protocols.hybridization.HybridizeFoldtreeDynamic

Bases: pybind11_object

assign(self: pyrosetta.rosetta.protocols.hybridization.HybridizeFoldtreeDynamic, : pyrosetta.rosetta.protocols.hybridization.HybridizeFoldtreeDynamic) → pyrosetta.rosetta.protocols.hybridization.HybridizeFoldtreeDynamic

C++: protocols::hybridization::HybridizeFoldtreeDynamic::operator=(const class protocols::hybridization::HybridizeFoldtreeDynamic &) –> class protocols::hybridization::HybridizeFoldtreeDynamic &

get_anchors(self: pyrosetta.rosetta.protocols.hybridization.HybridizeFoldtreeDynamic) → pyrosetta.rosetta.utility.vector1_unsigned_long

C++: protocols::hybridization::HybridizeFoldtreeDynamic::get_anchors() –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

initialize(self: pyrosetta.rosetta.protocols.hybridization.HybridizeFoldtreeDynamic, pose: pyrosetta.rosetta.core.pose.Pose, core_chunks: pyrosetta.rosetta.protocols.loops.Loops, strand_pairs: pyrosetta.rosetta.utility.vector1_std_pair_unsigned_long_unsigned_long_t, strand_pair_library_positions: pyrosetta.rosetta.std.set_unsigned_long_t) → None

C++: protocols::hybridization::HybridizeFoldtreeDynamic::initialize(class core::pose::Pose &, const class protocols::loops::Loops &, const class utility::vector1<struct std::pair<unsigned long, unsigned long>, class std::allocator<struct std::pair<unsigned long, unsigned long> > > &, const class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> > &) –> void

reset(self: pyrosetta.rosetta.protocols.hybridization.HybridizeFoldtreeDynamic, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::hybridization::HybridizeFoldtreeDynamic::reset(class core::pose::Pose &) –> void

class pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol

Bases: Mover

add_big_fragments(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol, newval: pyrosetta.rosetta.core.fragment.FragSet) → None

C++: protocols::hybridization::HybridizeProtocol::add_big_fragments(class std::shared_ptr<class core::fragment::FragSet>) –> void

add_fragment_csts(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::hybridization::HybridizeProtocol::add_fragment_csts(class core::pose::Pose &) –> void

add_null_template(*args, **kwargs)

Overloaded function.

1. add_null_template(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol, template_pose: pyrosetta.rosetta.core.pose.Pose, cst_fn: str) -> None

2. add_null_template(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol, template_pose: pyrosetta.rosetta.core.pose.Pose, cst_fn: str, symmdef_file: str) -> None

3. add_null_template(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol, template_pose: pyrosetta.rosetta.core.pose.Pose, cst_fn: str, symmdef_file: str, weight: float) -> None

C++: protocols::hybridization::HybridizeProtocol::add_null_template(class std::shared_ptr<class core::pose::Pose>, std::string, std::string, double) –> void

add_small_fragments(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol, newval: pyrosetta.rosetta.core.fragment.FragSet) → None

C++: protocols::hybridization::HybridizeProtocol::add_small_fragments(class std::shared_ptr<class core::fragment::FragSet>) –> void

add_template(*args, **kwargs)

Overloaded function.

1. add_template(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol, template_fn: str, cst_fn: str) -> None

2. add_template(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol, template_fn: str, cst_fn: str, symmdef_file: str) -> None

3. add_template(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol, template_fn: str, cst_fn: str, symmdef_file: str, weight: float) -> None

4. add_template(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol, template_fn: str, cst_fn: str, symmdef_file: str, weight: float, rand_chains: pyrosetta.rosetta.utility.vector1_char) -> None

5. add_template(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol, template_fn: str, cst_fn: str, symmdef_file: str, weight: float, rand_chains: pyrosetta.rosetta.utility.vector1_char, align_pdb_info: bool) -> None

C++: protocols::hybridization::HybridizeProtocol::add_template(const std::string &, const std::string &, const std::string &, const double, const class utility::vector1<char, class std::allocator<char> > &, const bool) –> void

6. add_template(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol, template_pose: pyrosetta.rosetta.core.pose.Pose, cst_fn: str) -> None

7. add_template(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol, template_pose: pyrosetta.rosetta.core.pose.Pose, cst_fn: str, symmdef_file: str) -> None

8. add_template(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol, template_pose: pyrosetta.rosetta.core.pose.Pose, cst_fn: str, symmdef_file: str, weight: float) -> None

9. add_template(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol, template_pose: pyrosetta.rosetta.core.pose.Pose, cst_fn: str, symmdef_file: str, weight: float, rand_chains: pyrosetta.rosetta.utility.vector1_char) -> None

10. add_template(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol, template_pose: pyrosetta.rosetta.core.pose.Pose, cst_fn: str, symmdef_file: str, weight: float, rand_chains: pyrosetta.rosetta.utility.vector1_char, filename: str) -> None

11. add_template(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol, template_pose: pyrosetta.rosetta.core.pose.Pose, cst_fn: str, symmdef_file: str, weight: float, rand_chains: pyrosetta.rosetta.utility.vector1_char, filename: str, align_pdb_info: bool) -> None

C++: protocols::hybridization::HybridizeProtocol::add_template(class std::shared_ptr<class core::pose::Pose>, const std::string &, const std::string &, const double, const class utility::vector1<char, class std::allocator<char> > &, const std::string &, const bool) –> void

align_by_domain(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol, pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.Pose, domains: pyrosetta.rosetta.utility.vector1_protocols_loops_Loops) → None

C++: protocols::hybridization::HybridizeProtocol::align_by_domain(class core::pose::Pose &, const class core::pose::Pose &, class utility::vector1<class protocols::loops::Loops, class std::allocator<class protocols::loops::Loops> >) –> void

align_templates_by_domain(*args, **kwargs)

Overloaded function.

1. align_templates_by_domain(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol, ref_pose: pyrosetta.rosetta.core.pose.Pose) -> None

2. align_templates_by_domain(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol, ref_pose: pyrosetta.rosetta.core.pose.Pose, domains: pyrosetta.rosetta.utility.vector1_protocols_loops_Loops) -> None

C++: protocols::hybridization::HybridizeProtocol::align_templates_by_domain(class std::shared_ptr<class core::pose::Pose> &, class utility::vector1<class protocols::loops::Loops, class std::allocator<class protocols::loops::Loops> >) –> void

apply(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol, : pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::hybridization::HybridizeProtocol::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol, : pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol) → pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol

C++: protocols::hybridization::HybridizeProtocol::operator=(const class protocols::hybridization::HybridizeProtocol &) –> class protocols::hybridization::HybridizeProtocol &

check_and_create_fragments(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol, : pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::hybridization::HybridizeProtocol::check_and_create_fragments(class core::pose::Pose &) –> void

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

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

clear_info is called by jd2 before calling apply

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

clone(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::hybridization::HybridizeProtocol::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>

do_intrastage_docking(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::hybridization::HybridizeProtocol::do_intrastage_docking(class core::pose::Pose &) –> void

domain_parse_templates(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol, nres: int) → None

C++: protocols::hybridization::HybridizeProtocol::domain_parse_templates(unsigned long) –> void

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

C++: protocols::hybridization::HybridizeProtocol::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_disulf_file(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol) → str

C++: protocols::hybridization::HybridizeProtocol::get_disulf_file() const –> 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.hybridization.HybridizeProtocol) → str

C++: protocols::hybridization::HybridizeProtocol::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 > > &

init(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol) → None

C++: protocols::hybridization::HybridizeProtocol::init() –> void

initialize_and_sample_loops(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol, pose: pyrosetta.rosetta.core.pose.Pose, chosen_templ: pyrosetta.rosetta.core.pose.Pose, template_contigs_icluster: pyrosetta.rosetta.protocols.loops.Loops, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: protocols::hybridization::HybridizeProtocol::initialize_and_sample_loops(class core::pose::Pose &, class std::shared_ptr<class core::pose::Pose>, class protocols::loops::Loops, class std::shared_ptr<class core::scoring::ScoreFunction>) –> void

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::hybridization::HybridizeProtocol::mover_name() –> std::string

static name() → str

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

parse_my_tag(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol, : pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None

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

pick_starting_template(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol) → int

C++: protocols::hybridization::HybridizeProtocol::pick_starting_template() –> unsigned long

provide_citation_info(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None

Provide the citation.

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

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

C++: protocols::hybridization::HybridizeProtocol::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_add_hetatm(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol, add_hetatm: bool) → None

C++: protocols::hybridization::HybridizeProtocol::set_add_hetatm(bool) –> void

set_batch_relax(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol, newval: int) → None

C++: protocols::hybridization::HybridizeProtocol::set_batch_relax(unsigned long) –> 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_disulf_file(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol, dsf: str) → None

C++: protocols::hybridization::HybridizeProtocol::set_disulf_file(const std::string &) –> void

set_fullatom_scorefxn(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol, newval: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: protocols::hybridization::HybridizeProtocol::set_fullatom_scorefxn(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_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_stage1_increase_cycles(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol, newval: float) → None

C++: protocols::hybridization::HybridizeProtocol::set_stage1_increase_cycles(double) –> void

set_stage1_scorefxn(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol, newval: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: protocols::hybridization::HybridizeProtocol::set_stage1_scorefxn(class std::shared_ptr<class core::scoring::ScoreFunction>) –> void

set_stage2_increase_cycles(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol, newval: float) → None

C++: protocols::hybridization::HybridizeProtocol::set_stage2_increase_cycles(double) –> void

set_stage2_scorefxn(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol, newval: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: protocols::hybridization::HybridizeProtocol::set_stage2_scorefxn(class std::shared_ptr<class core::scoring::ScoreFunction>) –> void

set_stage2min_scorefxn(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol, newval: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: protocols::hybridization::HybridizeProtocol::set_stage2min_scorefxn(class std::shared_ptr<class core::scoring::ScoreFunction>) –> void

set_stage2pack_scorefxn(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol, newval: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: protocols::hybridization::HybridizeProtocol::set_stage2pack_scorefxn(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

setup_templates_and_sampling_options(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::hybridization::HybridizeProtocol::setup_templates_and_sampling_options(const class core::pose::Pose &) –> 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 &

update_template(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol, template_idx: int) → None

C++: protocols::hybridization::HybridizeProtocol::update_template(const unsigned long) –> void

validate_template(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocol, filename: str, fasta: str, template_pose: pyrosetta.rosetta.core.pose.Pose, align_pdb_info: bool) → None

C++: protocols::hybridization::HybridizeProtocol::validate_template(const std::string &, const std::string &, class std::shared_ptr<class core::pose::Pose>, bool &) –> void

class pyrosetta.rosetta.protocols.hybridization.HybridizeProtocolCreator

Bases: MoverCreator

assign(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocolCreator, : pyrosetta.rosetta.protocols.hybridization.HybridizeProtocolCreator) → pyrosetta.rosetta.protocols.hybridization.HybridizeProtocolCreator

C++: protocols::hybridization::HybridizeProtocolCreator::operator=(const class protocols::hybridization::HybridizeProtocolCreator &) –> class protocols::hybridization::HybridizeProtocolCreator &

create_mover(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocolCreator) → pyrosetta.rosetta.protocols.moves.Mover

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

keyname(self: pyrosetta.rosetta.protocols.hybridization.HybridizeProtocolCreator) → str

C++: protocols::hybridization::HybridizeProtocolCreator::keyname() const –> std::string

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

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

class pyrosetta.rosetta.protocols.hybridization.InsertChunkMover

Bases: Mover

apply(self: pyrosetta.rosetta.protocols.hybridization.InsertChunkMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::hybridization::InsertChunkMover::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.hybridization.InsertChunkMover, : pyrosetta.rosetta.protocols.hybridization.InsertChunkMover) → pyrosetta.rosetta.protocols.hybridization.InsertChunkMover

C++: protocols::hybridization::InsertChunkMover::operator=(const class protocols::hybridization::InsertChunkMover &) –> class protocols::hybridization::InsertChunkMover &

check_overlap(self: pyrosetta.rosetta.protocols.hybridization.InsertChunkMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::hybridization::InsertChunkMover::check_overlap(class core::pose::Pose &) –> void

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

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

clear_info is called by jd2 before calling apply

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

clone(self: pyrosetta.rosetta.protocols.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_local_sequence_mapping(*args, **kwargs)

Overloaded function.

1. get_local_sequence_mapping(self: pyrosetta.rosetta.protocols.hybridization.InsertChunkMover, pose: pyrosetta.rosetta.core.pose.Pose) -> bool

2. get_local_sequence_mapping(self: pyrosetta.rosetta.protocols.hybridization.InsertChunkMover, pose: pyrosetta.rosetta.core.pose.Pose, registry_shift: int) -> bool

3. get_local_sequence_mapping(self: pyrosetta.rosetta.protocols.hybridization.InsertChunkMover, pose: pyrosetta.rosetta.core.pose.Pose, registry_shift: int, MAX_TRIAL: int) -> bool

C++: protocols::hybridization::InsertChunkMover::get_local_sequence_mapping(class core::pose::Pose &, int, unsigned long) –> bool

get_name(self: pyrosetta.rosetta.protocols.hybridization.InsertChunkMover) → str

C++: protocols::hybridization::InsertChunkMover::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 > > &

init(self: pyrosetta.rosetta.protocols.hybridization.InsertChunkMover) → None

C++: protocols::hybridization::InsertChunkMover::init() –> void

last_proposal_density_ratio(self: pyrosetta.rosetta.protocols.moves.Mover) → float

C++: protocols::moves::Mover::last_proposal_density_ratio() –> double

static name() → str

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

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

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

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

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

Provide citations to the passed CitationCollectionList

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

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

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

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_aligned_chunk(self: pyrosetta.rosetta.protocols.hybridization.InsertChunkMover, pose: pyrosetta.rosetta.core.pose.Pose, jump_number: int, anchor_insert_only_in: bool) → None

C++: protocols::hybridization::InsertChunkMover::set_aligned_chunk(const class core::pose::Pose &, const unsigned long, bool) –> void

set_bb_xyz_aligned(self: pyrosetta.rosetta.protocols.hybridization.InsertChunkMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::hybridization::InsertChunkMover::set_bb_xyz_aligned(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_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_registry_shift(self: pyrosetta.rosetta.protocols.hybridization.InsertChunkMover, registry_shift: int) → None

C++: protocols::hybridization::InsertChunkMover::set_registry_shift(int) –> void

set_template(self: pyrosetta.rosetta.protocols.hybridization.InsertChunkMover, template_pose: pyrosetta.rosetta.core.pose.Pose, template_id: int, sequence_alignment: pyrosetta.rosetta.std.map_unsigned_long_unsigned_long) → None

C++: protocols::hybridization::InsertChunkMover::set_template(class std::shared_ptr<const class core::pose::Pose>, unsigned long, const class std::map<unsigned long, unsigned long, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, unsigned long> > > &) –> 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

success(self: pyrosetta.rosetta.protocols.hybridization.InsertChunkMover) → bool

C++: protocols::hybridization::InsertChunkMover::success() –> bool

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

: Unit test support function. Apply one move to a given pose.

Allows extra test specific functions to be called before applying

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

trial_counter(self: pyrosetta.rosetta.protocols.hybridization.InsertChunkMover, ires: int) → int

C++: protocols::hybridization::InsertChunkMover::trial_counter(unsigned long) –> unsigned long

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.hybridization.MRMover

Bases: Mover

apply(self: pyrosetta.rosetta.protocols.hybridization.MRMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::hybridization::MRMover::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.hybridization.MRMover, : pyrosetta.rosetta.protocols.hybridization.MRMover) → pyrosetta.rosetta.protocols.hybridization.MRMover

C++: protocols::hybridization::MRMover::operator=(const class protocols::hybridization::MRMover &) –> class protocols::hybridization::MRMover &

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

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

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

C++: protocols::hybridization::MRMover::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 > > &

init(self: pyrosetta.rosetta.protocols.hybridization.MRMover) → None

C++: protocols::hybridization::MRMover::init() –> void

last_proposal_density_ratio(self: pyrosetta.rosetta.protocols.moves.Mover) → float

C++: protocols::moves::Mover::last_proposal_density_ratio() –> double

static name() → str

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

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

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

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

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

Provide citations to the passed CitationCollectionList

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

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

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

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_big_fragments(self: pyrosetta.rosetta.protocols.hybridization.MRMover, newval: pyrosetta.rosetta.core.fragment.FragSet) → None

C++: protocols::hybridization::MRMover::set_big_fragments(class std::shared_ptr<class core::fragment::FragSet>) –> void

set_cen_cst_weight(self: pyrosetta.rosetta.protocols.hybridization.MRMover, newval: float) → None

C++: protocols::hybridization::MRMover::set_cen_cst_weight(double) –> void

set_censcale(self: pyrosetta.rosetta.protocols.hybridization.MRMover, newval: float) → None

C++: protocols::hybridization::MRMover::set_censcale(double) –> void

set_centroid_density_weight(self: pyrosetta.rosetta.protocols.hybridization.MRMover, newval: float) → None

C++: protocols::hybridization::MRMover::set_centroid_density_weight(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_disulf(self: pyrosetta.rosetta.protocols.hybridization.MRMover, newval: pyrosetta.rosetta.utility.vector1_std_string) → None

C++: protocols::hybridization::MRMover::set_disulf(class utility::vector1<std::string, class std::allocator<std::string > >) –> void

set_fa_cst_weight(self: pyrosetta.rosetta.protocols.hybridization.MRMover, newval: float) → None

C++: protocols::hybridization::MRMover::set_fa_cst_weight(double) –> void

set_fullatom_density_weight(self: pyrosetta.rosetta.protocols.hybridization.MRMover, newval: float, fast: bool) → None

C++: protocols::hybridization::MRMover::set_fullatom_density_weight(double, 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_max_gaplength_to_model(self: pyrosetta.rosetta.protocols.hybridization.MRMover, newval: int) → None

C++: protocols::hybridization::MRMover::set_max_gaplength_to_model(unsigned long) –> 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_small_fragments(self: pyrosetta.rosetta.protocols.hybridization.MRMover, newval: pyrosetta.rosetta.core.fragment.FragSet) → None

C++: protocols::hybridization::MRMover::set_small_fragments(class std::shared_ptr<class core::fragment::FragSet>) –> void

set_symmdef_file(self: pyrosetta.rosetta.protocols.hybridization.MRMover, newval: str) → None

C++: protocols::hybridization::MRMover::set_symmdef_file(std::string) –> 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.hybridization.TMalign

Bases: pybind11_object

DP_iter(self: pyrosetta.rosetta.protocols.hybridization.TMalign, x: pyrosetta.rosetta.std.vector_numeric_xyzVector_double_t, y: pyrosetta.rosetta.std.vector_numeric_xyzVector_double_t, x_len: int, y_len: int, t: pyrosetta.rosetta.numeric.xyzVector_double_t, u: pyrosetta.rosetta.numeric.xyzMatrix_double_t, invmap0: pyrosetta.rosetta.std.vector_int, g1: int, g2: int, iteration_max: int) → float

C++: protocols::hybridization::TMalign::DP_iter(const class std::vector<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &, const class std::vector<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &, const int, const int, class numeric::xyzVector<double>, class numeric::xyzMatrix<double>, class std::vector<int, class std::allocator<int> > &, const int, const int, const int) –> double

Kabsch(*args, **kwargs)

Overloaded function.

1. Kabsch(self: pyrosetta.rosetta.protocols.hybridization.TMalign, x: pyrosetta.rosetta.std.vector_numeric_xyzVector_double_t, y: pyrosetta.rosetta.std.vector_numeric_xyzVector_double_t, n: int, mode: int, rms: float, t: pyrosetta.rosetta.numeric.xyzVector_double_t, u: pyrosetta.rosetta.numeric.xyzMatrix_double_t) -> bool

C++: protocols::hybridization::TMalign::Kabsch(const class std::vector<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &, const class std::vector<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &, const int, const int, double *, class numeric::xyzVector<double> &, class numeric::xyzMatrix<double> &) –> bool

2. Kabsch(self: pyrosetta.rosetta.protocols.hybridization.TMalign, x: pyrosetta.rosetta.std.vector_std_vector_double_t, y: pyrosetta.rosetta.std.vector_std_vector_double_t, n: int, mode: int, rms: float, t: pyrosetta.rosetta.std.vector_double, u: pyrosetta.rosetta.std.vector_std_vector_double_t) -> bool

C++: protocols::hybridization::TMalign::Kabsch(const class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > &, const class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > &, const int, const int, double *, class std::vector<double, class std::allocator<double> > &, class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > &) –> bool

NWDP_TM(*args, **kwargs)

Overloaded function.

1. NWDP_TM(self: pyrosetta.rosetta.protocols.hybridization.TMalign, len1: int, len2: int, gap_open: float, j2i: pyrosetta.rosetta.std.vector_int) -> None

C++: protocols::hybridization::TMalign::NWDP_TM(const unsigned long, const unsigned long, const double, class std::vector<int, class std::allocator<int> > &) –> void

2. NWDP_TM(self: pyrosetta.rosetta.protocols.hybridization.TMalign, x: pyrosetta.rosetta.std.vector_numeric_xyzVector_double_t, y: pyrosetta.rosetta.std.vector_numeric_xyzVector_double_t, len1: int, len2: int, t: pyrosetta.rosetta.numeric.xyzVector_double_t, u: pyrosetta.rosetta.numeric.xyzMatrix_double_t, d02: float, gap_open: float, j2i: pyrosetta.rosetta.std.vector_int) -> None

C++: protocols::hybridization::TMalign::NWDP_TM(const class std::vector<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &, const class std::vector<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &, const int, const int, const class numeric::xyzVector<double> &, const class numeric::xyzMatrix<double> &, double, double, class std::vector<int, class std::allocator<int> > &) –> void

3. NWDP_TM(self: pyrosetta.rosetta.protocols.hybridization.TMalign, secx: pyrosetta.rosetta.std.vector_int, secy: pyrosetta.rosetta.std.vector_int, len1: int, len2: int, gap_open: float, j2i: pyrosetta.rosetta.std.vector_int) -> None

C++: protocols::hybridization::TMalign::NWDP_TM(const class std::vector<int, class std::allocator<int> > &, const class std::vector<int, class std::allocator<int> > &, const int, const int, double, class std::vector<int, class std::allocator<int> > &) –> void

PrintErrorAndQuit(self: pyrosetta.rosetta.protocols.hybridization.TMalign, sErrorString: str) → None

C++: protocols::hybridization::TMalign::PrintErrorAndQuit(std::string) –> void

TMscore(self: pyrosetta.rosetta.protocols.hybridization.TMalign, length: int) → float

C++: protocols::hybridization::TMalign::TMscore(unsigned long) –> double

TMscore8_search(self: pyrosetta.rosetta.protocols.hybridization.TMalign, xtm: pyrosetta.rosetta.std.vector_numeric_xyzVector_double_t, ytm: pyrosetta.rosetta.std.vector_numeric_xyzVector_double_t, Lali: int, t0: pyrosetta.rosetta.numeric.xyzVector_double_t, u0: pyrosetta.rosetta.numeric.xyzMatrix_double_t, simplify_step: int, score_sum_method: int, Rcomm: float) → float

C++: protocols::hybridization::TMalign::TMscore8_search(const class std::vector<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &, const class std::vector<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &, int, class numeric::xyzVector<double> &, class numeric::xyzMatrix<double> &, const int, const int, double *) –> double

alignment2AtomMap(*args, **kwargs)

Overloaded function.

1. alignment2AtomMap(self: pyrosetta.rosetta.protocols.hybridization.TMalign, pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, atom_map: pyrosetta.rosetta.core.id.AtomID_Map_core_id_AtomID_t) -> None

C++: protocols::hybridization::TMalign::alignment2AtomMap(const class core::pose::Pose &, const class core::pose::Pose &, class core::id::AtomID_Map<class core::id::AtomID> &) –> void

2. alignment2AtomMap(self: pyrosetta.rosetta.protocols.hybridization.TMalign, pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, n_mapped_residues: int, atom_map: pyrosetta.rosetta.core.id.AtomID_Map_core_id_AtomID_t) -> None

C++: protocols::hybridization::TMalign::alignment2AtomMap(const class core::pose::Pose &, const class core::pose::Pose &, unsigned long &, class core::id::AtomID_Map<class core::id::AtomID> &) –> void

3. alignment2AtomMap(self: pyrosetta.rosetta.protocols.hybridization.TMalign, pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.Pose, residue_list: pyrosetta.rosetta.std.list_unsigned_long_t, ref_residue_list: pyrosetta.rosetta.std.list_unsigned_long_t, n_mapped_residues: int, atom_map: pyrosetta.rosetta.core.id.AtomID_Map_core_id_AtomID_t) -> None

C++: protocols::hybridization::TMalign::alignment2AtomMap(const class core::pose::Pose &, const class core::pose::Pose &, const class std::list<unsigned long, class std::allocator<unsigned long> > &, const class std::list<unsigned long, class std::allocator<unsigned long> > &, unsigned long &, class core::id::AtomID_Map<class core::id::AtomID> &) –> void

alignment2strings(self: pyrosetta.rosetta.protocols.hybridization.TMalign, seqxA: str, seqyA: str, seqM: str) → None

C++: protocols::hybridization::TMalign::alignment2strings(std::string &, std::string &, std::string &) –> void

apply(*args, **kwargs)

Overloaded function.

1. apply(self: pyrosetta.rosetta.protocols.hybridization.TMalign, pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose) -> int

C++: protocols::hybridization::TMalign::apply(const class core::pose::Pose &, const class core::pose::Pose &) –> int

2. apply(self: pyrosetta.rosetta.protocols.hybridization.TMalign, pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, residue_list1: pyrosetta.rosetta.std.list_unsigned_long_t, residue_list2: pyrosetta.rosetta.std.list_unsigned_long_t) -> int

C++: protocols::hybridization::TMalign::apply(const class core::pose::Pose &, const class core::pose::Pose &, class std::list<unsigned long, class std::allocator<unsigned long> >, class std::list<unsigned long, class std::allocator<unsigned long> >) –> int

assign(self: pyrosetta.rosetta.protocols.hybridization.TMalign, : pyrosetta.rosetta.protocols.hybridization.TMalign) → pyrosetta.rosetta.protocols.hybridization.TMalign

C++: protocols::hybridization::TMalign::operator=(const class protocols::hybridization::TMalign &) –> class protocols::hybridization::TMalign &

convert_matrix_to_xyz(self: pyrosetta.rosetta.protocols.hybridization.TMalign, x: pyrosetta.rosetta.std.vector_std_vector_double_t, xx: pyrosetta.rosetta.numeric.xyzMatrix_double_t) → None

C++: protocols::hybridization::TMalign::convert_matrix_to_xyz(const class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > &, class numeric::xyzMatrix<double> &) –> void

convert_vector_to_xyz(self: pyrosetta.rosetta.protocols.hybridization.TMalign, x: pyrosetta.rosetta.std.vector_double, xx: pyrosetta.rosetta.numeric.xyzVector_double_t) → None

C++: protocols::hybridization::TMalign::convert_vector_to_xyz(const class std::vector<double, class std::allocator<double> > &, class numeric::xyzVector<double> &) –> void

convert_xyz_to_matrix(self: pyrosetta.rosetta.protocols.hybridization.TMalign, x: pyrosetta.rosetta.numeric.xyzMatrix_double_t, xx: pyrosetta.rosetta.std.vector_std_vector_double_t) → None

C++: protocols::hybridization::TMalign::convert_xyz_to_matrix(const class numeric::xyzMatrix<double> &, class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > &) –> void

convert_xyz_to_vector(self: pyrosetta.rosetta.protocols.hybridization.TMalign, x: pyrosetta.rosetta.numeric.xyzVector_double_t, xx: pyrosetta.rosetta.std.vector_double) → None

C++: protocols::hybridization::TMalign::convert_xyz_to_vector(const class numeric::xyzVector<double> &, class std::vector<double, class std::allocator<double> > &) –> void

convert_xyz_v_to_vectors(self: pyrosetta.rosetta.protocols.hybridization.TMalign, x: pyrosetta.rosetta.std.vector_numeric_xyzVector_double_t, xx: pyrosetta.rosetta.std.vector_std_vector_double_t) → None

C++: protocols::hybridization::TMalign::convert_xyz_v_to_vectors(const class std::vector<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &, class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > &) –> void

detailed_search(self: pyrosetta.rosetta.protocols.hybridization.TMalign, x: pyrosetta.rosetta.std.vector_numeric_xyzVector_double_t, y: pyrosetta.rosetta.std.vector_numeric_xyzVector_double_t, : int, y_len: int, invmap0: pyrosetta.rosetta.std.vector_int, t: pyrosetta.rosetta.numeric.xyzVector_double_t, u: pyrosetta.rosetta.numeric.xyzMatrix_double_t, simplify_step: int, score_sum_method: int) → float

C++: protocols::hybridization::TMalign::detailed_search(const class std::vector<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &, const class std::vector<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &, const int, const int, const class std::vector<int, class std::allocator<int> > &, class numeric::xyzVector<double> &, class numeric::xyzMatrix<double> &, int, int) –> double

dist(self: pyrosetta.rosetta.protocols.hybridization.TMalign, x: pyrosetta.rosetta.numeric.xyzVector_double_t, y: pyrosetta.rosetta.numeric.xyzVector_double_t) → float

C++: protocols::hybridization::TMalign::dist(class numeric::xyzVector<double>, class numeric::xyzVector<double>) –> double

do_rotation(self: pyrosetta.rosetta.protocols.hybridization.TMalign, x: pyrosetta.rosetta.std.vector_numeric_xyzVector_double_t, x1: pyrosetta.rosetta.std.vector_numeric_xyzVector_double_t, len: int, t: pyrosetta.rosetta.numeric.xyzVector_double_t, u: pyrosetta.rosetta.numeric.xyzMatrix_double_t) → None

C++: protocols::hybridization::TMalign::do_rotation(const class std::vector<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &, class std::vector<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &, int, const class numeric::xyzVector<double> &, const class numeric::xyzMatrix<double> &) –> void

find_max_frag(self: pyrosetta.rosetta.protocols.hybridization.TMalign, x: pyrosetta.rosetta.std.vector_numeric_xyzVector_double_t, resno: pyrosetta.rosetta.std.vector_int, len: int, start_max: int, end_max: int) → None

C++: protocols::hybridization::TMalign::find_max_frag(const class std::vector<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &, const class std::vector<int, class std::allocator<int> > &, const int, int *, int *) –> void

get_initial(self: pyrosetta.rosetta.protocols.hybridization.TMalign, x: pyrosetta.rosetta.std.vector_numeric_xyzVector_double_t, y: pyrosetta.rosetta.std.vector_numeric_xyzVector_double_t, x_len: int, y_len: int, y2x: pyrosetta.rosetta.std.vector_int) → float

C++: protocols::hybridization::TMalign::get_initial(const class std::vector<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &, const class std::vector<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &, const int, const int, class std::vector<int, class std::allocator<int> > &) –> double

get_initial_fgt(self: pyrosetta.rosetta.protocols.hybridization.TMalign, x: pyrosetta.rosetta.std.vector_numeric_xyzVector_double_t, y: pyrosetta.rosetta.std.vector_numeric_xyzVector_double_t, x_len: int, y_len: int, xresno: pyrosetta.rosetta.std.vector_int, yresno: pyrosetta.rosetta.std.vector_int, y2x: pyrosetta.rosetta.std.vector_int) → float

C++: protocols::hybridization::TMalign::get_initial_fgt(const class std::vector<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &, const class std::vector<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &, const int, const int, const class std::vector<int, class std::allocator<int> > &, const class std::vector<int, class std::allocator<int> > &, class std::vector<int, class std::allocator<int> > &) –> double

get_initial_local(self: pyrosetta.rosetta.protocols.hybridization.TMalign, x: pyrosetta.rosetta.std.vector_numeric_xyzVector_double_t, y: pyrosetta.rosetta.std.vector_numeric_xyzVector_double_t, x_len: int, y_len: int, y2x: pyrosetta.rosetta.std.vector_int) → bool

C++: protocols::hybridization::TMalign::get_initial_local(const class std::vector<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &, const class std::vector<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &, const int, const int, class std::vector<int, class std::allocator<int> > &) –> bool

get_initial_ss(self: pyrosetta.rosetta.protocols.hybridization.TMalign, x: pyrosetta.rosetta.std.vector_numeric_xyzVector_double_t, y: pyrosetta.rosetta.std.vector_numeric_xyzVector_double_t, x_len: int, y_len: int, y2x: pyrosetta.rosetta.std.vector_int) → None

C++: protocols::hybridization::TMalign::get_initial_ss(const class std::vector<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &, const class std::vector<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &, const int, const int, class std::vector<int, class std::allocator<int> > &) –> void

get_initial_ssplus(self: pyrosetta.rosetta.protocols.hybridization.TMalign, x: pyrosetta.rosetta.std.vector_numeric_xyzVector_double_t, y: pyrosetta.rosetta.std.vector_numeric_xyzVector_double_t, x_len: int, y_len: int, y2x0: pyrosetta.rosetta.std.vector_int, y2x: pyrosetta.rosetta.std.vector_int) → None

C++: protocols::hybridization::TMalign::get_initial_ssplus(const class std::vector<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &, const class std::vector<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &, const int, const int, class std::vector<int, class std::allocator<int> > &, class std::vector<int, class std::allocator<int> > &) –> void

get_score_fast(self: pyrosetta.rosetta.protocols.hybridization.TMalign, x: pyrosetta.rosetta.std.vector_numeric_xyzVector_double_t, y: pyrosetta.rosetta.std.vector_numeric_xyzVector_double_t, : int, y_len: int, invmap: pyrosetta.rosetta.std.vector_int) → float

C++: protocols::hybridization::TMalign::get_score_fast(const class std::vector<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &, const class std::vector<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &, const int, const int, const class std::vector<int, class std::allocator<int> > &) –> double

get_t(self: pyrosetta.rosetta.protocols.hybridization.TMalign) → pyrosetta.rosetta.numeric.xyzVector_double_t

C++: protocols::hybridization::TMalign::get_t() const –> const class numeric::xyzVector<double> &

get_u(self: pyrosetta.rosetta.protocols.hybridization.TMalign) → pyrosetta.rosetta.numeric.xyzMatrix_double_t

C++: protocols::hybridization::TMalign::get_u() const –> const class numeric::xyzMatrix<double> &

load_pose_allocate_memory(self: pyrosetta.rosetta.protocols.hybridization.TMalign, pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, residue_list1: pyrosetta.rosetta.std.list_unsigned_long_t, residue_list2: pyrosetta.rosetta.std.list_unsigned_long_t) → None

C++: protocols::hybridization::TMalign::load_pose_allocate_memory(const class core::pose::Pose &, const class core::pose::Pose &, class std::list<unsigned long, class std::allocator<unsigned long> > &, class std::list<unsigned long, class std::allocator<unsigned long> > &) –> void

make_sec(self: pyrosetta.rosetta.protocols.hybridization.TMalign, x: pyrosetta.rosetta.std.vector_numeric_xyzVector_double_t, len: int, sec: pyrosetta.rosetta.std.vector_int) → None

C++: protocols::hybridization::TMalign::make_sec(const class std::vector<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &, const int, class std::vector<int, class std::allocator<int> > &) –> void

parameter_set4final(self: pyrosetta.rosetta.protocols.hybridization.TMalign, len: float) → None

C++: protocols::hybridization::TMalign::parameter_set4final(double) –> void

parameter_set4scale(self: pyrosetta.rosetta.protocols.hybridization.TMalign, len: int, d_s: float) → None

C++: protocols::hybridization::TMalign::parameter_set4scale(int, double) –> void

parameter_set4search(self: pyrosetta.rosetta.protocols.hybridization.TMalign, xlen: int, ylen: int) → None

C++: protocols::hybridization::TMalign::parameter_set4search(int, int) –> void

read_pose(self: pyrosetta.rosetta.protocols.hybridization.TMalign, pose: pyrosetta.rosetta.core.pose.Pose, residue_list: pyrosetta.rosetta.std.list_unsigned_long_t, a: pyrosetta.rosetta.std.vector_numeric_xyzVector_double_t, seq: str, resno: pyrosetta.rosetta.std.vector_int) → int

C++: protocols::hybridization::TMalign::read_pose(const class core::pose::Pose &, const class std::list<unsigned long, class std::allocator<unsigned long> > &, class std::vector<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &, std::string &, class std::vector<int, class std::allocator<int> > &) –> int

resize_for_xyz_matrix(self: pyrosetta.rosetta.protocols.hybridization.TMalign, xx: pyrosetta.rosetta.std.vector_std_vector_double_t) → None

C++: protocols::hybridization::TMalign::resize_for_xyz_matrix(class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > &) –> void

score_fun8(self: pyrosetta.rosetta.protocols.hybridization.TMalign, xa: pyrosetta.rosetta.std.vector_numeric_xyzVector_double_t, ya: pyrosetta.rosetta.std.vector_numeric_xyzVector_double_t, n_ali: int, d: float, i_ali: pyrosetta.rosetta.std.vector_int, score1: float, score_sum_method: int) → int

C++: protocols::hybridization::TMalign::score_fun8(const class std::vector<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &, const class std::vector<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &, const int, const double, class std::vector<int, class std::allocator<int> > &, double *, int) –> int

score_matrix_rmsd(self: pyrosetta.rosetta.protocols.hybridization.TMalign, x: pyrosetta.rosetta.std.vector_numeric_xyzVector_double_t, y: pyrosetta.rosetta.std.vector_numeric_xyzVector_double_t, x_len: int, y_len: int, y2x: pyrosetta.rosetta.std.vector_int) → None

C++: protocols::hybridization::TMalign::score_matrix_rmsd(const class std::vector<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &, const class std::vector<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &, const int, const int, const class std::vector<int, class std::allocator<int> > &) –> void

score_matrix_rmsd_sec(self: pyrosetta.rosetta.protocols.hybridization.TMalign, x: pyrosetta.rosetta.std.vector_numeric_xyzVector_double_t, y: pyrosetta.rosetta.std.vector_numeric_xyzVector_double_t, x_len: int, y_len: int, y2x: pyrosetta.rosetta.std.vector_int) → None

C++: protocols::hybridization::TMalign::score_matrix_rmsd_sec(const class std::vector<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &, const class std::vector<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &, const int, const int, const class std::vector<int, class std::allocator<int> > &) –> void

sec_str(self: pyrosetta.rosetta.protocols.hybridization.TMalign, dis13: float, dis14: float, dis15: float, dis24: float, dis25: float, dis35: float) → int

C++: protocols::hybridization::TMalign::sec_str(double, double, double, double, double, double) –> int

smooth(self: pyrosetta.rosetta.protocols.hybridization.TMalign, sec: pyrosetta.rosetta.std.vector_int, len: int) → None

C++: protocols::hybridization::TMalign::smooth(class std::vector<int, class std::allocator<int> > &, const int) –> void

transform(self: pyrosetta.rosetta.protocols.hybridization.TMalign, t: pyrosetta.rosetta.numeric.xyzVector_double_t, u: pyrosetta.rosetta.numeric.xyzMatrix_double_t, x: pyrosetta.rosetta.numeric.xyzVector_double_t, x1: pyrosetta.rosetta.numeric.xyzVector_double_t) → None

C++: protocols::hybridization::TMalign::transform(const class numeric::xyzVector<double> &, const class numeric::xyzMatrix<double> &, class numeric::xyzVector<double>, class numeric::xyzVector<double> &) –> void

class pyrosetta.rosetta.protocols.hybridization.TemplateHistory

Bases: CacheableData

assign(self: pyrosetta.rosetta.protocols.hybridization.TemplateHistory, : pyrosetta.rosetta.protocols.hybridization.TemplateHistory) → pyrosetta.rosetta.protocols.hybridization.TemplateHistory

C++: protocols::hybridization::TemplateHistory::operator=(const class protocols::hybridization::TemplateHistory &) –> class protocols::hybridization::TemplateHistory &

clone(self: pyrosetta.rosetta.protocols.hybridization.TemplateHistory) → pyrosetta.rosetta.basic.datacache.CacheableData

C++: protocols::hybridization::TemplateHistory::clone() const –> class std::shared_ptr<class basic::datacache::CacheableData>

get(self: pyrosetta.rosetta.protocols.hybridization.TemplateHistory, resid: int) → int

C++: protocols::hybridization::TemplateHistory::get(unsigned long) –> int

get_self_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.basic.datacache.CacheableData

C++: basic::datacache::CacheableData::get_self_ptr() –> class std::shared_ptr<class basic::datacache::CacheableData>

get_self_weak_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.std.weak_ptr_basic_datacache_CacheableData_t

C++: basic::datacache::CacheableData::get_self_weak_ptr() –> class std::weak_ptr<class basic::datacache::CacheableData>

set(self: pyrosetta.rosetta.protocols.hybridization.TemplateHistory, res_start: int, res_stop: int, template_id: int) → None

C++: protocols::hybridization::TemplateHistory::set(unsigned long, unsigned long, int) –> void

setall(self: pyrosetta.rosetta.protocols.hybridization.TemplateHistory, template_id: int) → None

C++: protocols::hybridization::TemplateHistory::setall(int) –> void

size(self: pyrosetta.rosetta.protocols.hybridization.TemplateHistory) → int

C++: protocols::hybridization::TemplateHistory::size() –> unsigned long

class pyrosetta.rosetta.protocols.hybridization.WeightedFragmentSmoothTrialMover

Bases: Mover

apply(self: pyrosetta.rosetta.protocols.hybridization.WeightedFragmentSmoothTrialMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::hybridization::WeightedFragmentSmoothTrialMover::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.hybridization.WeightedFragmentSmoothTrialMover, : pyrosetta.rosetta.protocols.hybridization.WeightedFragmentSmoothTrialMover) → pyrosetta.rosetta.protocols.hybridization.WeightedFragmentSmoothTrialMover

C++: protocols::hybridization::WeightedFragmentSmoothTrialMover::operator=(const class protocols::hybridization::WeightedFragmentSmoothTrialMover &) –> class protocols::hybridization::WeightedFragmentSmoothTrialMover &

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.hybridization.WeightedFragmentSmoothTrialMover) → str

C++: protocols::hybridization::WeightedFragmentSmoothTrialMover::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_nr_frags(self: pyrosetta.rosetta.protocols.hybridization.WeightedFragmentSmoothTrialMover) → int

C++: protocols::hybridization::WeightedFragmentSmoothTrialMover::get_nr_frags() –> unsigned long

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

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

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

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

get_total_frames(self: pyrosetta.rosetta.protocols.hybridization.WeightedFragmentSmoothTrialMover) → int

C++: protocols::hybridization::WeightedFragmentSmoothTrialMover::get_total_frames() –> unsigned long

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

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

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

non-const accessor

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

last_proposal_density_ratio(self: pyrosetta.rosetta.protocols.moves.Mover) → float

C++: protocols::moves::Mover::last_proposal_density_ratio() –> double

static name() → str

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

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

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

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

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

Provide citations to the passed CitationCollectionList

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

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

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

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

update_sampler_weights(self: pyrosetta.rosetta.protocols.hybridization.WeightedFragmentSmoothTrialMover, residue_weights: pyrosetta.rosetta.utility.vector1_double) → None

C++: protocols::hybridization::WeightedFragmentSmoothTrialMover::update_sampler_weights(const class utility::vector1<double, class std::allocator<double> >) –> void

class pyrosetta.rosetta.protocols.hybridization.WeightedFragmentTrialMover

Bases: Mover

apply(self: pyrosetta.rosetta.protocols.hybridization.WeightedFragmentTrialMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::hybridization::WeightedFragmentTrialMover::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.hybridization.WeightedFragmentTrialMover, : pyrosetta.rosetta.protocols.hybridization.WeightedFragmentTrialMover) → pyrosetta.rosetta.protocols.hybridization.WeightedFragmentTrialMover

C++: protocols::hybridization::WeightedFragmentTrialMover::operator=(const class protocols::hybridization::WeightedFragmentTrialMover &) –> class protocols::hybridization::WeightedFragmentTrialMover &

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.hybridization.WeightedFragmentTrialMover) → str

C++: protocols::hybridization::WeightedFragmentTrialMover::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_nr_frags(self: pyrosetta.rosetta.protocols.hybridization.WeightedFragmentTrialMover) → int

C++: protocols::hybridization::WeightedFragmentTrialMover::get_nr_frags() –> unsigned long

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

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

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

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

get_total_frames(self: pyrosetta.rosetta.protocols.hybridization.WeightedFragmentTrialMover) → int

C++: protocols::hybridization::WeightedFragmentTrialMover::get_total_frames() –> unsigned long

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

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

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

non-const accessor

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

last_proposal_density_ratio(self: pyrosetta.rosetta.protocols.moves.Mover) → float

C++: protocols::moves::Mover::last_proposal_density_ratio() –> double

static name() → str

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

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

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

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

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

Provide citations to the passed CitationCollectionList

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

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

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

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

update_sampler_weights(self: pyrosetta.rosetta.protocols.hybridization.WeightedFragmentTrialMover, residue_weights: pyrosetta.rosetta.utility.vector1_double) → None

C++: protocols::hybridization::WeightedFragmentTrialMover::update_sampler_weights(const class utility::vector1<double, class std::allocator<double> >) –> void

pyrosetta.rosetta.protocols.hybridization.add_non_protein_cst(pose: pyrosetta.rosetta.core.pose.Pose, tmpl: pyrosetta.rosetta.core.pose.Pose, self_cst_weight: float, het_prot_cst_weight: float) → None

C++: protocols::hybridization::add_non_protein_cst(class core::pose::Pose &, class core::pose::Pose &, const double, const double) –> void

pyrosetta.rosetta.protocols.hybridization.add_strand_pairs_cst(pose: pyrosetta.rosetta.core.pose.Pose, strand_pairs: pyrosetta.rosetta.utility.vector1_std_pair_unsigned_long_unsigned_long_t) → None

C++: protocols::hybridization::add_strand_pairs_cst(class core::pose::Pose &, const class utility::vector1<struct std::pair<unsigned long, unsigned long>, class std::allocator<struct std::pair<unsigned long, unsigned long> > >) –> void

pyrosetta.rosetta.protocols.hybridization.apply_transformation(mod_pose: pyrosetta.rosetta.core.pose.Pose, residue_list: pyrosetta.rosetta.std.list_unsigned_long_t, R: pyrosetta.rosetta.numeric.xyzMatrix_double_t, preT: pyrosetta.rosetta.numeric.xyzVector_double_t, postT: pyrosetta.rosetta.numeric.xyzVector_double_t) → None

C++: protocols::hybridization::apply_transformation(class core::pose::Pose &, const class std::list<unsigned long, class std::allocator<unsigned long> > &, const class numeric::xyzMatrix<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &) –> void

pyrosetta.rosetta.protocols.hybridization.atom_map_valid_size(pose: pyrosetta.rosetta.core.pose.Pose, atom_map: pyrosetta.rosetta.core.id.AtomID_Map_core_id_AtomID_t) → int

C++: protocols::hybridization::atom_map_valid_size(const class core::pose::Pose &, const class core::id::AtomID_Map<class core::id::AtomID> &) –> unsigned long

pyrosetta.rosetta.protocols.hybridization.create_fragment_set(pose: pyrosetta.rosetta.core.pose.Pose, len: int, nfrag: int) → pyrosetta.rosetta.core.fragment.FragSet

C++: protocols::hybridization::create_fragment_set(const class core::pose::Pose &, unsigned long, unsigned long) –> class std::shared_ptr<class core::fragment::FragSet>

pyrosetta.rosetta.protocols.hybridization.create_fragment_set_no_ssbias(*args, **kwargs)

Overloaded function.

1. create_fragment_set_no_ssbias(pose: pyrosetta.rosetta.core.pose.Pose, len: int, nfrag: int) -> pyrosetta.rosetta.core.fragment.FragSet

2. create_fragment_set_no_ssbias(pose: pyrosetta.rosetta.core.pose.Pose, len: int, nfrag: int, force_ss: str) -> pyrosetta.rosetta.core.fragment.FragSet

C++: protocols::hybridization::create_fragment_set_no_ssbias(const class core::pose::Pose &, unsigned long, unsigned long, char) –> class std::shared_ptr<class core::fragment::FragSet>

3. create_fragment_set_no_ssbias(pose: pyrosetta.rosetta.core.pose.Pose, user_pos: pyrosetta.rosetta.std.set_unsigned_long_t, len: int, nfrag: int) -> pyrosetta.rosetta.core.fragment.FragSet

4. create_fragment_set_no_ssbias(pose: pyrosetta.rosetta.core.pose.Pose, user_pos: pyrosetta.rosetta.std.set_unsigned_long_t, len: int, nfrag: int, force_ss: str) -> pyrosetta.rosetta.core.fragment.FragSet

C++: protocols::hybridization::create_fragment_set_no_ssbias(const class core::pose::Pose &, class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >, unsigned long, unsigned long, char) –> class std::shared_ptr<class core::fragment::FragSet>

5. create_fragment_set_no_ssbias(seq: str, len: int, nfrag: int) -> pyrosetta.rosetta.core.fragment.FragSet

6. create_fragment_set_no_ssbias(seq: str, len: int, nfrag: int, force_ss: str) -> pyrosetta.rosetta.core.fragment.FragSet

C++: protocols::hybridization::create_fragment_set_no_ssbias(std::string, unsigned long, unsigned long, char) –> class std::shared_ptr<class core::fragment::FragSet>

class pyrosetta.rosetta.protocols.hybridization.detailedControlsTagSetting

Bases: pybind11_object

assign(self: pyrosetta.rosetta.protocols.hybridization.detailedControlsTagSetting, : pyrosetta.rosetta.protocols.hybridization.detailedControlsTagSetting) → pyrosetta.rosetta.protocols.hybridization.detailedControlsTagSetting

C++: protocols::hybridization::detailedControlsTagSetting::operator=(const struct protocols::hybridization::detailedControlsTagSetting &) –> struct protocols::hybridization::detailedControlsTagSetting &

property sample_abinitio_

property sample_template_

property start_res_

property stop_res_

property taskFactOP_

property type_

pyrosetta.rosetta.protocols.hybridization.discontinued_lower(pose: pyrosetta.rosetta.core.pose.Pose, seqpos: int) → bool

C++: protocols::hybridization::discontinued_lower(const class core::pose::Pose &, const unsigned long) –> bool

pyrosetta.rosetta.protocols.hybridization.discontinued_upper(pose: pyrosetta.rosetta.core.pose.Pose, seqpos: int) → bool

C++: protocols::hybridization::discontinued_upper(const class core::pose::Pose &, const unsigned long) –> bool

pyrosetta.rosetta.protocols.hybridization.downstream_residues_from_jump(pose: pyrosetta.rosetta.core.pose.Pose, jump_number: int) → pyrosetta.rosetta.std.list_unsigned_long_t

C++: protocols::hybridization::downstream_residues_from_jump(const class core::pose::Pose &, const unsigned long) –> class std::list<unsigned long, class std::allocator<unsigned long> >

pyrosetta.rosetta.protocols.hybridization.generate_centroid_constraints(*args, **kwargs)

Overloaded function.

1. generate_centroid_constraints(pose: pyrosetta.rosetta.core.pose.Pose, templates: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_pose_Pose_t, template_weights: pyrosetta.rosetta.utility.vector1_double) -> None

2. generate_centroid_constraints(pose: pyrosetta.rosetta.core.pose.Pose, templates: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_pose_Pose_t, template_weights: pyrosetta.rosetta.utility.vector1_double, ignore_res: pyrosetta.rosetta.std.set_unsigned_long_t) -> None

C++: protocols::hybridization::generate_centroid_constraints(class core::pose::Pose &, class utility::vector1<class std::shared_ptr<const class core::pose::Pose>, class std::allocator<class std::shared_ptr<const class core::pose::Pose> > >, class utility::vector1<double, class std::allocator<double> >, class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >) –> void

pyrosetta.rosetta.protocols.hybridization.generate_fullatom_constraints(pose: pyrosetta.rosetta.core.pose.Pose, templates: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_pose_Pose_t, template_weights: pyrosetta.rosetta.utility.vector1_double) → None

C++: protocols::hybridization::generate_fullatom_constraints(class core::pose::Pose &, class utility::vector1<class std::shared_ptr<const class core::pose::Pose>, class std::allocator<class std::shared_ptr<const class core::pose::Pose> > >, class utility::vector1<double, class std::allocator<double> >) –> void

pyrosetta.rosetta.protocols.hybridization.get_gdtmm(native: pyrosetta.rosetta.core.pose.Pose, pose: pyrosetta.rosetta.core.pose.Pose, aln: pyrosetta.rosetta.core.sequence.SequenceAlignment) → float

C++: protocols::hybridization::get_gdtmm(class core::pose::Pose &, class core::pose::Pose &, class std::shared_ptr<class core::sequence::SequenceAlignment> &) –> double

pyrosetta.rosetta.protocols.hybridization.get_num_residues_nonvirt(pose: pyrosetta.rosetta.core.pose.Pose) → int

C++: protocols::hybridization::get_num_residues_nonvirt(const class core::pose::Pose &) –> unsigned long

pyrosetta.rosetta.protocols.hybridization.get_num_residues_prot(pose: pyrosetta.rosetta.core.pose.Pose) → int

C++: protocols::hybridization::get_num_residues_prot(const class core::pose::Pose &) –> unsigned long

pyrosetta.rosetta.protocols.hybridization.get_superposition_transformation(mod_pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.Pose, atom_map: pyrosetta.rosetta.core.id.AtomID_Map_core_id_AtomID_t, R: pyrosetta.rosetta.numeric.xyzMatrix_double_t, preT: pyrosetta.rosetta.numeric.xyzVector_double_t, postT: pyrosetta.rosetta.numeric.xyzVector_double_t) → None

C++: protocols::hybridization::get_superposition_transformation(const class core::pose::Pose &, const class core::pose::Pose &, const class core::id::AtomID_Map<class core::id::AtomID> &, class numeric::xyzMatrix<double> &, class numeric::xyzVector<double> &, class numeric::xyzVector<double> &) –> void

pyrosetta.rosetta.protocols.hybridization.natom_aligned(*args, **kwargs)

Overloaded function.

1. natom_aligned(pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.Pose, atom_map: pyrosetta.rosetta.core.id.AtomID_Map_core_id_AtomID_t) -> int

2. natom_aligned(pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.Pose, atom_map: pyrosetta.rosetta.core.id.AtomID_Map_core_id_AtomID_t, distance_squared_threshold: float) -> int

C++: protocols::hybridization::natom_aligned(class core::pose::Pose &, const class core::pose::Pose &, const class core::id::AtomID_Map<class core::id::AtomID> &, double) –> unsigned long

pyrosetta.rosetta.protocols.hybridization.partial_align(*args, **kwargs)

Overloaded function.

1. partial_align(pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.Pose, atom_map: pyrosetta.rosetta.core.id.AtomID_Map_core_id_AtomID_t, iterate_convergence: bool, distance_thresholds: pyrosetta.rosetta.utility.vector1_double, min_coverage: float) -> None

C++: protocols::hybridization::partial_align(class core::pose::Pose &, const class core::pose::Pose &, const class core::id::AtomID_Map<class core::id::AtomID> &, bool, class utility::vector1<double, class std::allocator<double> >, double) –> void

2. partial_align(pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.Pose, atom_map: pyrosetta.rosetta.core.id.AtomID_Map_core_id_AtomID_t, residue_list: pyrosetta.rosetta.std.list_unsigned_long_t) -> None

3. partial_align(pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.Pose, atom_map: pyrosetta.rosetta.core.id.AtomID_Map_core_id_AtomID_t, residue_list: pyrosetta.rosetta.std.list_unsigned_long_t, iterate_convergence: bool) -> None

4. partial_align(pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.Pose, atom_map: pyrosetta.rosetta.core.id.AtomID_Map_core_id_AtomID_t, residue_list: pyrosetta.rosetta.std.list_unsigned_long_t, iterate_convergence: bool, distance_thresholds: pyrosetta.rosetta.utility.vector1_double) -> None

5. partial_align(pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.Pose, atom_map: pyrosetta.rosetta.core.id.AtomID_Map_core_id_AtomID_t, residue_list: pyrosetta.rosetta.std.list_unsigned_long_t, iterate_convergence: bool, distance_thresholds: pyrosetta.rosetta.utility.vector1_double, min_coverage: float) -> None

C++: protocols::hybridization::partial_align(class core::pose::Pose &, const class core::pose::Pose &, const class core::id::AtomID_Map<class core::id::AtomID> &, const class std::list<unsigned long, class std::allocator<unsigned long> > &, bool, class utility::vector1<double, class std::allocator<double> >, double) –> void

pyrosetta.rosetta.protocols.hybridization.renumber_with_pdb_info(template_chunk: pyrosetta.rosetta.protocols.loops.Loops, template_pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.protocols.loops.Loops

C++: protocols::hybridization::renumber_with_pdb_info(class protocols::loops::Loops &, class std::shared_ptr<const class core::pose::Pose>) –> class protocols::loops::Loops

class pyrosetta.rosetta.protocols.hybridization.sampleEnum

Bases: pybind11_object

Members:

off

on

unset

property name

off = <sampleEnum.off: 0>

on = <sampleEnum.on: 1>

unset = <sampleEnum.unset: 2>

property value

pyrosetta.rosetta.protocols.hybridization.setup_centroid_constraints(*args, **kwargs)

Overloaded function.

1. setup_centroid_constraints(pose: pyrosetta.rosetta.core.pose.Pose, templates: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_pose_Pose_t, template_weights: pyrosetta.rosetta.utility.vector1_double, cen_cst_file: str) -> None

2. setup_centroid_constraints(pose: pyrosetta.rosetta.core.pose.Pose, templates: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_pose_Pose_t, template_weights: pyrosetta.rosetta.utility.vector1_double, cen_cst_file: str, ignore_res_for_AUTO: pyrosetta.rosetta.std.set_unsigned_long_t) -> None

C++: protocols::hybridization::setup_centroid_constraints(class core::pose::Pose &, const class utility::vector1<class std::shared_ptr<const class core::pose::Pose>, class std::allocator<class std::shared_ptr<const class core::pose::Pose> > > &, const class utility::vector1<double, class std::allocator<double> > &, const std::string &, const class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> > &) –> void

pyrosetta.rosetta.protocols.hybridization.setup_constraints(pose: pyrosetta.rosetta.core.pose.Pose, cst_in: str) → None

C++: protocols::hybridization::setup_constraints(class core::pose::Pose &, std::string &) –> void

pyrosetta.rosetta.protocols.hybridization.setup_fullatom_constraints(pose: pyrosetta.rosetta.core.pose.Pose, templates: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_pose_Pose_t, template_weights: pyrosetta.rosetta.utility.vector1_double, cen_cst_file: str, fa_cst_file: str) → None

C++: protocols::hybridization::setup_fullatom_constraints(class core::pose::Pose &, const class utility::vector1<class std::shared_ptr<const class core::pose::Pose>, class std::allocator<class std::shared_ptr<const class core::pose::Pose> > > &, const class utility::vector1<double, class std::allocator<double> > &, const std::string &, const std::string &) –> void

pyrosetta.rosetta.protocols.hybridization.setup_user_coordinate_constraints(pose: pyrosetta.rosetta.core.pose.Pose, reses_to_cst: pyrosetta.rosetta.utility.vector1_unsigned_long) → None

C++: protocols::hybridization::setup_user_coordinate_constraints(class core::pose::Pose &, class utility::vector1<unsigned long, class std::allocator<unsigned long> >) –> void

pyrosetta.rosetta.protocols.hybridization.update_atom_map(pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.Pose, atom_map: pyrosetta.rosetta.core.id.AtomID_Map_core_id_AtomID_t, distance_squared_threshold: float) → pyrosetta.rosetta.core.id.AtomID_Map_core_id_AtomID_t

C++: protocols::hybridization::update_atom_map(class core::pose::Pose &, const class core::pose::Pose &, const class core::id::AtomID_Map<class core::id::AtomID> &, double) –> class core::id::AtomID_Map<class core::id::AtomID>