canonical_sampling

• mc_convergence_checks

Bindings for protocols::canonical_sampling namespace

class pyrosetta.rosetta.protocols.canonical_sampling.DbTrajectoryRecorder

Bases: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder

Record a trajectory to an SQL database.

This class builds upon Rosetta’s database framework, which means that there is support for SQLite3, MySQL and PostgreSQL. Database options must be specified on the command line (i.e. there’s no API for this):

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.canonical_sampling.DbTrajectoryRecorder) -> None
2. __init__(self: pyrosetta.rosetta.protocols.canonical_sampling.DbTrajectoryRecorder, job_id: int) -> None
3. __init__(self: pyrosetta.rosetta.protocols.canonical_sampling.DbTrajectoryRecorder, arg0: pyrosetta.rosetta.protocols.canonical_sampling.DbTrajectoryRecorder) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

apply(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder, pose: pyrosetta.rosetta.core.pose.Pose) → None

ThermodynamicObserver::apply

C++: protocols::canonical_sampling::TrajectoryRecorder::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver, : pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver) → pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver

C++: protocols::canonical_sampling::ThermodynamicObserver::operator=(const class protocols::canonical_sampling::ThermodynamicObserver &) –> class protocols::canonical_sampling::ThermodynamicObserver &

attributes_for_trajectory_recorder(: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t) → None

C++: protocols::canonical_sampling::TrajectoryRecorder::attributes_for_trajectory_recorder(class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &) –> void

cache_limit(*args, **kwargs)

Overloaded function.

1. cache_limit(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder) -> int

Return the number of poses that can be cached.

C++: protocols::canonical_sampling::TrajectoryRecorder::cache_limit() –> unsigned long

2. cache_limit(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder, limit: int) -> None

Specify the maximum number of poses that can be cached.

This option can also be specified on the command line using the

-trajectory:cache_limit flag. Note that some recorders don’t

use a cache at all, and will therefore ignore this option.

C++: protocols::canonical_sampling::TrajectoryRecorder::cache_limit(unsigned long) –> 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.canonical_sampling.DbTrajectoryRecorder) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::canonical_sampling::DbTrajectoryRecorder::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>

cumulate_jobs(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder) → bool

Return true if poses from different jobs will be written to the

same trajectory file.

I suspect this is only meant to be used in the context of jd2. This option can only be set from the command line using the -trajectory:cumulate_jobs flag.

C++: protocols::canonical_sampling::TrajectoryRecorder::cumulate_jobs() const –> bool

cumulate_replicas(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder) → bool

Return true if poses from different replicas will be written to

the same trajectory file.

I suspect this is only meant to be used in the context of jd2. This option can only be set from the command line using the -trajectory:cumulate_replicas flag.

C++: protocols::canonical_sampling::TrajectoryRecorder::cumulate_replicas() const –> bool

file_name(*args, **kwargs)

Overloaded function.

1. file_name(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder) -> str

Return the file name for the trajectory.

C++: protocols::canonical_sampling::TrajectoryRecorder::file_name() const –> const std::string &

2. file_name(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder, file_name: str) -> None

Set the file name for the trajectory.

C++: protocols::canonical_sampling::TrajectoryRecorder::file_name(const class std::basic_string<char> &) –> void

finalize_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.DbTrajectoryRecorder, pose: pyrosetta.rosetta.core.pose.Pose, mover: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) → None

C++: protocols::canonical_sampling::DbTrajectoryRecorder::finalize_simulation(class core::pose::Pose &, const class protocols::canonical_sampling::MetropolisHastingsMover &) –> void

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

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

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

fpd

Mechanism by which a mover may return multiple output poses from a single input pose.

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

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

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

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

A tag is a unique identifier used to identify structures produced

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

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

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

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

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

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

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

get_name(self: pyrosetta.rosetta.protocols.canonical_sampling.DbTrajectoryRecorder) → str

C++: protocols::canonical_sampling::DbTrajectoryRecorder::get_name() const –> std::string

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

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

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

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

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

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

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

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

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

non-const accessor

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

initialize_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.DbTrajectoryRecorder, pose: pyrosetta.rosetta.core.pose.Pose, mover: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, cycle: int) → None

C++: protocols::canonical_sampling::DbTrajectoryRecorder::initialize_simulation(class core::pose::Pose &, const class protocols::canonical_sampling::MetropolisHastingsMover &, unsigned long) –> void

job_id(*args, **kwargs)

Overloaded function.

1. job_id(self: pyrosetta.rosetta.protocols.canonical_sampling.DbTrajectoryRecorder) -> int

Return the job id that will be used as a foreign key in the

trajectory table that gets generated.

C++: protocols::canonical_sampling::DbTrajectoryRecorder::job_id() const –> unsigned long

2. job_id(self: pyrosetta.rosetta.protocols.canonical_sampling.DbTrajectoryRecorder, id: int) -> None

Set the job id that will be used as a foreign key in the

trajectory table that gets generated.

C++: protocols::canonical_sampling::DbTrajectoryRecorder::job_id(unsigned long) –> void

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

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

model_count(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder) → int

Return the number of models that have been saved so far.

C++: protocols::canonical_sampling::TrajectoryRecorder::model_count() const –> unsigned long

name() → str

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

observe_after_metropolis(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder, metropolis_hastings_mover: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) → None

ThermodynamicObserver::observe_after_metropolis

C++: protocols::canonical_sampling::TrajectoryRecorder::observe_after_metropolis(const class protocols::canonical_sampling::MetropolisHastingsMover &) –> void

register_options() → None

Associate relevant options with the TemperedDocking class.

C++: protocols::canonical_sampling::TrajectoryRecorder::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

requires_pose(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver) → bool

Return false if this observer does not require a valid pose.

TrialCounterObserver is an example of such an observer.

C++: protocols::canonical_sampling::ThermodynamicObserver::requires_pose() –> bool

reset(*args, **kwargs)

Overloaded function.

1. reset(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder, mc: pyrosetta.rosetta.protocols.moves.MonteCarlo) -> None
2. reset(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder, mc: pyrosetta.rosetta.protocols.moves.MonteCarlo, metropolis_hastings_mover: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) -> None

Callback executed whenever the simulation is initialized or reset.

C++: protocols::canonical_sampling::TrajectoryRecorder::reset(const class protocols::moves::MonteCarlo &, const class protocols::canonical_sampling::MetropolisHastingsMover *) –> void

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

resets status to SUCCESS, meant to be used before an apply(). The job distributor (august 08 vintage) uses this to ensure non-accumulation of status across apply()s.

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

restart_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.DbTrajectoryRecorder, pose: pyrosetta.rosetta.core.pose.Pose, mover: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, cycle: int, temp_level: int, temperature: float) → bool

Not implemented, except to complain if accidentally used.

C++: protocols::canonical_sampling::DbTrajectoryRecorder::restart_simulation(class core::pose::Pose &, class protocols::canonical_sampling::MetropolisHastingsMover &, unsigned long &, unsigned long &, double &) –> bool

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

////////////////////////////end Job Distributor interface////////////////////////////////////////

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

set_current_tag(self: pyrosetta.rosetta.protocols.moves.Mover, new_tag: str) → None

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

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

setter for poses contained for rms

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

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

setter for native poses contained for rms —- we should get rid of this method? it is widely used, but a bit unsafe

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

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

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

show(*args, **kwargs)

Overloaded function.

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

Outputs details about the Mover, including current settings.

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

step_count(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder) → int

Return the number of iterations that have occurred so far.

C++: protocols::canonical_sampling::TrajectoryRecorder::step_count() const –> unsigned long

stride(*args, **kwargs)

Overloaded function.

1. stride(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder) -> int

Return how often models should be written to the trajectory.

C++: protocols::canonical_sampling::TrajectoryRecorder::stride() const –> unsigned long

2. stride(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder, stride: int) -> None

Set how often models should be written to the trajectory.

This option can also be specified on the command line using the

-trajectory:stride flag.

C++: protocols::canonical_sampling::TrajectoryRecorder::stride(unsigned long) –> void

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

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

Allows extra test specific functions to be called before applying

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

type(*args, **kwargs)

Overloaded function.

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

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

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

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

update_after_boltzmann(*args, **kwargs)

Overloaded function.

1. update_after_boltzmann(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder, pose: pyrosetta.rosetta.core.pose.Pose) -> None
2. update_after_boltzmann(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder, pose: pyrosetta.rosetta.core.pose.Pose, metropolis_hastings_mover: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) -> None

ThermodynamicObserver::apply

C++: protocols::canonical_sampling::TrajectoryRecorder::update_after_boltzmann(const class core::pose::Pose &, const class protocols::canonical_sampling::MetropolisHastingsMover *) –> void

3. update_after_boltzmann(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder, mc: pyrosetta.rosetta.protocols.moves.MonteCarlo) -> None

ThermodynamicObserver::apply

C++: protocols::canonical_sampling::TrajectoryRecorder::update_after_boltzmann(const class protocols::moves::MonteCarlo &) –> void

class pyrosetta.rosetta.protocols.canonical_sampling.DbTrajectoryRecorderCreator

Bases: pyrosetta.rosetta.protocols.moves.MoverCreator

RosettaScripts factory for DbTrajectoryRecorder.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.protocols.canonical_sampling.DbTrajectoryRecorderCreator) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

assign(self: pyrosetta.rosetta.protocols.canonical_sampling.DbTrajectoryRecorderCreator, : pyrosetta.rosetta.protocols.canonical_sampling.DbTrajectoryRecorderCreator) → pyrosetta.rosetta.protocols.canonical_sampling.DbTrajectoryRecorderCreator

C++: protocols::canonical_sampling::DbTrajectoryRecorderCreator::operator=(const class protocols::canonical_sampling::DbTrajectoryRecorderCreator &) –> class protocols::canonical_sampling::DbTrajectoryRecorderCreator &

create_mover(self: pyrosetta.rosetta.protocols.canonical_sampling.DbTrajectoryRecorderCreator) → pyrosetta.rosetta.protocols.moves.Mover

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

keyname(self: pyrosetta.rosetta.protocols.canonical_sampling.DbTrajectoryRecorderCreator) → str

C++: protocols::canonical_sampling::DbTrajectoryRecorderCreator::keyname() const –> std::string

mover_name() → str

C++: protocols::canonical_sampling::DbTrajectoryRecorderCreator::mover_name() –> std::string

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

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

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

class pyrosetta.rosetta.protocols.canonical_sampling.FixedTemperatureController

Bases: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController

Maintain a constant temperature.

This is the default temperature controller used by MetropolisHastingsMover.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.canonical_sampling.FixedTemperatureController, temp: float) -> None
2. __init__(self: pyrosetta.rosetta.protocols.canonical_sampling.FixedTemperatureController, arg0: pyrosetta.rosetta.protocols.canonical_sampling.FixedTemperatureController) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

apply(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController, : pyrosetta.rosetta.core.pose.Pose) → None

No-op implemented only to satisfy the Mover interface.

C++: protocols::canonical_sampling::TemperatureController::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.canonical_sampling.FixedTemperatureController, : pyrosetta.rosetta.protocols.canonical_sampling.FixedTemperatureController) → pyrosetta.rosetta.protocols.canonical_sampling.FixedTemperatureController

C++: protocols::canonical_sampling::FixedTemperatureController::operator=(const class protocols::canonical_sampling::FixedTemperatureController &) –> class protocols::canonical_sampling::FixedTemperatureController &

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

Return a copy of this mover.

C++: protocols::canonical_sampling::FixedTemperatureController::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>

exchange_grid_dim(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController) → int

C++: protocols::canonical_sampling::TemperatureController::exchange_grid_dim() const –> unsigned long

finalize_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver, : pyrosetta.rosetta.core.pose.Pose, : protocols::canonical_sampling::MetropolisHastingsMover) → None

Callback executed after all Monte Carlo trials are completed.

C++: protocols::canonical_sampling::ThermodynamicObserver::finalize_simulation(class core::pose::Pose &, const class protocols::canonical_sampling::MetropolisHastingsMover &) –> void

finished_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController, trials: int, ntrials: int) → bool

Return true if the simulation has been completed.

C++: protocols::canonical_sampling::TemperatureController::finished_simulation(unsigned long, unsigned long) –> bool

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

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

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

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

fpd

Mechanism by which a mover may return multiple output poses from a single input pose.

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

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

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

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

A tag is a unique identifier used to identify structures produced

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

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

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

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

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

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

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

get_name(self: pyrosetta.rosetta.protocols.canonical_sampling.FixedTemperatureController) → str

C++: protocols::canonical_sampling::FixedTemperatureController::get_name() const –> std::string

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

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

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

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

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

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

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

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

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

non-const accessor

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

initialize_simulation(*args, **kwargs)

Overloaded function.

1. initialize_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController, pose: pyrosetta.rosetta.core.pose.Pose, metropolis_hastings_mover: protocols::canonical_sampling::MetropolisHastingsMover, level: int, temperature: float, cycle: int) -> None

C++: protocols::canonical_sampling::TemperatureController::initialize_simulation(class core::pose::Pose &, const class protocols::canonical_sampling::MetropolisHastingsMover &, unsigned long, double, unsigned long) –> void

2. initialize_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController, : pyrosetta.rosetta.core.pose.Pose, : protocols::canonical_sampling::MetropolisHastingsMover, : int) -> None

C++: protocols::canonical_sampling::TemperatureController::initialize_simulation(class core::pose::Pose &, const class protocols::canonical_sampling::MetropolisHastingsMover &, unsigned long) –> void

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

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

level_2_grid_coord(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController, level: int) → pyrosetta.rosetta.utility.vector1_unsigned_long

C++: protocols::canonical_sampling::TemperatureController::level_2_grid_coord(unsigned long) const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

monte_carlo(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController) → pyrosetta.rosetta.protocols.moves.MonteCarlo

Return const access to the MonteCarlo object being controlled.

C++: protocols::canonical_sampling::TemperatureController::monte_carlo() const –> class std::shared_ptr<const class protocols::moves::MonteCarlo>

n_temp_levels(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController) → int

Return the number of temperature levels used by this controller.

temperature_level()

C++: protocols::canonical_sampling::TemperatureController::n_temp_levels() const –> unsigned long

name() → str

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

nlevels_per_dim(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController, : int) → int

C++: protocols::canonical_sampling::TemperatureController::nlevels_per_dim(unsigned long) const –> unsigned long

observe_after_metropolis(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController, metropolis_hastings_mover: protocols::canonical_sampling::MetropolisHastingsMover) → None

C++: protocols::canonical_sampling::TemperatureController::observe_after_metropolis(const class protocols::canonical_sampling::MetropolisHastingsMover &) –> void

register_options() → None

Overload this static method if you access options within the mover.

These options will end up in -help of your application if users of this mover call register_options. Do this recursively! If you use movers within your mover, call their register_options in your register_options() method.

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

reinitialize_for_each_job(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController) → bool

Return false. This class does not need to be reinitialized for

each job.

C++: protocols::canonical_sampling::TemperatureController::reinitialize_for_each_job() const –> bool

reinitialize_for_new_input(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController) → bool

Return false. This class does not need to be reinitialized for

new input.

C++: protocols::canonical_sampling::TemperatureController::reinitialize_for_new_input() const –> bool

requires_pose(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver) → bool

Return false if this observer does not require a valid pose.

TrialCounterObserver is an example of such an observer.

C++: protocols::canonical_sampling::ThermodynamicObserver::requires_pose() –> 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

restart_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver, : pyrosetta.rosetta.core.pose.Pose, : protocols::canonical_sampling::MetropolisHastingsMover, : int, : int, : float) → bool

Attempt to restart the last simulation that was recorded by this

observer.

For example, consider an observer that records trajectories. This method should open the file that was going to be written, read out the last pose in that trajectory, and assign it to the given pose reference so that the current trajectory can start from the same place. Other observers may help setup other parts of the simulation.

This is not a particularly robust system, because it may require several unrelated observers working in concert to properly reconstitute the simulation. In fact, the restart feature in MetropolisHastingsMover is currently commented out, so this method is never actually invoked. I would advise reimplementing this method to utility_exit_with_message() in any subclasses you write, so that you don’t waste time writing an unused method but so you don’t confuse anyone if this feature gets revived in the future.

C++: protocols::canonical_sampling::ThermodynamicObserver::restart_simulation(class core::pose::Pose &, class protocols::canonical_sampling::MetropolisHastingsMover &, unsigned long &, unsigned long &, double &) –> bool

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

////////////////////////////end Job Distributor interface////////////////////////////////////////

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

set_current_tag(self: pyrosetta.rosetta.protocols.moves.Mover, new_tag: str) → None

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

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

setter for poses contained for rms

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

set_monte_carlo(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController, monte_carlo: pyrosetta.rosetta.protocols.moves.MonteCarlo) → None

Set the MonteCarlo object to be controlled.

C++: protocols::canonical_sampling::TemperatureController::set_monte_carlo(class std::shared_ptr<class protocols::moves::MonteCarlo>) –> void

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

setter for native poses contained for rms —- we should get rid of this method? it is widely used, but a bit unsafe

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

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

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

show(*args, **kwargs)

Overloaded function.

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

Outputs details about the Mover, including current settings.

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

temperature(*args, **kwargs)

Overloaded function.

1. temperature(self: pyrosetta.rosetta.protocols.canonical_sampling.FixedTemperatureController) -> float

C++: protocols::canonical_sampling::FixedTemperatureController::temperature() const –> double

2. temperature(self: pyrosetta.rosetta.protocols.canonical_sampling.FixedTemperatureController, : int) -> float

C++: protocols::canonical_sampling::FixedTemperatureController::temperature(unsigned long) const –> double

temperature_level(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController) → int

Return the current temperature level.

Tempering controllers often work with a handful of discrete temperature levels. This method makes it possible to work with levels, which are discrete, rather than temperatures, which are continuous.

n_temp_levels()

temperature()

C++: protocols::canonical_sampling::TemperatureController::temperature_level() const –> unsigned long

temperature_move(self: pyrosetta.rosetta.protocols.canonical_sampling.FixedTemperatureController, : float) → float

Return the same constant temperature every time.

C++: protocols::canonical_sampling::FixedTemperatureController::temperature_move(double) –> double

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

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

Allows extra test specific functions to be called before applying

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

type(*args, **kwargs)

Overloaded function.

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

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

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

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

class pyrosetta.rosetta.protocols.canonical_sampling.HamiltonianExchangeCreator

Bases: pyrosetta.rosetta.protocols.moves.MoverCreator

RosettaScripts factory for HamiltonianExchange.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.protocols.canonical_sampling.HamiltonianExchangeCreator) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

assign(self: pyrosetta.rosetta.protocols.canonical_sampling.HamiltonianExchangeCreator, : pyrosetta.rosetta.protocols.canonical_sampling.HamiltonianExchangeCreator) → pyrosetta.rosetta.protocols.canonical_sampling.HamiltonianExchangeCreator

C++: protocols::canonical_sampling::HamiltonianExchangeCreator::operator=(const class protocols::canonical_sampling::HamiltonianExchangeCreator &) –> class protocols::canonical_sampling::HamiltonianExchangeCreator &

create_mover(self: pyrosetta.rosetta.protocols.canonical_sampling.HamiltonianExchangeCreator) → pyrosetta.rosetta.protocols.moves.Mover

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

keyname(self: pyrosetta.rosetta.protocols.canonical_sampling.HamiltonianExchangeCreator) → str

C++: protocols::canonical_sampling::HamiltonianExchangeCreator::keyname() const –> std::string

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

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

class pyrosetta.rosetta.protocols.canonical_sampling.MetricRecorder

Bases: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver

Periodically output miscellaneous information.

This class is capable of writing out a variety of data related to the trajectory. This includes the job name, the replica, the temperature, and the score. Any number of torsion angles can also be added to the report using add_torsion(). Methods are also provided for specifying an output filename. Most of the IO work is done by update_after_boltzmann().

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.canonical_sampling.MetricRecorder) -> None
2. __init__(self: pyrosetta.rosetta.protocols.canonical_sampling.MetricRecorder, arg0: pyrosetta.rosetta.protocols.canonical_sampling.MetricRecorder) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

add_torsion(*args, **kwargs)

Overloaded function.

1. add_torsion(self: pyrosetta.rosetta.protocols.canonical_sampling.MetricRecorder, torsion_id: pyrosetta.rosetta.core.id.TorsionID) -> None
2. add_torsion(self: pyrosetta.rosetta.protocols.canonical_sampling.MetricRecorder, torsion_id: pyrosetta.rosetta.core.id.TorsionID, name: str) -> None

Include the given torsion in the output.

C++: protocols::canonical_sampling::MetricRecorder::add_torsion(const class core::id::TorsionID &, class std::basic_string<char>) –> void

3. add_torsion(self: pyrosetta.rosetta.protocols.canonical_sampling.MetricRecorder, pose: pyrosetta.rosetta.core.pose.Pose, rsd: str, type: str, torsion: int) -> None
4. add_torsion(self: pyrosetta.rosetta.protocols.canonical_sampling.MetricRecorder, pose: pyrosetta.rosetta.core.pose.Pose, rsd: str, type: str, torsion: int, name: str) -> None

Include the given torsion in the output.

C++: protocols::canonical_sampling::MetricRecorder::add_torsion(const class core::pose::Pose &, const class std::basic_string<char> &, class std::basic_string<char>, unsigned long, class std::basic_string<char>) –> void

apply(self: pyrosetta.rosetta.protocols.canonical_sampling.MetricRecorder, pose: pyrosetta.rosetta.core.pose.Pose) → None

Just invoke update_after_boltzmann() with a const pose.

C++: protocols::canonical_sampling::MetricRecorder::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver, : pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver) → pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver

C++: protocols::canonical_sampling::ThermodynamicObserver::operator=(const class protocols::canonical_sampling::ThermodynamicObserver &) –> class protocols::canonical_sampling::ThermodynamicObserver &

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

Return a copy of this mover.

C++: protocols::canonical_sampling::MetricRecorder::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>

cumulate_jobs(*args, **kwargs)

Overloaded function.

1. cumulate_jobs(self: pyrosetta.rosetta.protocols.canonical_sampling.MetricRecorder) -> bool

Return true if every job is being reported to the same file.

C++: protocols::canonical_sampling::MetricRecorder::cumulate_jobs() const –> bool

2. cumulate_jobs(self: pyrosetta.rosetta.protocols.canonical_sampling.MetricRecorder, cumulate_jobs: bool) -> None

Indicate whether or not every job should be reported to the same

file.

C++: protocols::canonical_sampling::MetricRecorder::cumulate_jobs(bool) –> void

cumulate_replicas(*args, **kwargs)

Overloaded function.

1. cumulate_replicas(self: pyrosetta.rosetta.protocols.canonical_sampling.MetricRecorder) -> bool

Return true if every replica is being reported to the same file.

C++: protocols::canonical_sampling::MetricRecorder::cumulate_replicas() const –> bool

2. cumulate_replicas(self: pyrosetta.rosetta.protocols.canonical_sampling.MetricRecorder, cumulate_replicas: bool) -> None

Indicate whether or not every replica should be reported to the

same file.

C++: protocols::canonical_sampling::MetricRecorder::cumulate_replicas(bool) –> void

file_name(*args, **kwargs)

Overloaded function.

1. file_name(self: pyrosetta.rosetta.protocols.canonical_sampling.MetricRecorder) -> str

Return the name of the file being written to.

C++: protocols::canonical_sampling::MetricRecorder::file_name() const –> const std::string &

2. file_name(self: pyrosetta.rosetta.protocols.canonical_sampling.MetricRecorder, file_name: str) -> None

Set the name of the file being written to.

C++: protocols::canonical_sampling::MetricRecorder::file_name(const class std::basic_string<char> &) –> void

finalize_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.MetricRecorder, pose: pyrosetta.rosetta.core.pose.Pose, metropolis_hastings_mover: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) → None

C++: protocols::canonical_sampling::MetricRecorder::finalize_simulation(class core::pose::Pose &, const class protocols::canonical_sampling::MetropolisHastingsMover &) –> void

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

Return a newly instantiated mover.

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

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

fpd

Mechanism by which a mover may return multiple output poses from a single input pose.

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

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

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

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

A tag is a unique identifier used to identify structures produced

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

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

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

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

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

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

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

get_name(self: pyrosetta.rosetta.protocols.canonical_sampling.MetricRecorder) → str

C++: protocols::canonical_sampling::MetricRecorder::get_name() const –> std::string

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

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

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

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

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

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

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

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

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

non-const accessor

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

initialize_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.MetricRecorder, pose: pyrosetta.rosetta.core.pose.Pose, metropolis_hastings_mover: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, cycle: int) → None

C++: protocols::canonical_sampling::MetricRecorder::initialize_simulation(class core::pose::Pose &, const class protocols::canonical_sampling::MetropolisHastingsMover &, unsigned long) –> void

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

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

mover_name() → str

C++: protocols::canonical_sampling::MetricRecorder::mover_name() –> std::string

name() → str

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

observe_after_metropolis(self: pyrosetta.rosetta.protocols.canonical_sampling.MetricRecorder, metropolis_hastings_mover: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) → None

C++: protocols::canonical_sampling::MetricRecorder::observe_after_metropolis(const class protocols::canonical_sampling::MetropolisHastingsMover &) –> void

prepend_output_name(*args, **kwargs)

Overloaded function.

1. prepend_output_name(self: pyrosetta.rosetta.protocols.canonical_sampling.MetricRecorder) -> bool

Return true if the job name should be prepended onto the output

filename.

C++: protocols::canonical_sampling::MetricRecorder::prepend_output_name() const –> bool

2. prepend_output_name(self: pyrosetta.rosetta.protocols.canonical_sampling.MetricRecorder, prepend_output_name: bool) -> None

Indicate whether or not the job name should be prepended onto the

output filename.

C++: protocols::canonical_sampling::MetricRecorder::prepend_output_name(bool) –> void

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None

C++: protocols::canonical_sampling::MetricRecorder::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

register_options() → None

Overload this static method if you access options within the mover.

These options will end up in -help of your application if users of this mover call register_options. Do this recursively! If you use movers within your mover, call their register_options in your register_options() method.

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

reinitialize_for_each_job(self: pyrosetta.rosetta.protocols.canonical_sampling.MetricRecorder) → bool

Return true. This mover needs to be reinitialized for each job.

C++: protocols::canonical_sampling::MetricRecorder::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

requires_pose(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver) → bool

Return false if this observer does not require a valid pose.

TrialCounterObserver is an example of such an observer.

C++: protocols::canonical_sampling::ThermodynamicObserver::requires_pose() –> bool

reset(*args, **kwargs)

Overloaded function.

1. reset(self: pyrosetta.rosetta.protocols.canonical_sampling.MetricRecorder, pose: pyrosetta.rosetta.core.pose.Pose) -> None
2. reset(self: pyrosetta.rosetta.protocols.canonical_sampling.MetricRecorder, pose: pyrosetta.rosetta.core.pose.Pose, metropolis_hastings_mover: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) -> None

Truncate the output file and rewrite the output header.

This method may not actually truncate the output file. It really just closes and reopens the file, and I’m not sure whether or not it picks a new name when it does the reopening.

C++: protocols::canonical_sampling::MetricRecorder::reset(const class core::pose::Pose &, const class protocols::canonical_sampling::MetropolisHastingsMover *) –> void

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

resets status to SUCCESS, meant to be used before an apply(). The job distributor (august 08 vintage) uses this to ensure non-accumulation of status across apply()s.

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

restart_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver, : pyrosetta.rosetta.core.pose.Pose, : protocols::canonical_sampling::MetropolisHastingsMover, : int, : int, : float) → bool

Attempt to restart the last simulation that was recorded by this

observer.

For example, consider an observer that records trajectories. This method should open the file that was going to be written, read out the last pose in that trajectory, and assign it to the given pose reference so that the current trajectory can start from the same place. Other observers may help setup other parts of the simulation.

This is not a particularly robust system, because it may require several unrelated observers working in concert to properly reconstitute the simulation. In fact, the restart feature in MetropolisHastingsMover is currently commented out, so this method is never actually invoked. I would advise reimplementing this method to utility_exit_with_message() in any subclasses you write, so that you don’t waste time writing an unused method but so you don’t confuse anyone if this feature gets revived in the future.

C++: protocols::canonical_sampling::ThermodynamicObserver::restart_simulation(class core::pose::Pose &, class protocols::canonical_sampling::MetropolisHastingsMover &, unsigned long &, unsigned long &, double &) –> bool

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

////////////////////////////end Job Distributor interface////////////////////////////////////////

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

set_current_tag(self: pyrosetta.rosetta.protocols.moves.Mover, new_tag: str) → None

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

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

setter for poses contained for rms

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

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

setter for native poses contained for rms —- we should get rid of this method? it is widely used, but a bit unsafe

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

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

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

show(*args, **kwargs)

Overloaded function.

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

Outputs details about the Mover, including current settings.

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

stride(*args, **kwargs)

Overloaded function.

1. stride(self: pyrosetta.rosetta.protocols.canonical_sampling.MetricRecorder) -> int

Return the frequency with which data is written.

C++: protocols::canonical_sampling::MetricRecorder::stride() const –> unsigned long

2. stride(self: pyrosetta.rosetta.protocols.canonical_sampling.MetricRecorder, stride: int) -> None

Set the frequency with which data is written.

C++: protocols::canonical_sampling::MetricRecorder::stride(unsigned long) –> void

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

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

Allows extra test specific functions to be called before applying

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

type(*args, **kwargs)

Overloaded function.

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

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

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

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

update_after_boltzmann(*args, **kwargs)

Overloaded function.

1. update_after_boltzmann(self: pyrosetta.rosetta.protocols.canonical_sampling.MetricRecorder, pose: pyrosetta.rosetta.core.pose.Pose) -> None
2. update_after_boltzmann(self: pyrosetta.rosetta.protocols.canonical_sampling.MetricRecorder, pose: pyrosetta.rosetta.core.pose.Pose, metropolis_hastings_mover: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) -> None

Write information like temperature, score, and torsion angles to a

file.

C++: protocols::canonical_sampling::MetricRecorder::update_after_boltzmann(const class core::pose::Pose &, const class protocols::canonical_sampling::MetropolisHastingsMover *) –> void

class pyrosetta.rosetta.protocols.canonical_sampling.MetricRecorderCreator

Bases: pyrosetta.rosetta.protocols.moves.MoverCreator

RosettaScripts factory for MetricRecorder.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.protocols.canonical_sampling.MetricRecorderCreator) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

assign(self: pyrosetta.rosetta.protocols.canonical_sampling.MetricRecorderCreator, : pyrosetta.rosetta.protocols.canonical_sampling.MetricRecorderCreator) → pyrosetta.rosetta.protocols.canonical_sampling.MetricRecorderCreator

C++: protocols::canonical_sampling::MetricRecorderCreator::operator=(const class protocols::canonical_sampling::MetricRecorderCreator &) –> class protocols::canonical_sampling::MetricRecorderCreator &

create_mover(self: pyrosetta.rosetta.protocols.canonical_sampling.MetricRecorderCreator) → pyrosetta.rosetta.protocols.moves.Mover

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

keyname(self: pyrosetta.rosetta.protocols.canonical_sampling.MetricRecorderCreator) → str

C++: protocols::canonical_sampling::MetricRecorderCreator::keyname() const –> std::string

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

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

class pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover

Bases: pyrosetta.rosetta.protocols.moves.Mover

Manage the main loop of a canonical Monte Carlo simulation.

To make the simulation flexible, most aspects of the algorithm have been delegated to other classes. Use the add_mover() methods to control which moves are used during the simulation. Use the set_tempering() method to control how the temperature changes during the simulation. This can be used to setup simulated annealing or parallel tempering runs. Management of the score function is delegated to the underlying MonteCarlo object, so use set_monte_carlo() to specify a score function. Use add_observer() to keep track of statistics and to record the trajectory.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) -> None
2. __init__(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, arg0: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

add_backrub_mover(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, weight: float) → None

Convenience method to add a backrub move to the simulation.

C++: protocols::canonical_sampling::MetropolisHastingsMover::add_backrub_mover(double) –> void

add_ct_name(: str) → str

C++: protocols::canonical_sampling::MetropolisHastingsMover::add_ct_name(class std::basic_string<char>) –> std::string

add_kic_mover(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, weight: float, loop: pyrosetta.rosetta.protocols.loops.Loop) → None

Convenience method to add a kinematic closure move to the

simulation.

C++: protocols::canonical_sampling::MetropolisHastingsMover::add_kic_mover(double, const class protocols::loops::Loop &) –> void

add_mover(*args, **kwargs)

Overloaded function.

1. add_mover(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, mover: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicMover, weight: float, subtag: pyrosetta.rosetta.utility.tag.Tag) -> None

Add the given mover to the simulation.

C++: protocols::canonical_sampling::MetropolisHastingsMover::add_mover(class std::shared_ptr<class protocols::canonical_sampling::ThermodynamicMover>, double, const class std::shared_ptr<const class utility::tag::Tag> &) –> void

2. add_mover(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, mover: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicMover, weight: float) -> None

Add the given mover to the simulation.

C++: protocols::canonical_sampling::MetropolisHastingsMover::add_mover(class std::shared_ptr<class protocols::canonical_sampling::ThermodynamicMover>, double) –> void

add_observer(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, observer: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver) → None

Add the given observer to this simulation.

C++: protocols::canonical_sampling::MetropolisHastingsMover::add_observer(class std::shared_ptr<class protocols::canonical_sampling::ThermodynamicObserver>) –> void

add_shear_mover(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, weight: float) → None

Convenience method to add a shear move to the simulation.

C++: protocols::canonical_sampling::MetropolisHastingsMover::add_shear_mover(double) –> void

add_sidechain_mc_mover(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, weight: float, prob_uniform: float, prob_withinrot: float, preserve_cbeta: bool, ntrials: int) → None

Convenience method to add a Monte Carlo sidechain move to the

simulation. This move uses an internal Monte Carlo loop to generate a whole new set of sidechain conformations.

C++: protocols::canonical_sampling::MetropolisHastingsMover::add_sidechain_mc_mover(double, double, double, bool, unsigned long) –> void

add_sidechain_mover(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, weight: float, prob_uniform: float, prob_withinrot: float, preserve_cbeta: bool) → None

Convenience method to add a sidechain move to the simulation.

C++: protocols::canonical_sampling::MetropolisHastingsMover::add_sidechain_mover(double, double, double, bool) –> void

add_small_mover(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, weight: float) → None

Convenience method to add a small move to the simulation.

C++: protocols::canonical_sampling::MetropolisHastingsMover::add_small_mover(double) –> void

apply(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

Run the Metropolis-Hastings simulation.

C++: protocols::canonical_sampling::MetropolisHastingsMover::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, : pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) → pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover

C++: protocols::canonical_sampling::MetropolisHastingsMover::operator=(const class protocols::canonical_sampling::MetropolisHastingsMover &) –> class protocols::canonical_sampling::MetropolisHastingsMover &

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

Return a copy of this mover.

C++: protocols::canonical_sampling::MetropolisHastingsMover::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>

current_trial(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) → int

Return the iteration currently being processed by the simulation.

C++: protocols::canonical_sampling::MetropolisHastingsMover::current_trial() const –> unsigned long

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

Return a newly instantiated mover.

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

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

fpd

Mechanism by which a mover may return multiple output poses from a single input pose.

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

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

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

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

A tag is a unique identifier used to identify structures produced

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

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

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

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

get_last_checkpoint(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) → str

C++: protocols::canonical_sampling::MetropolisHastingsMover::get_last_checkpoint() const –> std::string

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.canonical_sampling.MetropolisHastingsMover) → str

C++: protocols::canonical_sampling::MetropolisHastingsMover::get_name() const –> std::string

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

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

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

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

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

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

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

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

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

non-const accessor

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

last_accepted(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) → bool

Return true if the last attempted move was accepted.

C++: protocols::canonical_sampling::MetropolisHastingsMover::last_accepted() const –> bool

last_move(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) → pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicMover

Return the most recently used ThermodynamicMover.

C++: protocols::canonical_sampling::MetropolisHastingsMover::last_move() const –> const class protocols::canonical_sampling::ThermodynamicMover &

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

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

monte_carlo(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) → pyrosetta.rosetta.protocols.moves.MonteCarlo

Return the MonteCarlo object being used by this simulation.

C++: protocols::canonical_sampling::MetropolisHastingsMover::monte_carlo() const –> class std::shared_ptr<const class protocols::moves::MonteCarlo>

mover_name() → str

C++: protocols::canonical_sampling::MetropolisHastingsMover::mover_name() –> std::string

mover_or_add_group_name() → str

C++: protocols::canonical_sampling::MetropolisHastingsMover::mover_or_add_group_name() –> std::string

name() → str

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

ntrials(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) → int

Return the number of iterations used by this simulation.

C++: protocols::canonical_sampling::MetropolisHastingsMover::ntrials() const –> unsigned long

output_file_name(*args, **kwargs)

Overloaded function.

1. output_file_name(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, suffix: str) -> str
2. output_file_name(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, suffix: str, cumulate_jobs: bool) -> str
3. output_file_name(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, suffix: str, cumulate_jobs: bool, cumulate_replicas: bool) -> str

Return a file name that is consistent with the given options.

If is true, the same filename will be returned for different jobs, so that the jobs all get cumulated in the same file. Likewise, if is true, the same filename will be returned for all replicas. If either of these options are set, MPI must be enabled.

C++: protocols::canonical_sampling::MetropolisHastingsMover::output_file_name(const class std::basic_string<char> &, bool, bool) const –> std::string

output_name(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) → str

Return the file name used by some of the observers to output data.

C++: protocols::canonical_sampling::MetropolisHastingsMover::output_name() const –> const std::string &

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None

C++: protocols::canonical_sampling::MetropolisHastingsMover::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

random_mover(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) → pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicMover

Return a randomly chosen mover to use in the next iteration.

C++: protocols::canonical_sampling::MetropolisHastingsMover::random_mover() const –> class std::shared_ptr<class protocols::canonical_sampling::ThermodynamicMover>

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

Return false. This mover does not need to be reinitialized for

each job.

C++: protocols::canonical_sampling::MetropolisHastingsMover::reinitialize_for_each_job() const –> bool

reinitialize_for_new_input(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) → bool

Return false. This mover does not need to be reinitialized for

new input.

C++: protocols::canonical_sampling::MetropolisHastingsMover::reinitialize_for_new_input() const –> bool

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

resets status to SUCCESS, meant to be used before an apply(). The job distributor (august 08 vintage) uses this to ensure non-accumulation of status across apply()s.

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

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

////////////////////////////end Job Distributor interface////////////////////////////////////////

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

set_current_tag(self: pyrosetta.rosetta.protocols.moves.Mover, new_tag: str) → None

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

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

setter for poses contained for rms

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

set_monte_carlo(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, monte_carlo: pyrosetta.rosetta.protocols.moves.MonteCarlo) → None

Provide a MonteCarlo object to use for this simulation.

C++: protocols::canonical_sampling::MetropolisHastingsMover::set_monte_carlo(class std::shared_ptr<class protocols::moves::MonteCarlo>) –> 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_ntrials(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, ntrials: int) → None

Set the number of iterations to use for this simulation.

C++: protocols::canonical_sampling::MetropolisHastingsMover::set_ntrials(unsigned long) –> void

set_output_name(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, output_name: str) → None

Set the file name used by some of the observers to output data.

C++: protocols::canonical_sampling::MetropolisHastingsMover::set_output_name(const class std::basic_string<char> &) –> void

set_tempering(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, : pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController) → None

Provide a TemperatureController to use for this simulation.

C++: protocols::canonical_sampling::MetropolisHastingsMover::set_tempering(class std::shared_ptr<class protocols::canonical_sampling::TemperatureController>) –> void

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

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

show(*args, **kwargs)

Overloaded function.

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

Outputs details about the Mover, including current settings.

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

tempering(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) → pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController

Return the TemperatureController being used by this simulation.

C++: protocols::canonical_sampling::MetropolisHastingsMover::tempering() const –> class std::shared_ptr<const class protocols::canonical_sampling::TemperatureController>

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

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

Allows extra test specific functions to be called before applying

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

type(*args, **kwargs)

Overloaded function.

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

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

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

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

class pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMoverCreator

Bases: pyrosetta.rosetta.protocols.moves.MoverCreator

RosettaScripts factory for MetropolisHastingsMover.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMoverCreator) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

assign(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMoverCreator, : pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMoverCreator) → pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMoverCreator

C++: protocols::canonical_sampling::MetropolisHastingsMoverCreator::operator=(const class protocols::canonical_sampling::MetropolisHastingsMoverCreator &) –> class protocols::canonical_sampling::MetropolisHastingsMoverCreator &

create_mover(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMoverCreator) → pyrosetta.rosetta.protocols.moves.Mover

Static alias for keyname(). Not sure why this is needed.

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

keyname(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMoverCreator) → str

C++: protocols::canonical_sampling::MetropolisHastingsMoverCreator::keyname() const –> std::string

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

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

class pyrosetta.rosetta.protocols.canonical_sampling.MultiTemperatureTrialCounter

Bases: pybind11_builtins.pybind11_object

Keep track of trial statistics for any number of replicas.

This class helps MetropolisHastingsMover keep track of move statistics. At the end of a simulation, operator[]() can be used to access the TrialCounter objects kept for each temperature level. Alternatively, the show() and write_to_file() methods can also be used to directly output acceptance rates to a stream or file.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__getitem__(self: pyrosetta.rosetta.protocols.canonical_sampling.MultiTemperatureTrialCounter, : int) → pyrosetta.rosetta.protocols.moves.TrialCounter

Return non-const access to the TrialCounter for the given

temperature level.

C++: protocols::canonical_sampling::MultiTemperatureTrialCounter::operator[](unsigned long) –> class protocols::moves::TrialCounter &

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.canonical_sampling.MultiTemperatureTrialCounter) -> None
2. __init__(self: pyrosetta.rosetta.protocols.canonical_sampling.MultiTemperatureTrialCounter, : pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController) -> None
3. __init__(self: pyrosetta.rosetta.protocols.canonical_sampling.MultiTemperatureTrialCounter, arg0: pyrosetta.rosetta.protocols.canonical_sampling.MultiTemperatureTrialCounter) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

assign(self: pyrosetta.rosetta.protocols.canonical_sampling.MultiTemperatureTrialCounter, : pyrosetta.rosetta.protocols.canonical_sampling.MultiTemperatureTrialCounter) → pyrosetta.rosetta.protocols.canonical_sampling.MultiTemperatureTrialCounter

C++: protocols::canonical_sampling::MultiTemperatureTrialCounter::operator=(const class protocols::canonical_sampling::MultiTemperatureTrialCounter &) –> class protocols::canonical_sampling::MultiTemperatureTrialCounter &

count_accepted(self: pyrosetta.rosetta.protocols.canonical_sampling.MultiTemperatureTrialCounter, : str) → None

Note that a move of the given type was accepted.

C++: protocols::canonical_sampling::MultiTemperatureTrialCounter::count_accepted(const class std::basic_string<char> &) –> void

count_energy_drop(self: pyrosetta.rosetta.protocols.canonical_sampling.MultiTemperatureTrialCounter, : str, : float) → None

Note that a move of the given type led to the given energy drop.

C++: protocols::canonical_sampling::MultiTemperatureTrialCounter::count_energy_drop(const class std::basic_string<char> &, double) –> void

count_trial(self: pyrosetta.rosetta.protocols.canonical_sampling.MultiTemperatureTrialCounter, : str) → None

Note that a move of the given type was attempted.

C++: protocols::canonical_sampling::MultiTemperatureTrialCounter::count_trial(const class std::basic_string<char> &) –> void

reset(self: pyrosetta.rosetta.protocols.canonical_sampling.MultiTemperatureTrialCounter) → None

Set all counters for all temperatures to zero.

C++: protocols::canonical_sampling::MultiTemperatureTrialCounter::reset() –> void

set_temperature_observer(self: pyrosetta.rosetta.protocols.canonical_sampling.MultiTemperatureTrialCounter, : pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController) → None

Set the temperature controller.

C++: protocols::canonical_sampling::MultiTemperatureTrialCounter::set_temperature_observer(const class protocols::canonical_sampling::TemperatureController *) –> void

show(*args, **kwargs)

Overloaded function.

1. show(self: pyrosetta.rosetta.protocols.canonical_sampling.MultiTemperatureTrialCounter, : pyrosetta.rosetta.std.ostream) -> None

Write acceptance rates for each move at each temperature to the

given stream.

C++: protocols::canonical_sampling::MultiTemperatureTrialCounter::show(class std::basic_ostream<char> &) const –> void

2. show(self: pyrosetta.rosetta.protocols.canonical_sampling.MultiTemperatureTrialCounter) -> None

Write acceptance rates for each move at each temperature to this

module’s tracer.

C++: protocols::canonical_sampling::MultiTemperatureTrialCounter::show() const –> void

write_to_file(self: pyrosetta.rosetta.protocols.canonical_sampling.MultiTemperatureTrialCounter, file: str, tag: str) → None

Write acceptance rates for each move at each temperature to the

given file.

C++: protocols::canonical_sampling::MultiTemperatureTrialCounter::write_to_file(const class std::basic_string<char> &, const class std::basic_string<char> &) const –> void

class pyrosetta.rosetta.protocols.canonical_sampling.PDBTrajectoryRecorder

Bases: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder

Record a trajectory to the PDB file format.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.canonical_sampling.PDBTrajectoryRecorder) -> None
2. __init__(self: pyrosetta.rosetta.protocols.canonical_sampling.PDBTrajectoryRecorder, arg0: pyrosetta.rosetta.protocols.canonical_sampling.PDBTrajectoryRecorder) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

apply(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder, pose: pyrosetta.rosetta.core.pose.Pose) → None

ThermodynamicObserver::apply

C++: protocols::canonical_sampling::TrajectoryRecorder::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver, : pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver) → pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver

C++: protocols::canonical_sampling::ThermodynamicObserver::operator=(const class protocols::canonical_sampling::ThermodynamicObserver &) –> class protocols::canonical_sampling::ThermodynamicObserver &

attributes_for_trajectory_recorder(: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t) → None

C++: protocols::canonical_sampling::TrajectoryRecorder::attributes_for_trajectory_recorder(class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &) –> void

cache_limit(*args, **kwargs)

Overloaded function.

1. cache_limit(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder) -> int

Return the number of poses that can be cached.

C++: protocols::canonical_sampling::TrajectoryRecorder::cache_limit() –> unsigned long

2. cache_limit(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder, limit: int) -> None

Specify the maximum number of poses that can be cached.

This option can also be specified on the command line using the

-trajectory:cache_limit flag. Note that some recorders don’t

use a cache at all, and will therefore ignore this option.

C++: protocols::canonical_sampling::TrajectoryRecorder::cache_limit(unsigned long) –> 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.canonical_sampling.PDBTrajectoryRecorder) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::canonical_sampling::PDBTrajectoryRecorder::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>

cumulate_jobs(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder) → bool

Return true if poses from different jobs will be written to the

same trajectory file.

I suspect this is only meant to be used in the context of jd2. This option can only be set from the command line using the -trajectory:cumulate_jobs flag.

C++: protocols::canonical_sampling::TrajectoryRecorder::cumulate_jobs() const –> bool

cumulate_replicas(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder) → bool

Return true if poses from different replicas will be written to

the same trajectory file.

I suspect this is only meant to be used in the context of jd2. This option can only be set from the command line using the -trajectory:cumulate_replicas flag.

C++: protocols::canonical_sampling::TrajectoryRecorder::cumulate_replicas() const –> bool

file_name(*args, **kwargs)

Overloaded function.

1. file_name(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder) -> str

Return the file name for the trajectory.

C++: protocols::canonical_sampling::TrajectoryRecorder::file_name() const –> const std::string &

2. file_name(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder, file_name: str) -> None

Set the file name for the trajectory.

C++: protocols::canonical_sampling::TrajectoryRecorder::file_name(const class std::basic_string<char> &) –> void

finalize_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.PDBTrajectoryRecorder, pose: pyrosetta.rosetta.core.pose.Pose, metropolis_hastings_mover: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) → None

C++: protocols::canonical_sampling::PDBTrajectoryRecorder::finalize_simulation(class core::pose::Pose &, const class protocols::canonical_sampling::MetropolisHastingsMover &) –> void

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

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

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

fpd

Mechanism by which a mover may return multiple output poses from a single input pose.

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

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

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

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

A tag is a unique identifier used to identify structures produced

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

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

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

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

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

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

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

get_name(self: pyrosetta.rosetta.protocols.canonical_sampling.PDBTrajectoryRecorder) → str

C++: protocols::canonical_sampling::PDBTrajectoryRecorder::get_name() const –> std::string

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

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

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

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

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

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

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

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

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

non-const accessor

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

initialize_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder, pose: pyrosetta.rosetta.core.pose.Pose, metropolis_hastings_mover: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, cycle: int) → None

ThermodynamicObserver::initialize_simulation

C++: protocols::canonical_sampling::TrajectoryRecorder::initialize_simulation(class core::pose::Pose &, const class protocols::canonical_sampling::MetropolisHastingsMover &, unsigned long) –> void

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

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

model_count(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder) → int

Return the number of models that have been saved so far.

C++: protocols::canonical_sampling::TrajectoryRecorder::model_count() const –> unsigned long

mover_name() → str

C++: protocols::canonical_sampling::PDBTrajectoryRecorder::mover_name() –> std::string

name() → str

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

observe_after_metropolis(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder, metropolis_hastings_mover: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) → None

ThermodynamicObserver::observe_after_metropolis

C++: protocols::canonical_sampling::TrajectoryRecorder::observe_after_metropolis(const class protocols::canonical_sampling::MetropolisHastingsMover &) –> void

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None

C++: protocols::canonical_sampling::PDBTrajectoryRecorder::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

register_options() → None

Associate relevant options with the TemperedDocking class.

C++: protocols::canonical_sampling::TrajectoryRecorder::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

requires_pose(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver) → bool

Return false if this observer does not require a valid pose.

TrialCounterObserver is an example of such an observer.

C++: protocols::canonical_sampling::ThermodynamicObserver::requires_pose() –> bool

reset(*args, **kwargs)

Overloaded function.

1. reset(self: pyrosetta.rosetta.protocols.canonical_sampling.PDBTrajectoryRecorder, mc: pyrosetta.rosetta.protocols.moves.MonteCarlo) -> None
2. reset(self: pyrosetta.rosetta.protocols.canonical_sampling.PDBTrajectoryRecorder, mc: pyrosetta.rosetta.protocols.moves.MonteCarlo, metropolis_hastings_mover: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) -> None

C++: protocols::canonical_sampling::PDBTrajectoryRecorder::reset(const class protocols::moves::MonteCarlo &, const class protocols::canonical_sampling::MetropolisHastingsMover *) –> void

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

resets status to SUCCESS, meant to be used before an apply(). The job distributor (august 08 vintage) uses this to ensure non-accumulation of status across apply()s.

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

restart_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver, : pyrosetta.rosetta.core.pose.Pose, : protocols::canonical_sampling::MetropolisHastingsMover, : int, : int, : float) → bool

Attempt to restart the last simulation that was recorded by this

observer.

For example, consider an observer that records trajectories. This method should open the file that was going to be written, read out the last pose in that trajectory, and assign it to the given pose reference so that the current trajectory can start from the same place. Other observers may help setup other parts of the simulation.

This is not a particularly robust system, because it may require several unrelated observers working in concert to properly reconstitute the simulation. In fact, the restart feature in MetropolisHastingsMover is currently commented out, so this method is never actually invoked. I would advise reimplementing this method to utility_exit_with_message() in any subclasses you write, so that you don’t waste time writing an unused method but so you don’t confuse anyone if this feature gets revived in the future.

C++: protocols::canonical_sampling::ThermodynamicObserver::restart_simulation(class core::pose::Pose &, class protocols::canonical_sampling::MetropolisHastingsMover &, unsigned long &, unsigned long &, double &) –> bool

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

////////////////////////////end Job Distributor interface////////////////////////////////////////

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

set_current_tag(self: pyrosetta.rosetta.protocols.moves.Mover, new_tag: str) → None

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

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

setter for poses contained for rms

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

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

setter for native poses contained for rms —- we should get rid of this method? it is widely used, but a bit unsafe

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

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

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

show(*args, **kwargs)

Overloaded function.

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

Outputs details about the Mover, including current settings.

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

step_count(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder) → int

Return the number of iterations that have occurred so far.

C++: protocols::canonical_sampling::TrajectoryRecorder::step_count() const –> unsigned long

stride(*args, **kwargs)

Overloaded function.

1. stride(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder) -> int

Return how often models should be written to the trajectory.

C++: protocols::canonical_sampling::TrajectoryRecorder::stride() const –> unsigned long

2. stride(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder, stride: int) -> None

Set how often models should be written to the trajectory.

This option can also be specified on the command line using the

-trajectory:stride flag.

C++: protocols::canonical_sampling::TrajectoryRecorder::stride(unsigned long) –> void

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

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

Allows extra test specific functions to be called before applying

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

type(*args, **kwargs)

Overloaded function.

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

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

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

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

update_after_boltzmann(*args, **kwargs)

Overloaded function.

1. update_after_boltzmann(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder, pose: pyrosetta.rosetta.core.pose.Pose) -> None
2. update_after_boltzmann(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder, pose: pyrosetta.rosetta.core.pose.Pose, metropolis_hastings_mover: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) -> None

ThermodynamicObserver::apply

C++: protocols::canonical_sampling::TrajectoryRecorder::update_after_boltzmann(const class core::pose::Pose &, const class protocols::canonical_sampling::MetropolisHastingsMover *) –> void

3. update_after_boltzmann(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder, mc: pyrosetta.rosetta.protocols.moves.MonteCarlo) -> None

ThermodynamicObserver::apply

C++: protocols::canonical_sampling::TrajectoryRecorder::update_after_boltzmann(const class protocols::moves::MonteCarlo &) –> void

class pyrosetta.rosetta.protocols.canonical_sampling.PDBTrajectoryRecorderCreator

Bases: pyrosetta.rosetta.protocols.moves.MoverCreator

RosettaScripts factory for PDBTrajectoryRecorder.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.protocols.canonical_sampling.PDBTrajectoryRecorderCreator) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

assign(self: pyrosetta.rosetta.protocols.canonical_sampling.PDBTrajectoryRecorderCreator, : pyrosetta.rosetta.protocols.canonical_sampling.PDBTrajectoryRecorderCreator) → pyrosetta.rosetta.protocols.canonical_sampling.PDBTrajectoryRecorderCreator

C++: protocols::canonical_sampling::PDBTrajectoryRecorderCreator::operator=(const class protocols::canonical_sampling::PDBTrajectoryRecorderCreator &) –> class protocols::canonical_sampling::PDBTrajectoryRecorderCreator &

create_mover(self: pyrosetta.rosetta.protocols.canonical_sampling.PDBTrajectoryRecorderCreator) → pyrosetta.rosetta.protocols.moves.Mover

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

keyname(self: pyrosetta.rosetta.protocols.canonical_sampling.PDBTrajectoryRecorderCreator) → str

C++: protocols::canonical_sampling::PDBTrajectoryRecorderCreator::keyname() const –> std::string

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

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

class pyrosetta.rosetta.protocols.canonical_sampling.ParallelTempering

Bases: pyrosetta.rosetta.protocols.canonical_sampling.TemperingBase

The only way to set the temperature range used for simulated annealing is to use the command line. The relevant options are:

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.canonical_sampling.ParallelTempering) -> None
2. __init__(self: pyrosetta.rosetta.protocols.canonical_sampling.ParallelTempering, arg0: pyrosetta.rosetta.protocols.canonical_sampling.ParallelTempering) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

apply(self: pyrosetta.rosetta.protocols.canonical_sampling.ParallelTempering, : pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::canonical_sampling::ParallelTempering::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.canonical_sampling.ParallelTempering, : pyrosetta.rosetta.protocols.canonical_sampling.ParallelTempering) → pyrosetta.rosetta.protocols.canonical_sampling.ParallelTempering

Assignment operator.

C++: protocols::canonical_sampling::ParallelTempering::operator=(const class protocols::canonical_sampling::ParallelTempering &) –> class protocols::canonical_sampling::ParallelTempering &

attributes_for_tempering_base(: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t, : pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None

C++: protocols::canonical_sampling::TemperingBase::attributes_for_tempering_base(class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &, class utility::tag::XMLSchemaDefinition &) –> 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.canonical_sampling.ParallelTempering) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::canonical_sampling::ParallelTempering::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>

exchange_grid_dim(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController) → int

C++: protocols::canonical_sampling::TemperatureController::exchange_grid_dim() const –> unsigned long

finalize_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.ParallelTempering, pose: pyrosetta.rosetta.core.pose.Pose, metropolis_hastings_mover: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) → None

C++: protocols::canonical_sampling::ParallelTempering::finalize_simulation(class core::pose::Pose &, const class protocols::canonical_sampling::MetropolisHastingsMover &) –> void

finished_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController, trials: int, ntrials: int) → bool

Return true if the simulation has been completed.

C++: protocols::canonical_sampling::TemperatureController::finished_simulation(unsigned long, unsigned long) –> bool

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

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

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

fpd

Mechanism by which a mover may return multiple output poses from a single input pose.

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

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

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

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

A tag is a unique identifier used to identify structures produced

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

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

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

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

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

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

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

get_name(self: pyrosetta.rosetta.protocols.canonical_sampling.ParallelTempering) → str

C++: protocols::canonical_sampling::ParallelTempering::get_name() const –> std::string

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

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

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

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

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

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

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

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

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

non-const accessor

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

initialize_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.ParallelTempering, pose: pyrosetta.rosetta.core.pose.Pose, metropolis_hastings_mover: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, cycle: int) → None

C++: protocols::canonical_sampling::ParallelTempering::initialize_simulation(class core::pose::Pose &, const class protocols::canonical_sampling::MetropolisHastingsMover &, unsigned long) –> void

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

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

level_2_grid_coord(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController, level: int) → pyrosetta.rosetta.utility.vector1_unsigned_long

C++: protocols::canonical_sampling::TemperatureController::level_2_grid_coord(unsigned long) const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

monte_carlo(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController) → pyrosetta.rosetta.protocols.moves.MonteCarlo

Return const access to the MonteCarlo object being controlled.

C++: protocols::canonical_sampling::TemperatureController::monte_carlo() const –> class std::shared_ptr<const class protocols::moves::MonteCarlo>

mover_name() → str

C++: protocols::canonical_sampling::ParallelTempering::mover_name() –> std::string

n_temp_levels(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperingBase) → int

C++: protocols::canonical_sampling::TemperingBase::n_temp_levels() const –> unsigned long

name() → str

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

nlevels_per_dim(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController, : int) → int

C++: protocols::canonical_sampling::TemperatureController::nlevels_per_dim(unsigned long) const –> unsigned long

observe_after_metropolis(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperingBase, metropolis_hastings_mover: protocols::canonical_sampling::MetropolisHastingsMover) → None

C++: protocols::canonical_sampling::TemperingBase::observe_after_metropolis(const class protocols::canonical_sampling::MetropolisHastingsMover &) –> void

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None

C++: protocols::canonical_sampling::ParallelTempering::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

register_options() → None

C++: protocols::canonical_sampling::ParallelTempering::register_options() –> void

reinitialize_for_each_job(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController) → bool

Return false. This class does not need to be reinitialized for

each job.

C++: protocols::canonical_sampling::TemperatureController::reinitialize_for_each_job() const –> bool

reinitialize_for_new_input(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController) → bool

Return false. This class does not need to be reinitialized for

new input.

C++: protocols::canonical_sampling::TemperatureController::reinitialize_for_new_input() const –> bool

requires_pose(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver) → bool

Return false if this observer does not require a valid pose.

TrialCounterObserver is an example of such an observer.

C++: protocols::canonical_sampling::ThermodynamicObserver::requires_pose() –> 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

restart_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver, : pyrosetta.rosetta.core.pose.Pose, : protocols::canonical_sampling::MetropolisHastingsMover, : int, : int, : float) → bool

Attempt to restart the last simulation that was recorded by this

observer.

For example, consider an observer that records trajectories. This method should open the file that was going to be written, read out the last pose in that trajectory, and assign it to the given pose reference so that the current trajectory can start from the same place. Other observers may help setup other parts of the simulation.

This is not a particularly robust system, because it may require several unrelated observers working in concert to properly reconstitute the simulation. In fact, the restart feature in MetropolisHastingsMover is currently commented out, so this method is never actually invoked. I would advise reimplementing this method to utility_exit_with_message() in any subclasses you write, so that you don’t waste time writing an unused method but so you don’t confuse anyone if this feature gets revived in the future.

C++: protocols::canonical_sampling::ThermodynamicObserver::restart_simulation(class core::pose::Pose &, class protocols::canonical_sampling::MetropolisHastingsMover &, unsigned long &, unsigned long &, double &) –> bool

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

////////////////////////////end Job Distributor interface////////////////////////////////////////

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

set_current_tag(self: pyrosetta.rosetta.protocols.moves.Mover, new_tag: str) → None

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

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

setter for poses contained for rms

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

set_monte_carlo(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController, monte_carlo: pyrosetta.rosetta.protocols.moves.MonteCarlo) → None

Set the MonteCarlo object to be controlled.

C++: protocols::canonical_sampling::TemperatureController::set_monte_carlo(class std::shared_ptr<class protocols::moves::MonteCarlo>) –> void

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

setter for native poses contained for rms —- we should get rid of this method? it is widely used, but a bit unsafe

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

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

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

show(*args, **kwargs)

Overloaded function.

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

Outputs details about the Mover, including current settings.

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

temperature(*args, **kwargs)

Overloaded function.

1. temperature(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperingBase) -> float

Return the temperature of the underlying MonteCarlo object.

C++: protocols::canonical_sampling::TemperingBase::temperature() const –> double

2. temperature(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperingBase, level: int) -> float

Return the temperature of the given level.

C++: protocols::canonical_sampling::TemperingBase::temperature(unsigned long) const –> double

temperature_level(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperingBase) → int

C++: protocols::canonical_sampling::TemperingBase::temperature_level() const –> unsigned long

temperature_move(self: pyrosetta.rosetta.protocols.canonical_sampling.ParallelTempering, score: float) → float

C++: protocols::canonical_sampling::ParallelTempering::temperature_move(double) –> double

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

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

Allows extra test specific functions to be called before applying

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

type(*args, **kwargs)

Overloaded function.

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

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

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

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

class pyrosetta.rosetta.protocols.canonical_sampling.ParallelTemperingCreator

Bases: pyrosetta.rosetta.protocols.moves.MoverCreator

RosettaScripts factory for ParallelTempering.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.protocols.canonical_sampling.ParallelTemperingCreator) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

assign(self: pyrosetta.rosetta.protocols.canonical_sampling.ParallelTemperingCreator, : pyrosetta.rosetta.protocols.canonical_sampling.ParallelTemperingCreator) → pyrosetta.rosetta.protocols.canonical_sampling.ParallelTemperingCreator

C++: protocols::canonical_sampling::ParallelTemperingCreator::operator=(const class protocols::canonical_sampling::ParallelTemperingCreator &) –> class protocols::canonical_sampling::ParallelTemperingCreator &

create_mover(self: pyrosetta.rosetta.protocols.canonical_sampling.ParallelTemperingCreator) → pyrosetta.rosetta.protocols.moves.Mover

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

keyname(self: pyrosetta.rosetta.protocols.canonical_sampling.ParallelTemperingCreator) → str

C++: protocols::canonical_sampling::ParallelTemperingCreator::keyname() const –> std::string

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

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

class pyrosetta.rosetta.protocols.canonical_sampling.ProgressBarObserver

Bases: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver

Print an progress bar that updated on each iteration.

The progress bar is currently written to stdout, which of course is not a tracer. I’m not really sure if this is a good idea or not. I think it’d be cool to detect whether or not rosetta is attached to a TTY and change how the progress bar is drawn depending. For example, when writing to files it’s nicer to not write carriage return ‘’ characters.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.canonical_sampling.ProgressBarObserver) -> None
2. __init__(self: pyrosetta.rosetta.protocols.canonical_sampling.ProgressBarObserver, arg0: pyrosetta.rosetta.protocols.canonical_sampling.ProgressBarObserver) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

apply(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver, : pyrosetta.rosetta.core.pose.Pose) → None

Callback executed after each move is made.

Even though the argument is a reference to a non-const pose, this method should not make any changes to the pose. Making changes to the pose is the role of the ThermodynamicMover class. The role of this class is to simply observe the poses being generated.

C++: protocols::canonical_sampling::ThermodynamicObserver::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.canonical_sampling.ProgressBarObserver, : pyrosetta.rosetta.protocols.canonical_sampling.ProgressBarObserver) → pyrosetta.rosetta.protocols.canonical_sampling.ProgressBarObserver

C++: protocols::canonical_sampling::ProgressBarObserver::operator=(const class protocols::canonical_sampling::ProgressBarObserver &) –> class protocols::canonical_sampling::ProgressBarObserver &

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

C++: protocols::canonical_sampling::ProgressBarObserver::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>

finalize_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver, : pyrosetta.rosetta.core.pose.Pose, : protocols::canonical_sampling::MetropolisHastingsMover) → None

Callback executed after all Monte Carlo trials are completed.

C++: protocols::canonical_sampling::ThermodynamicObserver::finalize_simulation(class core::pose::Pose &, const class protocols::canonical_sampling::MetropolisHastingsMover &) –> void

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

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

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

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

fpd

Mechanism by which a mover may return multiple output poses from a single input pose.

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

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

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

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

A tag is a unique identifier used to identify structures produced

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

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

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

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

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

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

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

get_name(self: pyrosetta.rosetta.protocols.canonical_sampling.ProgressBarObserver) → str

C++: protocols::canonical_sampling::ProgressBarObserver::get_name() const –> std::string

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

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

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

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

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

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

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

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

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

non-const accessor

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

initialize_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver, : pyrosetta.rosetta.core.pose.Pose, : protocols::canonical_sampling::MetropolisHastingsMover, : int) → None

Callback executed before any Monte Carlo trials are attempted.

C++: protocols::canonical_sampling::ThermodynamicObserver::initialize_simulation(class core::pose::Pose &, const class protocols::canonical_sampling::MetropolisHastingsMover &, unsigned long) –> void

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

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

name() → str

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

observe_after_metropolis(self: pyrosetta.rosetta.protocols.canonical_sampling.ProgressBarObserver, metropolis_hastings_mover: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) → None

C++: protocols::canonical_sampling::ProgressBarObserver::observe_after_metropolis(const class protocols::canonical_sampling::MetropolisHastingsMover &) –> void

register_options() → None

Overload this static method if you access options within the mover.

These options will end up in -help of your application if users of this mover call register_options. Do this recursively! If you use movers within your mover, call their register_options in your register_options() method.

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

reinitialize_for_each_job(self: pyrosetta.rosetta.protocols.moves.Mover) → bool

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be freshly regenerated on

each use.

C++: protocols::moves::Mover::reinitialize_for_each_job() const –> bool

reinitialize_for_new_input(self: pyrosetta.rosetta.protocols.moves.Mover) → bool

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be regenerated when the input

pose is about to change, (for example, if the Mover has special code on the first apply() that is only valid for that one input pose).

C++: protocols::moves::Mover::reinitialize_for_new_input() const –> bool

requires_pose(self: pyrosetta.rosetta.protocols.canonical_sampling.ProgressBarObserver) → bool

Return false, as a valid pose is not required for printing a

progress bar.

C++: protocols::canonical_sampling::ProgressBarObserver::requires_pose() –> 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

restart_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver, : pyrosetta.rosetta.core.pose.Pose, : protocols::canonical_sampling::MetropolisHastingsMover, : int, : int, : float) → bool

Attempt to restart the last simulation that was recorded by this

observer.

For example, consider an observer that records trajectories. This method should open the file that was going to be written, read out the last pose in that trajectory, and assign it to the given pose reference so that the current trajectory can start from the same place. Other observers may help setup other parts of the simulation.

This is not a particularly robust system, because it may require several unrelated observers working in concert to properly reconstitute the simulation. In fact, the restart feature in MetropolisHastingsMover is currently commented out, so this method is never actually invoked. I would advise reimplementing this method to utility_exit_with_message() in any subclasses you write, so that you don’t waste time writing an unused method but so you don’t confuse anyone if this feature gets revived in the future.

C++: protocols::canonical_sampling::ThermodynamicObserver::restart_simulation(class core::pose::Pose &, class protocols::canonical_sampling::MetropolisHastingsMover &, unsigned long &, unsigned long &, double &) –> bool

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

////////////////////////////end Job Distributor interface////////////////////////////////////////

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

set_current_tag(self: pyrosetta.rosetta.protocols.moves.Mover, new_tag: str) → None

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

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

setter for poses contained for rms

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

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

setter for native poses contained for rms —- we should get rid of this method? it is widely used, but a bit unsafe

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

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

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

show(*args, **kwargs)

Overloaded function.

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

Outputs details about the Mover, including current settings.

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

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

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

Allows extra test specific functions to be called before applying

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

type(*args, **kwargs)

Overloaded function.

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

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

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

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

class pyrosetta.rosetta.protocols.canonical_sampling.ProgressBarObserverCreator

Bases: pyrosetta.rosetta.protocols.moves.MoverCreator

RosettaScripts factory for ProgressBarObserver.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.protocols.canonical_sampling.ProgressBarObserverCreator) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

assign(self: pyrosetta.rosetta.protocols.canonical_sampling.ProgressBarObserverCreator, : pyrosetta.rosetta.protocols.canonical_sampling.ProgressBarObserverCreator) → pyrosetta.rosetta.protocols.canonical_sampling.ProgressBarObserverCreator

C++: protocols::canonical_sampling::ProgressBarObserverCreator::operator=(const class protocols::canonical_sampling::ProgressBarObserverCreator &) –> class protocols::canonical_sampling::ProgressBarObserverCreator &

create_mover(self: pyrosetta.rosetta.protocols.canonical_sampling.ProgressBarObserverCreator) → pyrosetta.rosetta.protocols.moves.Mover

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

keyname(self: pyrosetta.rosetta.protocols.canonical_sampling.ProgressBarObserverCreator) → str

C++: protocols::canonical_sampling::ProgressBarObserverCreator::keyname() const –> std::string

mover_name() → str

C++: protocols::canonical_sampling::ProgressBarObserverCreator::mover_name() –> std::string

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

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

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

class pyrosetta.rosetta.protocols.canonical_sampling.SidechainMetropolisHastingsMover

Bases: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover

Run a sidechain-only canonical Monte Carlo simulation.

The Monte Carlo algorithm present in apply() has been optimized for the case where only the sidechains can moves. This makes it possible speed up score function evaluation by either precalculating and/or caching residue pair energies. In this specific case, however, I’m not exactly sure how the algorithm is doing its optimization.

Although this class inherits from MetropolisHastingsMover, it doesn’t support all of its parent’s interface. In particular, since the algorithm is customized for a particular sidechain move, movers added via add_mover() or its related methods are ignored. However, observers added via add_observer() can still be used to report on the state of the simulation.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.canonical_sampling.SidechainMetropolisHastingsMover) -> None
2. __init__(self: pyrosetta.rosetta.protocols.canonical_sampling.SidechainMetropolisHastingsMover, stride: int) -> None
3. __init__(self: pyrosetta.rosetta.protocols.canonical_sampling.SidechainMetropolisHastingsMover, arg0: pyrosetta.rosetta.protocols.canonical_sampling.SidechainMetropolisHastingsMover) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

add_backrub_mover(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, weight: float) → None

Convenience method to add a backrub move to the simulation.

C++: protocols::canonical_sampling::MetropolisHastingsMover::add_backrub_mover(double) –> void

add_ct_name(: str) → str

C++: protocols::canonical_sampling::MetropolisHastingsMover::add_ct_name(class std::basic_string<char>) –> std::string

add_kic_mover(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, weight: float, loop: pyrosetta.rosetta.protocols.loops.Loop) → None

Convenience method to add a kinematic closure move to the

simulation.

C++: protocols::canonical_sampling::MetropolisHastingsMover::add_kic_mover(double, const class protocols::loops::Loop &) –> void

add_mover(*args, **kwargs)

Overloaded function.

1. add_mover(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, mover: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicMover, weight: float, subtag: pyrosetta.rosetta.utility.tag.Tag) -> None

Add the given mover to the simulation.

C++: protocols::canonical_sampling::MetropolisHastingsMover::add_mover(class std::shared_ptr<class protocols::canonical_sampling::ThermodynamicMover>, double, const class std::shared_ptr<const class utility::tag::Tag> &) –> void

2. add_mover(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, mover: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicMover, weight: float) -> None

Add the given mover to the simulation.

C++: protocols::canonical_sampling::MetropolisHastingsMover::add_mover(class std::shared_ptr<class protocols::canonical_sampling::ThermodynamicMover>, double) –> void

add_observer(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, observer: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver) → None

Add the given observer to this simulation.

C++: protocols::canonical_sampling::MetropolisHastingsMover::add_observer(class std::shared_ptr<class protocols::canonical_sampling::ThermodynamicObserver>) –> void

add_shear_mover(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, weight: float) → None

Convenience method to add a shear move to the simulation.

C++: protocols::canonical_sampling::MetropolisHastingsMover::add_shear_mover(double) –> void

add_sidechain_mc_mover(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, weight: float, prob_uniform: float, prob_withinrot: float, preserve_cbeta: bool, ntrials: int) → None

Convenience method to add a Monte Carlo sidechain move to the

simulation. This move uses an internal Monte Carlo loop to generate a whole new set of sidechain conformations.

C++: protocols::canonical_sampling::MetropolisHastingsMover::add_sidechain_mc_mover(double, double, double, bool, unsigned long) –> void

add_sidechain_mover(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, weight: float, prob_uniform: float, prob_withinrot: float, preserve_cbeta: bool) → None

Convenience method to add a sidechain move to the simulation.

C++: protocols::canonical_sampling::MetropolisHastingsMover::add_sidechain_mover(double, double, double, bool) –> void

add_small_mover(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, weight: float) → None

Convenience method to add a small move to the simulation.

C++: protocols::canonical_sampling::MetropolisHastingsMover::add_small_mover(double) –> void

apply(self: pyrosetta.rosetta.protocols.canonical_sampling.SidechainMetropolisHastingsMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

Run the sidechain-only simulation.

C++: protocols::canonical_sampling::SidechainMetropolisHastingsMover::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.canonical_sampling.SidechainMetropolisHastingsMover, : pyrosetta.rosetta.protocols.canonical_sampling.SidechainMetropolisHastingsMover) → pyrosetta.rosetta.protocols.canonical_sampling.SidechainMetropolisHastingsMover

C++: protocols::canonical_sampling::SidechainMetropolisHastingsMover::operator=(const class protocols::canonical_sampling::SidechainMetropolisHastingsMover &) –> class protocols::canonical_sampling::SidechainMetropolisHastingsMover &

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

C++: protocols::canonical_sampling::SidechainMetropolisHastingsMover::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>

current_trial(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) → int

Return the iteration currently being processed by the simulation.

C++: protocols::canonical_sampling::MetropolisHastingsMover::current_trial() const –> unsigned long

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

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

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

fpd

Mechanism by which a mover may return multiple output poses from a single input pose.

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

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

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

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

A tag is a unique identifier used to identify structures produced

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

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

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

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

get_last_checkpoint(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) → str

C++: protocols::canonical_sampling::MetropolisHastingsMover::get_last_checkpoint() const –> std::string

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.canonical_sampling.SidechainMetropolisHastingsMover) → str

C++: protocols::canonical_sampling::SidechainMetropolisHastingsMover::get_name() const –> std::string

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

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

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

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

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

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

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

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

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

non-const accessor

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

last_accepted(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) → bool

Return true if the last attempted move was accepted.

C++: protocols::canonical_sampling::MetropolisHastingsMover::last_accepted() const –> bool

last_move(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) → pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicMover

Return the most recently used ThermodynamicMover.

C++: protocols::canonical_sampling::MetropolisHastingsMover::last_move() const –> const class protocols::canonical_sampling::ThermodynamicMover &

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

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

monte_carlo(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) → pyrosetta.rosetta.protocols.moves.MonteCarlo

Return the MonteCarlo object being used by this simulation.

C++: protocols::canonical_sampling::MetropolisHastingsMover::monte_carlo() const –> class std::shared_ptr<const class protocols::moves::MonteCarlo>

mover_name() → str

C++: protocols::canonical_sampling::MetropolisHastingsMover::mover_name() –> std::string

mover_or_add_group_name() → str

C++: protocols::canonical_sampling::MetropolisHastingsMover::mover_or_add_group_name() –> std::string

name() → str

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

ntrials(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) → int

Return the number of iterations used by this simulation.

C++: protocols::canonical_sampling::MetropolisHastingsMover::ntrials() const –> unsigned long

output_count(self: pyrosetta.rosetta.protocols.canonical_sampling.SidechainMetropolisHastingsMover, ct: int) → int

Return non-zero if the observers should be invoked on this

iteration.

set_stride()

C++: protocols::canonical_sampling::SidechainMetropolisHastingsMover::output_count(unsigned long) const –> unsigned long

output_file_name(*args, **kwargs)

Overloaded function.

1. output_file_name(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, suffix: str) -> str
2. output_file_name(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, suffix: str, cumulate_jobs: bool) -> str
3. output_file_name(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, suffix: str, cumulate_jobs: bool, cumulate_replicas: bool) -> str

Return a file name that is consistent with the given options.

If is true, the same filename will be returned for different jobs, so that the jobs all get cumulated in the same file. Likewise, if is true, the same filename will be returned for all replicas. If either of these options are set, MPI must be enabled.

C++: protocols::canonical_sampling::MetropolisHastingsMover::output_file_name(const class std::basic_string<char> &, bool, bool) const –> std::string

output_name(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) → str

Return the file name used by some of the observers to output data.

C++: protocols::canonical_sampling::MetropolisHastingsMover::output_name() const –> const std::string &

pass_metropolis(self: pyrosetta.rosetta.protocols.canonical_sampling.SidechainMetropolisHastingsMover, delta_energy: float, last_proposal_density_ratio: float) → bool

Return true if a move should be accepted, given

and

C++: protocols::canonical_sampling::SidechainMetropolisHastingsMover::pass_metropolis(double, double) const –> bool

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None

C++: protocols::canonical_sampling::MetropolisHastingsMover::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

random_mover(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) → pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicMover

Return a randomly chosen mover to use in the next iteration.

C++: protocols::canonical_sampling::MetropolisHastingsMover::random_mover() const –> class std::shared_ptr<class protocols::canonical_sampling::ThermodynamicMover>

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

Return false. This mover does not need to be reinitialized for

each job.

C++: protocols::canonical_sampling::MetropolisHastingsMover::reinitialize_for_each_job() const –> bool

reinitialize_for_new_input(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) → bool

Return false. This mover does not need to be reinitialized for

new input.

C++: protocols::canonical_sampling::MetropolisHastingsMover::reinitialize_for_new_input() const –> bool

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

resets status to SUCCESS, meant to be used before an apply(). The job distributor (august 08 vintage) uses this to ensure non-accumulation of status across apply()s.

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

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

////////////////////////////end Job Distributor interface////////////////////////////////////////

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

set_current_tag(self: pyrosetta.rosetta.protocols.moves.Mover, new_tag: str) → None

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

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

setter for poses contained for rms

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

set_monte_carlo(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, monte_carlo: pyrosetta.rosetta.protocols.moves.MonteCarlo) → None

Provide a MonteCarlo object to use for this simulation.

C++: protocols::canonical_sampling::MetropolisHastingsMover::set_monte_carlo(class std::shared_ptr<class protocols::moves::MonteCarlo>) –> 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_ntrials(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, ntrials: int) → None

Set the number of iterations to use for this simulation.

C++: protocols::canonical_sampling::MetropolisHastingsMover::set_ntrials(unsigned long) –> void

set_output_name(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, output_name: str) → None

Set the file name used by some of the observers to output data.

C++: protocols::canonical_sampling::MetropolisHastingsMover::set_output_name(const class std::basic_string<char> &) –> void

set_stride(self: pyrosetta.rosetta.protocols.canonical_sampling.SidechainMetropolisHastingsMover, setting: int) → None

Set the frequency with which the observers should be invoked.

output_count()

C++: protocols::canonical_sampling::SidechainMetropolisHastingsMover::set_stride(unsigned long) –> void

set_tempering(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, : pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController) → None

Provide a TemperatureController to use for this simulation.

C++: protocols::canonical_sampling::MetropolisHastingsMover::set_tempering(class std::shared_ptr<class protocols::canonical_sampling::TemperatureController>) –> void

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

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

show(*args, **kwargs)

Overloaded function.

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

Outputs details about the Mover, including current settings.

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

tempering(self: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) → pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController

Return the TemperatureController being used by this simulation.

C++: protocols::canonical_sampling::MetropolisHastingsMover::tempering() const –> class std::shared_ptr<const class protocols::canonical_sampling::TemperatureController>

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

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

Allows extra test specific functions to be called before applying

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

type(*args, **kwargs)

Overloaded function.

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

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

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

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

class pyrosetta.rosetta.protocols.canonical_sampling.SidechainMetropolisHastingsMoverCreator

Bases: pyrosetta.rosetta.protocols.moves.MoverCreator

RosettaScripts factory for SidechainMetropolisHastingsMover.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.protocols.canonical_sampling.SidechainMetropolisHastingsMoverCreator) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

assign(self: pyrosetta.rosetta.protocols.canonical_sampling.SidechainMetropolisHastingsMoverCreator, : pyrosetta.rosetta.protocols.canonical_sampling.SidechainMetropolisHastingsMoverCreator) → pyrosetta.rosetta.protocols.canonical_sampling.SidechainMetropolisHastingsMoverCreator

C++: protocols::canonical_sampling::SidechainMetropolisHastingsMoverCreator::operator=(const class protocols::canonical_sampling::SidechainMetropolisHastingsMoverCreator &) –> class protocols::canonical_sampling::SidechainMetropolisHastingsMoverCreator &

create_mover(self: pyrosetta.rosetta.protocols.canonical_sampling.SidechainMetropolisHastingsMoverCreator) → pyrosetta.rosetta.protocols.moves.Mover

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

keyname(self: pyrosetta.rosetta.protocols.canonical_sampling.SidechainMetropolisHastingsMoverCreator) → str

C++: protocols::canonical_sampling::SidechainMetropolisHastingsMoverCreator::keyname() const –> std::string

mover_name() → str

C++: protocols::canonical_sampling::SidechainMetropolisHastingsMoverCreator::mover_name() –> std::string

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

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

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

class pyrosetta.rosetta.protocols.canonical_sampling.SilentTrajectoryRecorder

Bases: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder

Record a trajectory to the rosetta-specific silent file format.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.canonical_sampling.SilentTrajectoryRecorder) -> None
2. __init__(self: pyrosetta.rosetta.protocols.canonical_sampling.SilentTrajectoryRecorder, arg0: pyrosetta.rosetta.protocols.canonical_sampling.SilentTrajectoryRecorder) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

apply(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder, pose: pyrosetta.rosetta.core.pose.Pose) → None

ThermodynamicObserver::apply

C++: protocols::canonical_sampling::TrajectoryRecorder::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver, : pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver) → pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver

C++: protocols::canonical_sampling::ThermodynamicObserver::operator=(const class protocols::canonical_sampling::ThermodynamicObserver &) –> class protocols::canonical_sampling::ThermodynamicObserver &

attributes_for_trajectory_recorder(: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t) → None

C++: protocols::canonical_sampling::TrajectoryRecorder::attributes_for_trajectory_recorder(class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &) –> void

cache_limit(*args, **kwargs)

Overloaded function.

1. cache_limit(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder) -> int

Return the number of poses that can be cached.

C++: protocols::canonical_sampling::TrajectoryRecorder::cache_limit() –> unsigned long

2. cache_limit(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder, limit: int) -> None

Specify the maximum number of poses that can be cached.

This option can also be specified on the command line using the

-trajectory:cache_limit flag. Note that some recorders don’t

use a cache at all, and will therefore ignore this option.

C++: protocols::canonical_sampling::TrajectoryRecorder::cache_limit(unsigned long) –> 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.canonical_sampling.SilentTrajectoryRecorder) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::canonical_sampling::SilentTrajectoryRecorder::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>

cumulate_jobs(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder) → bool

Return true if poses from different jobs will be written to the

same trajectory file.

I suspect this is only meant to be used in the context of jd2. This option can only be set from the command line using the -trajectory:cumulate_jobs flag.

C++: protocols::canonical_sampling::TrajectoryRecorder::cumulate_jobs() const –> bool

cumulate_replicas(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder) → bool

Return true if poses from different replicas will be written to

the same trajectory file.

I suspect this is only meant to be used in the context of jd2. This option can only be set from the command line using the -trajectory:cumulate_replicas flag.

C++: protocols::canonical_sampling::TrajectoryRecorder::cumulate_replicas() const –> bool

file_name(*args, **kwargs)

Overloaded function.

1. file_name(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder) -> str

Return the file name for the trajectory.

C++: protocols::canonical_sampling::TrajectoryRecorder::file_name() const –> const std::string &

2. file_name(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder, file_name: str) -> None

Set the file name for the trajectory.

C++: protocols::canonical_sampling::TrajectoryRecorder::file_name(const class std::basic_string<char> &) –> void

finalize_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver, : pyrosetta.rosetta.core.pose.Pose, : protocols::canonical_sampling::MetropolisHastingsMover) → None

Callback executed after all Monte Carlo trials are completed.

C++: protocols::canonical_sampling::ThermodynamicObserver::finalize_simulation(class core::pose::Pose &, const class protocols::canonical_sampling::MetropolisHastingsMover &) –> void

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

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

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

fpd

Mechanism by which a mover may return multiple output poses from a single input pose.

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

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

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

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

A tag is a unique identifier used to identify structures produced

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

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

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

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

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

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

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

get_name(self: pyrosetta.rosetta.protocols.canonical_sampling.SilentTrajectoryRecorder) → str

C++: protocols::canonical_sampling::SilentTrajectoryRecorder::get_name() const –> std::string

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

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

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

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

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

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

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

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

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

non-const accessor

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

initialize_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.SilentTrajectoryRecorder, pose: pyrosetta.rosetta.core.pose.Pose, metropolis_hastings_mover: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, cycle: int) → None

C++: protocols::canonical_sampling::SilentTrajectoryRecorder::initialize_simulation(class core::pose::Pose &, const class protocols::canonical_sampling::MetropolisHastingsMover &, unsigned long) –> void

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

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

model_count(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder) → int

Return the number of models that have been saved so far.

C++: protocols::canonical_sampling::TrajectoryRecorder::model_count() const –> unsigned long

mover_name() → str

C++: protocols::canonical_sampling::SilentTrajectoryRecorder::mover_name() –> std::string

name() → str

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

observe_after_metropolis(self: pyrosetta.rosetta.protocols.canonical_sampling.SilentTrajectoryRecorder, metropolis_hastings_mover: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) → None

C++: protocols::canonical_sampling::SilentTrajectoryRecorder::observe_after_metropolis(const class protocols::canonical_sampling::MetropolisHastingsMover &) –> void

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None

C++: protocols::canonical_sampling::SilentTrajectoryRecorder::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

register_options() → None

Associates relevant options with the TemperedDocking class.

C++: protocols::canonical_sampling::SilentTrajectoryRecorder::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

requires_pose(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver) → bool

Return false if this observer does not require a valid pose.

TrialCounterObserver is an example of such an observer.

C++: protocols::canonical_sampling::ThermodynamicObserver::requires_pose() –> bool

reset(*args, **kwargs)

Overloaded function.

1. reset(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder, mc: pyrosetta.rosetta.protocols.moves.MonteCarlo) -> None
2. reset(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder, mc: pyrosetta.rosetta.protocols.moves.MonteCarlo, metropolis_hastings_mover: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) -> None

Callback executed whenever the simulation is initialized or reset.

C++: protocols::canonical_sampling::TrajectoryRecorder::reset(const class protocols::moves::MonteCarlo &, const class protocols::canonical_sampling::MetropolisHastingsMover *) –> void

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

resets status to SUCCESS, meant to be used before an apply(). The job distributor (august 08 vintage) uses this to ensure non-accumulation of status across apply()s.

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

restart_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.SilentTrajectoryRecorder, pose: pyrosetta.rosetta.core.pose.Pose, metropolis_hastings_mover: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, cycle: int, temp_level: int, temperature: float) → bool

C++: protocols::canonical_sampling::SilentTrajectoryRecorder::restart_simulation(class core::pose::Pose &, class protocols::canonical_sampling::MetropolisHastingsMover &, unsigned long &, unsigned long &, double &) –> bool

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

////////////////////////////end Job Distributor interface////////////////////////////////////////

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

set_current_tag(self: pyrosetta.rosetta.protocols.moves.Mover, new_tag: str) → None

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

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

setter for poses contained for rms

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

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

setter for native poses contained for rms —- we should get rid of this method? it is widely used, but a bit unsafe

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

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

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

show(*args, **kwargs)

Overloaded function.

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

Outputs details about the Mover, including current settings.

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

step_count(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder) → int

Return the number of iterations that have occurred so far.

C++: protocols::canonical_sampling::TrajectoryRecorder::step_count() const –> unsigned long

stride(*args, **kwargs)

Overloaded function.

1. stride(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder) -> int

Return how often models should be written to the trajectory.

C++: protocols::canonical_sampling::TrajectoryRecorder::stride() const –> unsigned long

2. stride(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder, stride: int) -> None

Set how often models should be written to the trajectory.

This option can also be specified on the command line using the

-trajectory:stride flag.

C++: protocols::canonical_sampling::TrajectoryRecorder::stride(unsigned long) –> void

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

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

Allows extra test specific functions to be called before applying

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

type(*args, **kwargs)

Overloaded function.

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

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

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

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

update_after_boltzmann(*args, **kwargs)

Overloaded function.

1. update_after_boltzmann(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder, pose: pyrosetta.rosetta.core.pose.Pose) -> None
2. update_after_boltzmann(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder, pose: pyrosetta.rosetta.core.pose.Pose, metropolis_hastings_mover: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) -> None

ThermodynamicObserver::apply

C++: protocols::canonical_sampling::TrajectoryRecorder::update_after_boltzmann(const class core::pose::Pose &, const class protocols::canonical_sampling::MetropolisHastingsMover *) –> void

3. update_after_boltzmann(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder, mc: pyrosetta.rosetta.protocols.moves.MonteCarlo) -> None

ThermodynamicObserver::apply

C++: protocols::canonical_sampling::TrajectoryRecorder::update_after_boltzmann(const class protocols::moves::MonteCarlo &) –> void

class pyrosetta.rosetta.protocols.canonical_sampling.SilentTrajectoryRecorderCreator

Bases: pyrosetta.rosetta.protocols.moves.MoverCreator

RosettaScripts factory for SilentTrajectoryRecorder.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.protocols.canonical_sampling.SilentTrajectoryRecorderCreator) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

assign(self: pyrosetta.rosetta.protocols.canonical_sampling.SilentTrajectoryRecorderCreator, : pyrosetta.rosetta.protocols.canonical_sampling.SilentTrajectoryRecorderCreator) → pyrosetta.rosetta.protocols.canonical_sampling.SilentTrajectoryRecorderCreator

C++: protocols::canonical_sampling::SilentTrajectoryRecorderCreator::operator=(const class protocols::canonical_sampling::SilentTrajectoryRecorderCreator &) –> class protocols::canonical_sampling::SilentTrajectoryRecorderCreator &

create_mover(self: pyrosetta.rosetta.protocols.canonical_sampling.SilentTrajectoryRecorderCreator) → pyrosetta.rosetta.protocols.moves.Mover

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

keyname(self: pyrosetta.rosetta.protocols.canonical_sampling.SilentTrajectoryRecorderCreator) → str

C++: protocols::canonical_sampling::SilentTrajectoryRecorderCreator::keyname() const –> std::string

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

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

class pyrosetta.rosetta.protocols.canonical_sampling.SimulatedTempering

Bases: pyrosetta.rosetta.protocols.canonical_sampling.TemperingBase

The only way to set the temperature range used for simulated annealing is to use the command line. The relevant options are:

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.canonical_sampling.SimulatedTempering) -> None
2. __init__(self: pyrosetta.rosetta.protocols.canonical_sampling.SimulatedTempering, arg0: pyrosetta.rosetta.protocols.canonical_sampling.SimulatedTempering) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

apply(self: pyrosetta.rosetta.protocols.canonical_sampling.SimulatedTempering, : pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::canonical_sampling::SimulatedTempering::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.canonical_sampling.SimulatedTempering, : pyrosetta.rosetta.protocols.canonical_sampling.SimulatedTempering) → pyrosetta.rosetta.protocols.canonical_sampling.SimulatedTempering

C++: protocols::canonical_sampling::SimulatedTempering::operator=(const class protocols::canonical_sampling::SimulatedTempering &) –> class protocols::canonical_sampling::SimulatedTempering &

attributes_for_tempering_base(: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t, : pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None

C++: protocols::canonical_sampling::TemperingBase::attributes_for_tempering_base(class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &, class utility::tag::XMLSchemaDefinition &) –> 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.canonical_sampling.SimulatedTempering) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::canonical_sampling::SimulatedTempering::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>

exchange_grid_dim(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController) → int

C++: protocols::canonical_sampling::TemperatureController::exchange_grid_dim() const –> unsigned long

finalize_simulation(*args, **kwargs)

Overloaded function.

1. finalize_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.SimulatedTempering, pose: pyrosetta.rosetta.core.pose.Pose, metropolis_hastings_mover: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) -> None

callback executed after all Monte Carlo trials

C++: protocols::canonical_sampling::SimulatedTempering::finalize_simulation(class core::pose::Pose &, const class protocols::canonical_sampling::MetropolisHastingsMover &) –> void

2. finalize_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.SimulatedTempering, output_name: str) -> None

C++: protocols::canonical_sampling::SimulatedTempering::finalize_simulation(const class std::basic_string<char> &) –> void

finished_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController, trials: int, ntrials: int) → bool

Return true if the simulation has been completed.

C++: protocols::canonical_sampling::TemperatureController::finished_simulation(unsigned long, unsigned long) –> bool

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

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

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

fpd

Mechanism by which a mover may return multiple output poses from a single input pose.

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

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

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

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

A tag is a unique identifier used to identify structures produced

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

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

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

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

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

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

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

get_name(self: pyrosetta.rosetta.protocols.canonical_sampling.SimulatedTempering) → str

C++: protocols::canonical_sampling::SimulatedTempering::get_name() const –> std::string

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

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

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

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

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

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

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

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

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

non-const accessor

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

initialize_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.SimulatedTempering, pose: pyrosetta.rosetta.core.pose.Pose, metropolis_hastings_mover: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, cycle: int) → None

callback executed before any Monte Carlo trials

C++: protocols::canonical_sampling::SimulatedTempering::initialize_simulation(class core::pose::Pose &, const class protocols::canonical_sampling::MetropolisHastingsMover &, unsigned long) –> void

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

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

level_2_grid_coord(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController, level: int) → pyrosetta.rosetta.utility.vector1_unsigned_long

C++: protocols::canonical_sampling::TemperatureController::level_2_grid_coord(unsigned long) const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

monte_carlo(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController) → pyrosetta.rosetta.protocols.moves.MonteCarlo

Return const access to the MonteCarlo object being controlled.

C++: protocols::canonical_sampling::TemperatureController::monte_carlo() const –> class std::shared_ptr<const class protocols::moves::MonteCarlo>

mover_name() → str

C++: protocols::canonical_sampling::SimulatedTempering::mover_name() –> std::string

n_temp_levels(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperingBase) → int

C++: protocols::canonical_sampling::TemperingBase::n_temp_levels() const –> unsigned long

name() → str

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

nlevels_per_dim(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController, : int) → int

C++: protocols::canonical_sampling::TemperatureController::nlevels_per_dim(unsigned long) const –> unsigned long

observe_after_metropolis(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperingBase, metropolis_hastings_mover: protocols::canonical_sampling::MetropolisHastingsMover) → None

C++: protocols::canonical_sampling::TemperingBase::observe_after_metropolis(const class protocols::canonical_sampling::MetropolisHastingsMover &) –> void

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None

C++: protocols::canonical_sampling::SimulatedTempering::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

register_options() → None

C++: protocols::canonical_sampling::SimulatedTempering::register_options() –> void

reinitialize_for_each_job(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController) → bool

Return false. This class does not need to be reinitialized for

each job.

C++: protocols::canonical_sampling::TemperatureController::reinitialize_for_each_job() const –> bool

reinitialize_for_new_input(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController) → bool

Return false. This class does not need to be reinitialized for

new input.

C++: protocols::canonical_sampling::TemperatureController::reinitialize_for_new_input() const –> bool

requires_pose(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver) → bool

Return false if this observer does not require a valid pose.

TrialCounterObserver is an example of such an observer.

C++: protocols::canonical_sampling::ThermodynamicObserver::requires_pose() –> 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

restart_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver, : pyrosetta.rosetta.core.pose.Pose, : protocols::canonical_sampling::MetropolisHastingsMover, : int, : int, : float) → bool

Attempt to restart the last simulation that was recorded by this

observer.

For example, consider an observer that records trajectories. This method should open the file that was going to be written, read out the last pose in that trajectory, and assign it to the given pose reference so that the current trajectory can start from the same place. Other observers may help setup other parts of the simulation.

This is not a particularly robust system, because it may require several unrelated observers working in concert to properly reconstitute the simulation. In fact, the restart feature in MetropolisHastingsMover is currently commented out, so this method is never actually invoked. I would advise reimplementing this method to utility_exit_with_message() in any subclasses you write, so that you don’t waste time writing an unused method but so you don’t confuse anyone if this feature gets revived in the future.

C++: protocols::canonical_sampling::ThermodynamicObserver::restart_simulation(class core::pose::Pose &, class protocols::canonical_sampling::MetropolisHastingsMover &, unsigned long &, unsigned long &, double &) –> bool

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

////////////////////////////end Job Distributor interface////////////////////////////////////////

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

set_current_tag(self: pyrosetta.rosetta.protocols.moves.Mover, new_tag: str) → None

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

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

setter for poses contained for rms

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

set_monte_carlo(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController, monte_carlo: pyrosetta.rosetta.protocols.moves.MonteCarlo) → None

Set the MonteCarlo object to be controlled.

C++: protocols::canonical_sampling::TemperatureController::set_monte_carlo(class std::shared_ptr<class protocols::moves::MonteCarlo>) –> void

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

setter for native poses contained for rms —- we should get rid of this method? it is widely used, but a bit unsafe

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

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

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

show(*args, **kwargs)

Overloaded function.

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

Outputs details about the Mover, including current settings.

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

temperature(*args, **kwargs)

Overloaded function.

1. temperature(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperingBase) -> float

Return the temperature of the underlying MonteCarlo object.

C++: protocols::canonical_sampling::TemperingBase::temperature() const –> double

2. temperature(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperingBase, level: int) -> float

Return the temperature of the given level.

C++: protocols::canonical_sampling::TemperingBase::temperature(unsigned long) const –> double

temperature_level(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperingBase) → int

C++: protocols::canonical_sampling::TemperingBase::temperature_level() const –> unsigned long

temperature_move(self: pyrosetta.rosetta.protocols.canonical_sampling.SimulatedTempering, score: float) → float

execute the temperatur move ( called by observer_after_metropolis )

returns the current temperatur in kT.

C++: protocols::canonical_sampling::SimulatedTempering::temperature_move(double) –> double

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

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

Allows extra test specific functions to be called before applying

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

type(*args, **kwargs)

Overloaded function.

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

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

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

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

class pyrosetta.rosetta.protocols.canonical_sampling.SimulatedTemperingCreator

Bases: pyrosetta.rosetta.protocols.moves.MoverCreator

RosettaScripts factory for SimulatedTempering.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.protocols.canonical_sampling.SimulatedTemperingCreator) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

assign(self: pyrosetta.rosetta.protocols.canonical_sampling.SimulatedTemperingCreator, : pyrosetta.rosetta.protocols.canonical_sampling.SimulatedTemperingCreator) → pyrosetta.rosetta.protocols.canonical_sampling.SimulatedTemperingCreator

C++: protocols::canonical_sampling::SimulatedTemperingCreator::operator=(const class protocols::canonical_sampling::SimulatedTemperingCreator &) –> class protocols::canonical_sampling::SimulatedTemperingCreator &

create_mover(self: pyrosetta.rosetta.protocols.canonical_sampling.SimulatedTemperingCreator) → pyrosetta.rosetta.protocols.moves.Mover

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

keyname(self: pyrosetta.rosetta.protocols.canonical_sampling.SimulatedTemperingCreator) → str

C++: protocols::canonical_sampling::SimulatedTemperingCreator::keyname() const –> std::string

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

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

class pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController

Bases: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver

Base class for controlling the temperature of a simulation.

Many schemes to improve the performance of condensed phase Monte Carlo simulations depends on changing the temperature of the system. Common examples include simulated annealing and parallel tempering. This class provides an interface for writing these algorithms. The most important method is temperature_move(), which is responsible for actually changing the temperature of the MonteCarlo object used for the underlying simulation. Methods like temperature_level() are also provided for managing a discrete number of different temperature levels, which is a common feature of these algorithms.

The TemperingBase class serves a similar role to this one, but is geared towards controllers that actually intend to change the temperature. This class also is parent to FixedTemperatureController, which is the default controller used by MetropolisHastingsMover.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController) -> None
2. __init__(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController, arg0: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

apply(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController, : pyrosetta.rosetta.core.pose.Pose) → None

No-op implemented only to satisfy the Mover interface.

C++: protocols::canonical_sampling::TemperatureController::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController, : pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController) → pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController

C++: protocols::canonical_sampling::TemperatureController::operator=(const class protocols::canonical_sampling::TemperatureController &) –> class protocols::canonical_sampling::TemperatureController &

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>

exchange_grid_dim(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController) → int

C++: protocols::canonical_sampling::TemperatureController::exchange_grid_dim() const –> unsigned long

finalize_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver, : pyrosetta.rosetta.core.pose.Pose, : protocols::canonical_sampling::MetropolisHastingsMover) → None

Callback executed after all Monte Carlo trials are completed.

C++: protocols::canonical_sampling::ThermodynamicObserver::finalize_simulation(class core::pose::Pose &, const class protocols::canonical_sampling::MetropolisHastingsMover &) –> void

finished_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController, trials: int, ntrials: int) → bool

Return true if the simulation has been completed.

C++: protocols::canonical_sampling::TemperatureController::finished_simulation(unsigned long, unsigned long) –> bool

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

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

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

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

fpd

Mechanism by which a mover may return multiple output poses from a single input pose.

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

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

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

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

A tag is a unique identifier used to identify structures produced

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

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

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

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

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

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

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

get_name(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController) → str

Return the name of this class.

C++: protocols::canonical_sampling::TemperatureController::get_name() const –> std::string

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

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

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

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

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

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

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

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

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

non-const accessor

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

initialize_simulation(*args, **kwargs)

Overloaded function.

1. initialize_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController, pose: pyrosetta.rosetta.core.pose.Pose, metropolis_hastings_mover: protocols::canonical_sampling::MetropolisHastingsMover, level: int, temperature: float, cycle: int) -> None

C++: protocols::canonical_sampling::TemperatureController::initialize_simulation(class core::pose::Pose &, const class protocols::canonical_sampling::MetropolisHastingsMover &, unsigned long, double, unsigned long) –> void

2. initialize_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController, : pyrosetta.rosetta.core.pose.Pose, : protocols::canonical_sampling::MetropolisHastingsMover, : int) -> None

C++: protocols::canonical_sampling::TemperatureController::initialize_simulation(class core::pose::Pose &, const class protocols::canonical_sampling::MetropolisHastingsMover &, unsigned long) –> void

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

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

level_2_grid_coord(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController, level: int) → pyrosetta.rosetta.utility.vector1_unsigned_long

C++: protocols::canonical_sampling::TemperatureController::level_2_grid_coord(unsigned long) const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

monte_carlo(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController) → pyrosetta.rosetta.protocols.moves.MonteCarlo

Return const access to the MonteCarlo object being controlled.

C++: protocols::canonical_sampling::TemperatureController::monte_carlo() const –> class std::shared_ptr<const class protocols::moves::MonteCarlo>

n_temp_levels(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController) → int

Return the number of temperature levels used by this controller.

temperature_level()

C++: protocols::canonical_sampling::TemperatureController::n_temp_levels() const –> unsigned long

name() → str

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

nlevels_per_dim(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController, : int) → int

C++: protocols::canonical_sampling::TemperatureController::nlevels_per_dim(unsigned long) const –> unsigned long

observe_after_metropolis(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController, metropolis_hastings_mover: protocols::canonical_sampling::MetropolisHastingsMover) → None

C++: protocols::canonical_sampling::TemperatureController::observe_after_metropolis(const class protocols::canonical_sampling::MetropolisHastingsMover &) –> void

register_options() → None

Overload this static method if you access options within the mover.

These options will end up in -help of your application if users of this mover call register_options. Do this recursively! If you use movers within your mover, call their register_options in your register_options() method.

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

reinitialize_for_each_job(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController) → bool

Return false. This class does not need to be reinitialized for

each job.

C++: protocols::canonical_sampling::TemperatureController::reinitialize_for_each_job() const –> bool

reinitialize_for_new_input(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController) → bool

Return false. This class does not need to be reinitialized for

new input.

C++: protocols::canonical_sampling::TemperatureController::reinitialize_for_new_input() const –> bool

requires_pose(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver) → bool

Return false if this observer does not require a valid pose.

TrialCounterObserver is an example of such an observer.

C++: protocols::canonical_sampling::ThermodynamicObserver::requires_pose() –> 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

restart_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver, : pyrosetta.rosetta.core.pose.Pose, : protocols::canonical_sampling::MetropolisHastingsMover, : int, : int, : float) → bool

Attempt to restart the last simulation that was recorded by this

observer.

For example, consider an observer that records trajectories. This method should open the file that was going to be written, read out the last pose in that trajectory, and assign it to the given pose reference so that the current trajectory can start from the same place. Other observers may help setup other parts of the simulation.

This is not a particularly robust system, because it may require several unrelated observers working in concert to properly reconstitute the simulation. In fact, the restart feature in MetropolisHastingsMover is currently commented out, so this method is never actually invoked. I would advise reimplementing this method to utility_exit_with_message() in any subclasses you write, so that you don’t waste time writing an unused method but so you don’t confuse anyone if this feature gets revived in the future.

C++: protocols::canonical_sampling::ThermodynamicObserver::restart_simulation(class core::pose::Pose &, class protocols::canonical_sampling::MetropolisHastingsMover &, unsigned long &, unsigned long &, double &) –> bool

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

////////////////////////////end Job Distributor interface////////////////////////////////////////

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

set_current_tag(self: pyrosetta.rosetta.protocols.moves.Mover, new_tag: str) → None

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

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

setter for poses contained for rms

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

set_monte_carlo(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController, monte_carlo: pyrosetta.rosetta.protocols.moves.MonteCarlo) → None

Set the MonteCarlo object to be controlled.

C++: protocols::canonical_sampling::TemperatureController::set_monte_carlo(class std::shared_ptr<class protocols::moves::MonteCarlo>) –> void

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

setter for native poses contained for rms —- we should get rid of this method? it is widely used, but a bit unsafe

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

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

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

show(*args, **kwargs)

Overloaded function.

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

Outputs details about the Mover, including current settings.

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

temperature(*args, **kwargs)

Overloaded function.

1. temperature(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController) -> float

Return the current temperature.

C++: protocols::canonical_sampling::TemperatureController::temperature() const –> double

2. temperature(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController, level: int) -> float

Set the current temperature to match given level.

C++: protocols::canonical_sampling::TemperatureController::temperature(unsigned long) const –> double

temperature_level(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController) → int

Return the current temperature level.

Tempering controllers often work with a handful of discrete temperature levels. This method makes it possible to work with levels, which are discrete, rather than temperatures, which are continuous.

n_temp_levels()

temperature()

C++: protocols::canonical_sampling::TemperatureController::temperature_level() const –> unsigned long

temperature_move(*args, **kwargs)

Overloaded function.

1. temperature_move(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController, score: float) -> float

Execute the temperature move.

This method is called by observe_after_metropolis() and is expected to return the new temperature (in units of kT, to the extent that that is meaningful in the context of rosetta).

C++: protocols::canonical_sampling::TemperatureController::temperature_move(double) –> double

2. temperature_move(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController, pose: pyrosetta.rosetta.core.pose.Pose) -> float

Execute a temperature move which depends on the current pose.

The default implementation just calls the pose-independent temperature_pose() method with the energy of the given pose. However, the HamiltonianExchange temperature controller needs to evaluate the alternative Hamiltonian.

C++: protocols::canonical_sampling::TemperatureController::temperature_move(class core::pose::Pose &) –> double

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

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

Allows extra test specific functions to be called before applying

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

type(*args, **kwargs)

Overloaded function.

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

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

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

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

class pyrosetta.rosetta.protocols.canonical_sampling.TemperingBase

Bases: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController

Base class for tempering Monte Carlo optimizations.

Many important Monte Carlo optimization techniques, like simulated annealing and parallel tempering, depend on a changing temperature schedule. TemperatureController provides the essential interface for providing this functionality. This class provides a lot of useful protected member functions, especially with regard to input (i.e. command-line or file) and output (i.e. tracer or silent file).

That said, my first impression is that this class really limits what you can do in terms of output. The emphasis seems to be on silent files, so it would be hard to instead use (for example) database output. In general, putting IO code in a base class seems like a bad idea. Better to do that kind of stuff with object composition, so different IO formats can easily be swapped in and out. Perhaps this would be a good target for a small refactoring project.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperingBase) -> None
2. __init__(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperingBase, arg0: pyrosetta.rosetta.protocols.canonical_sampling.TemperingBase) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

apply(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperingBase, : pyrosetta.rosetta.core.pose.Pose) → None

No-op implemented only to satisfy the Mover interface.

C++: protocols::canonical_sampling::TemperingBase::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperingBase, : pyrosetta.rosetta.protocols.canonical_sampling.TemperingBase) → pyrosetta.rosetta.protocols.canonical_sampling.TemperingBase

C++: protocols::canonical_sampling::TemperingBase::operator=(const class protocols::canonical_sampling::TemperingBase &) –> class protocols::canonical_sampling::TemperingBase &

attributes_for_tempering_base(: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t, : pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None

C++: protocols::canonical_sampling::TemperingBase::attributes_for_tempering_base(class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &, class utility::tag::XMLSchemaDefinition &) –> 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>

exchange_grid_dim(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController) → int

C++: protocols::canonical_sampling::TemperatureController::exchange_grid_dim() const –> unsigned long

finalize_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperingBase, pose: pyrosetta.rosetta.core.pose.Pose, metropolis_hastings_mover: protocols::canonical_sampling::MetropolisHastingsMover) → None

C++: protocols::canonical_sampling::TemperingBase::finalize_simulation(class core::pose::Pose &, const class protocols::canonical_sampling::MetropolisHastingsMover &) –> void

finished_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController, trials: int, ntrials: int) → bool

Return true if the simulation has been completed.

C++: protocols::canonical_sampling::TemperatureController::finished_simulation(unsigned long, unsigned long) –> bool

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

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

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

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

fpd

Mechanism by which a mover may return multiple output poses from a single input pose.

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

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

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

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

A tag is a unique identifier used to identify structures produced

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

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

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

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

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

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

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

get_name(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperingBase) → str

C++: protocols::canonical_sampling::TemperingBase::get_name() const –> std::string

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

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

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

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

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

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

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

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

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

non-const accessor

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

initialize_simulation(*args, **kwargs)

Overloaded function.

1. initialize_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperingBase, pose: pyrosetta.rosetta.core.pose.Pose, metropolis_hastings_mover: protocols::canonical_sampling::MetropolisHastingsMover, cycle: int) -> None

C++: protocols::canonical_sampling::TemperingBase::initialize_simulation(class core::pose::Pose &, const class protocols::canonical_sampling::MetropolisHastingsMover &, unsigned long) –> void

2. initialize_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperingBase, pose: pyrosetta.rosetta.core.pose.Pose, metropolis_hastings_mover: protocols::canonical_sampling::MetropolisHastingsMover, level: int, temperature: float, cycle: int) -> None

C++: protocols::canonical_sampling::TemperingBase::initialize_simulation(class core::pose::Pose &, const class protocols::canonical_sampling::MetropolisHastingsMover &, unsigned long, double, unsigned long) –> void

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

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

level_2_grid_coord(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController, level: int) → pyrosetta.rosetta.utility.vector1_unsigned_long

C++: protocols::canonical_sampling::TemperatureController::level_2_grid_coord(unsigned long) const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

monte_carlo(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController) → pyrosetta.rosetta.protocols.moves.MonteCarlo

Return const access to the MonteCarlo object being controlled.

C++: protocols::canonical_sampling::TemperatureController::monte_carlo() const –> class std::shared_ptr<const class protocols::moves::MonteCarlo>

n_temp_levels(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperingBase) → int

C++: protocols::canonical_sampling::TemperingBase::n_temp_levels() const –> unsigned long

name() → str

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

nlevels_per_dim(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController, : int) → int

C++: protocols::canonical_sampling::TemperatureController::nlevels_per_dim(unsigned long) const –> unsigned long

observe_after_metropolis(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperingBase, metropolis_hastings_mover: protocols::canonical_sampling::MetropolisHastingsMover) → None

C++: protocols::canonical_sampling::TemperingBase::observe_after_metropolis(const class protocols::canonical_sampling::MetropolisHastingsMover &) –> void

register_options() → None

Register the options used by this mover with the global options

system.

C++: protocols::canonical_sampling::TemperingBase::register_options() –> void

reinitialize_for_each_job(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController) → bool

Return false. This class does not need to be reinitialized for

each job.

C++: protocols::canonical_sampling::TemperatureController::reinitialize_for_each_job() const –> bool

reinitialize_for_new_input(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController) → bool

Return false. This class does not need to be reinitialized for

new input.

C++: protocols::canonical_sampling::TemperatureController::reinitialize_for_new_input() const –> bool

requires_pose(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver) → bool

Return false if this observer does not require a valid pose.

TrialCounterObserver is an example of such an observer.

C++: protocols::canonical_sampling::ThermodynamicObserver::requires_pose() –> 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

restart_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver, : pyrosetta.rosetta.core.pose.Pose, : protocols::canonical_sampling::MetropolisHastingsMover, : int, : int, : float) → bool

Attempt to restart the last simulation that was recorded by this

observer.

For example, consider an observer that records trajectories. This method should open the file that was going to be written, read out the last pose in that trajectory, and assign it to the given pose reference so that the current trajectory can start from the same place. Other observers may help setup other parts of the simulation.

This is not a particularly robust system, because it may require several unrelated observers working in concert to properly reconstitute the simulation. In fact, the restart feature in MetropolisHastingsMover is currently commented out, so this method is never actually invoked. I would advise reimplementing this method to utility_exit_with_message() in any subclasses you write, so that you don’t waste time writing an unused method but so you don’t confuse anyone if this feature gets revived in the future.

C++: protocols::canonical_sampling::ThermodynamicObserver::restart_simulation(class core::pose::Pose &, class protocols::canonical_sampling::MetropolisHastingsMover &, unsigned long &, unsigned long &, double &) –> bool

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

////////////////////////////end Job Distributor interface////////////////////////////////////////

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

set_current_tag(self: pyrosetta.rosetta.protocols.moves.Mover, new_tag: str) → None

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

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

setter for poses contained for rms

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

set_monte_carlo(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController, monte_carlo: pyrosetta.rosetta.protocols.moves.MonteCarlo) → None

Set the MonteCarlo object to be controlled.

C++: protocols::canonical_sampling::TemperatureController::set_monte_carlo(class std::shared_ptr<class protocols::moves::MonteCarlo>) –> void

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

setter for native poses contained for rms —- we should get rid of this method? it is widely used, but a bit unsafe

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

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

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

show(*args, **kwargs)

Overloaded function.

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

Outputs details about the Mover, including current settings.

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

temperature(*args, **kwargs)

Overloaded function.

1. temperature(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperingBase) -> float

Return the temperature of the underlying MonteCarlo object.

C++: protocols::canonical_sampling::TemperingBase::temperature() const –> double

2. temperature(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperingBase, level: int) -> float

Return the temperature of the given level.

C++: protocols::canonical_sampling::TemperingBase::temperature(unsigned long) const –> double

temperature_level(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperingBase) → int

C++: protocols::canonical_sampling::TemperingBase::temperature_level() const –> unsigned long

temperature_move(*args, **kwargs)

Overloaded function.

1. temperature_move(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController, score: float) -> float

Execute the temperature move.

This method is called by observe_after_metropolis() and is expected to return the new temperature (in units of kT, to the extent that that is meaningful in the context of rosetta).

C++: protocols::canonical_sampling::TemperatureController::temperature_move(double) –> double

2. temperature_move(self: pyrosetta.rosetta.protocols.canonical_sampling.TemperatureController, pose: pyrosetta.rosetta.core.pose.Pose) -> float

Execute a temperature move which depends on the current pose.

The default implementation just calls the pose-independent temperature_pose() method with the energy of the given pose. However, the HamiltonianExchange temperature controller needs to evaluate the alternative Hamiltonian.

C++: protocols::canonical_sampling::TemperatureController::temperature_move(class core::pose::Pose &) –> double

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

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

Allows extra test specific functions to be called before applying

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

type(*args, **kwargs)

Overloaded function.

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

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

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

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

class pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicMover

Bases: pyrosetta.rosetta.protocols.moves.Mover

Base class for moves that can obey detailed balance.

In order to sample a thermodynamic state using a Monte Carlo simulation, the moves must obey detailed balance. This base class provides a framework for writing moves that can obey this condition. One interesting method is set_preserve_detailed_balance(), which indicates whether or not detailed balance needs to be obeyed. This flag makes it possible to implement fancy (but biased) features for use in contexts where rigorous thermodynamic sampling isn’t needed. If the move requires a non-unity proposal ratio to obey detailed balance, it can reimplement last_proposal_density_ratio(). Support for movers that make multiple trial moves under the hood is provided by is_multi_trial() and its related methods. A number of callbacks, including initialize_simulation(), observe_after_metropolis(), and finalize_simulation(), are also defined to let the mover react to certain milestones in the simulation.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicMover) -> None
2. __init__(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicMover, arg0: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicMover) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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

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

assign(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicMover, : pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicMover) → pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicMover

C++: protocols::canonical_sampling::ThermodynamicMover::operator=(const class protocols::canonical_sampling::ThermodynamicMover &) –> class protocols::canonical_sampling::ThermodynamicMover &

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>

finalize_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicMover, pose: pyrosetta.rosetta.core.pose.Pose, metropolis_hastings_mover: protocols::canonical_sampling::MetropolisHastingsMover) → None

Callback executed after all Monte Carlo trials are completed.

C++: protocols::canonical_sampling::ThermodynamicMover::finalize_simulation(class core::pose::Pose &, const class protocols::canonical_sampling::MetropolisHastingsMover &) –> void

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

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

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

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

fpd

Mechanism by which a mover may return multiple output poses from a single input pose.

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

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

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

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

A tag is a unique identifier used to identify structures produced

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

non-const accessor

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

initialize_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicMover, pose: pyrosetta.rosetta.core.pose.Pose, metropolis_hastings_mover: protocols::canonical_sampling::MetropolisHastingsMover, cycle: int) → None

Callback executed before any Monte Carlo trials are attempted.

C++: protocols::canonical_sampling::ThermodynamicMover::initialize_simulation(class core::pose::Pose &, const class protocols::canonical_sampling::MetropolisHastingsMover &, unsigned long) –> void

is_multi_trial(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicMover) → bool

Return true if the move performs multiple trials on each apply.

last_inner_score_delta_over_temperature()

metropolis_hastings_mover()

set_metropolis_hastings_mover()

C++: protocols::canonical_sampling::ThermodynamicMover::is_multi_trial() –> bool

last_inner_score_delta_over_temperature(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicMover) → float

If this is a multi-trial move, return the change in internal

score/temperature caused by the last call to apply().

is_multi_trial()

C++: protocols::canonical_sampling::ThermodynamicMover::last_inner_score_delta_over_temperature() –> double

last_proposal_density_ratio(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicMover) → float

Return the proposal density ratio for last apply method.

C++: protocols::canonical_sampling::ThermodynamicMover::last_proposal_density_ratio() –> double

metropolis_hastings_mover(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicMover) → pyrosetta.rosetta.std.weak_ptr_protocols_canonical_sampling_MetropolisHastingsMover_t

If this is a multi-trial move, return the MetropolisHastingsMover

being used internally.

is_multi_trial()

C++: protocols::canonical_sampling::ThermodynamicMover::metropolis_hastings_mover() –> class std::weak_ptr<class protocols::canonical_sampling::MetropolisHastingsMover>

name() → str

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

observe_after_metropolis(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicMover, metropolis_hastings_mover: protocols::canonical_sampling::MetropolisHastingsMover) → None

Callback executed after the Metropolis criterion is evaluated.

C++: protocols::canonical_sampling::ThermodynamicMover::observe_after_metropolis(const class protocols::canonical_sampling::MetropolisHastingsMover &) –> void

preserve_detailed_balance(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicMover) → bool

Return true if detailed balance is being preserved (i.e. no branch

angle optimization).

C++: protocols::canonical_sampling::ThermodynamicMover::preserve_detailed_balance() const –> bool

register_options() → None

Overload this static method if you access options within the mover.

These options will end up in -help of your application if users of this mover call register_options. Do this recursively! If you use movers within your mover, call their register_options in your register_options() method.

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

reinitialize_for_each_job(self: pyrosetta.rosetta.protocols.moves.Mover) → bool

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be freshly regenerated on

each use.

C++: protocols::moves::Mover::reinitialize_for_each_job() const –> bool

reinitialize_for_new_input(self: pyrosetta.rosetta.protocols.moves.Mover) → bool

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be regenerated when the input

pose is about to change, (for example, if the Mover has special code on the first apply() that is only valid for that one input pose).

C++: protocols::moves::Mover::reinitialize_for_new_input() const –> bool

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

resets status to SUCCESS, meant to be used before an apply(). The job distributor (august 08 vintage) uses this to ensure non-accumulation of status across apply()s.

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

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

////////////////////////////end Job Distributor interface////////////////////////////////////////

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

set_current_tag(self: pyrosetta.rosetta.protocols.moves.Mover, new_tag: str) → None

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

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

setter for poses contained for rms

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

set_metropolis_hastings_mover(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicMover, metropolis_hastings_mover: pyrosetta.rosetta.std.weak_ptr_protocols_canonical_sampling_MetropolisHastingsMover_t) → None

If this is a multi-trial move, set the MetropolisHastingsMover to

be used internally.

is_multi_trial()

C++: protocols::canonical_sampling::ThermodynamicMover::set_metropolis_hastings_mover(class std::weak_ptr<class protocols::canonical_sampling::MetropolisHastingsMover>) –> 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_preserve_detailed_balance(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicMover, preserve_detailed_balance: bool) → None

Set to true if detailed balance should be preserved (i.e. no

branch angle optimization). This will be set to true for all movers used by MetropolisHastingsMover.

C++: protocols::canonical_sampling::ThermodynamicMover::set_preserve_detailed_balance(bool) –> void

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

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

show(*args, **kwargs)

Overloaded function.

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

Outputs details about the Mover, including current settings.

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

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

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

Allows extra test specific functions to be called before applying

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

torsion_id_ranges(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicMover, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.utility.vector1_core_id_TorsionID_Range

Return a list specifying which torsions may be perturbed by

apply(), and the in what range each perturbation may be.

This method should probably not be pure virtual, and in fact should probably not even exist. I searched most of the codebase, and could only find it being used in one pilot app. It is also a somewhat difficult method to write, which means that most of the implementations are either untested or no-ops. It might be better to remove the method altogether and implement it on a class-by-class basis as necessary.

C++: protocols::canonical_sampling::ThermodynamicMover::torsion_id_ranges(class core::pose::Pose &) –> class utility::vector1<class core::id::TorsionID_Range, class std::allocator<class core::id::TorsionID_Range> >

type(*args, **kwargs)

Overloaded function.

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

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

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

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

class pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver

Bases: pyrosetta.rosetta.protocols.moves.Mover

Base class for reporting and recording data from a simulation.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver) -> None
2. __init__(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver, arg0: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

apply(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver, : pyrosetta.rosetta.core.pose.Pose) → None

Callback executed after each move is made.

Even though the argument is a reference to a non-const pose, this method should not make any changes to the pose. Making changes to the pose is the role of the ThermodynamicMover class. The role of this class is to simply observe the poses being generated.

C++: protocols::canonical_sampling::ThermodynamicObserver::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver, : pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver) → pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver

C++: protocols::canonical_sampling::ThermodynamicObserver::operator=(const class protocols::canonical_sampling::ThermodynamicObserver &) –> class protocols::canonical_sampling::ThermodynamicObserver &

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>

finalize_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver, : pyrosetta.rosetta.core.pose.Pose, : protocols::canonical_sampling::MetropolisHastingsMover) → None

Callback executed after all Monte Carlo trials are completed.

C++: protocols::canonical_sampling::ThermodynamicObserver::finalize_simulation(class core::pose::Pose &, const class protocols::canonical_sampling::MetropolisHastingsMover &) –> void

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

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

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

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

fpd

Mechanism by which a mover may return multiple output poses from a single input pose.

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

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

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

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

A tag is a unique identifier used to identify structures produced

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

non-const accessor

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

initialize_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver, : pyrosetta.rosetta.core.pose.Pose, : protocols::canonical_sampling::MetropolisHastingsMover, : int) → None

Callback executed before any Monte Carlo trials are attempted.

C++: protocols::canonical_sampling::ThermodynamicObserver::initialize_simulation(class core::pose::Pose &, const class protocols::canonical_sampling::MetropolisHastingsMover &, unsigned long) –> void

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

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

name() → str

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

observe_after_metropolis(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver, metropolis_hastings_mover: protocols::canonical_sampling::MetropolisHastingsMover) → None

Callback executed after the Metropolis criterion is evaluated.

C++: protocols::canonical_sampling::ThermodynamicObserver::observe_after_metropolis(const class protocols::canonical_sampling::MetropolisHastingsMover &) –> void

register_options() → None

Overload this static method if you access options within the mover.

These options will end up in -help of your application if users of this mover call register_options. Do this recursively! If you use movers within your mover, call their register_options in your register_options() method.

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

reinitialize_for_each_job(self: pyrosetta.rosetta.protocols.moves.Mover) → bool

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be freshly regenerated on

each use.

C++: protocols::moves::Mover::reinitialize_for_each_job() const –> bool

reinitialize_for_new_input(self: pyrosetta.rosetta.protocols.moves.Mover) → bool

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be regenerated when the input

pose is about to change, (for example, if the Mover has special code on the first apply() that is only valid for that one input pose).

C++: protocols::moves::Mover::reinitialize_for_new_input() const –> bool

requires_pose(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver) → bool

Return false if this observer does not require a valid pose.

TrialCounterObserver is an example of such an observer.

C++: protocols::canonical_sampling::ThermodynamicObserver::requires_pose() –> 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

restart_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver, : pyrosetta.rosetta.core.pose.Pose, : protocols::canonical_sampling::MetropolisHastingsMover, : int, : int, : float) → bool

Attempt to restart the last simulation that was recorded by this

observer.

For example, consider an observer that records trajectories. This method should open the file that was going to be written, read out the last pose in that trajectory, and assign it to the given pose reference so that the current trajectory can start from the same place. Other observers may help setup other parts of the simulation.

This is not a particularly robust system, because it may require several unrelated observers working in concert to properly reconstitute the simulation. In fact, the restart feature in MetropolisHastingsMover is currently commented out, so this method is never actually invoked. I would advise reimplementing this method to utility_exit_with_message() in any subclasses you write, so that you don’t waste time writing an unused method but so you don’t confuse anyone if this feature gets revived in the future.

C++: protocols::canonical_sampling::ThermodynamicObserver::restart_simulation(class core::pose::Pose &, class protocols::canonical_sampling::MetropolisHastingsMover &, unsigned long &, unsigned long &, double &) –> bool

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

////////////////////////////end Job Distributor interface////////////////////////////////////////

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

set_current_tag(self: pyrosetta.rosetta.protocols.moves.Mover, new_tag: str) → None

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

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

setter for poses contained for rms

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

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

setter for native poses contained for rms —- we should get rid of this method? it is widely used, but a bit unsafe

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

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

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

show(*args, **kwargs)

Overloaded function.

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

Outputs details about the Mover, including current settings.

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

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

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

Allows extra test specific functions to be called before applying

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

type(*args, **kwargs)

Overloaded function.

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

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

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

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

class pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder

Bases: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver

Base class for recording a simulation trajectory.

This class seems a little too geared towards file IO, which will make it awkward to create the database trajectory subclass that I want. But I’ll get it to work one way or another.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder) -> None
2. __init__(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder, arg0: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

apply(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder, pose: pyrosetta.rosetta.core.pose.Pose) → None

ThermodynamicObserver::apply

C++: protocols::canonical_sampling::TrajectoryRecorder::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver, : pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver) → pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver

C++: protocols::canonical_sampling::ThermodynamicObserver::operator=(const class protocols::canonical_sampling::ThermodynamicObserver &) –> class protocols::canonical_sampling::ThermodynamicObserver &

attributes_for_trajectory_recorder(: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t) → None

C++: protocols::canonical_sampling::TrajectoryRecorder::attributes_for_trajectory_recorder(class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &) –> void

cache_limit(*args, **kwargs)

Overloaded function.

1. cache_limit(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder) -> int

Return the number of poses that can be cached.

C++: protocols::canonical_sampling::TrajectoryRecorder::cache_limit() –> unsigned long

2. cache_limit(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder, limit: int) -> None

Specify the maximum number of poses that can be cached.

This option can also be specified on the command line using the

-trajectory:cache_limit flag. Note that some recorders don’t

use a cache at all, and will therefore ignore this option.

C++: protocols::canonical_sampling::TrajectoryRecorder::cache_limit(unsigned long) –> 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>

cumulate_jobs(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder) → bool

Return true if poses from different jobs will be written to the

same trajectory file.

I suspect this is only meant to be used in the context of jd2. This option can only be set from the command line using the -trajectory:cumulate_jobs flag.

C++: protocols::canonical_sampling::TrajectoryRecorder::cumulate_jobs() const –> bool

cumulate_replicas(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder) → bool

Return true if poses from different replicas will be written to

the same trajectory file.

I suspect this is only meant to be used in the context of jd2. This option can only be set from the command line using the -trajectory:cumulate_replicas flag.

C++: protocols::canonical_sampling::TrajectoryRecorder::cumulate_replicas() const –> bool

file_name(*args, **kwargs)

Overloaded function.

1. file_name(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder) -> str

Return the file name for the trajectory.

C++: protocols::canonical_sampling::TrajectoryRecorder::file_name() const –> const std::string &

2. file_name(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder, file_name: str) -> None

Set the file name for the trajectory.

C++: protocols::canonical_sampling::TrajectoryRecorder::file_name(const class std::basic_string<char> &) –> void

finalize_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver, : pyrosetta.rosetta.core.pose.Pose, : protocols::canonical_sampling::MetropolisHastingsMover) → None

Callback executed after all Monte Carlo trials are completed.

C++: protocols::canonical_sampling::ThermodynamicObserver::finalize_simulation(class core::pose::Pose &, const class protocols::canonical_sampling::MetropolisHastingsMover &) –> void

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

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

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

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

fpd

Mechanism by which a mover may return multiple output poses from a single input pose.

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

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

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

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

A tag is a unique identifier used to identify structures produced

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

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

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

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

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

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

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

get_name(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder) → str

Return the name of this mover.

C++: protocols::canonical_sampling::TrajectoryRecorder::get_name() const –> std::string

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

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

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

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

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

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

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

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

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

non-const accessor

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

initialize_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder, pose: pyrosetta.rosetta.core.pose.Pose, metropolis_hastings_mover: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, cycle: int) → None

ThermodynamicObserver::initialize_simulation

C++: protocols::canonical_sampling::TrajectoryRecorder::initialize_simulation(class core::pose::Pose &, const class protocols::canonical_sampling::MetropolisHastingsMover &, unsigned long) –> void

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

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

model_count(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder) → int

Return the number of models that have been saved so far.

C++: protocols::canonical_sampling::TrajectoryRecorder::model_count() const –> unsigned long

name() → str

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

observe_after_metropolis(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder, metropolis_hastings_mover: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) → None

ThermodynamicObserver::observe_after_metropolis

C++: protocols::canonical_sampling::TrajectoryRecorder::observe_after_metropolis(const class protocols::canonical_sampling::MetropolisHastingsMover &) –> void

register_options() → None

Associate relevant options with the TemperedDocking class.

C++: protocols::canonical_sampling::TrajectoryRecorder::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

requires_pose(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver) → bool

Return false if this observer does not require a valid pose.

TrialCounterObserver is an example of such an observer.

C++: protocols::canonical_sampling::ThermodynamicObserver::requires_pose() –> bool

reset(*args, **kwargs)

Overloaded function.

1. reset(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder, mc: pyrosetta.rosetta.protocols.moves.MonteCarlo) -> None
2. reset(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder, mc: pyrosetta.rosetta.protocols.moves.MonteCarlo, metropolis_hastings_mover: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) -> None

Callback executed whenever the simulation is initialized or reset.

C++: protocols::canonical_sampling::TrajectoryRecorder::reset(const class protocols::moves::MonteCarlo &, const class protocols::canonical_sampling::MetropolisHastingsMover *) –> void

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

resets status to SUCCESS, meant to be used before an apply(). The job distributor (august 08 vintage) uses this to ensure non-accumulation of status across apply()s.

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

restart_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver, : pyrosetta.rosetta.core.pose.Pose, : protocols::canonical_sampling::MetropolisHastingsMover, : int, : int, : float) → bool

Attempt to restart the last simulation that was recorded by this

observer.

For example, consider an observer that records trajectories. This method should open the file that was going to be written, read out the last pose in that trajectory, and assign it to the given pose reference so that the current trajectory can start from the same place. Other observers may help setup other parts of the simulation.

This is not a particularly robust system, because it may require several unrelated observers working in concert to properly reconstitute the simulation. In fact, the restart feature in MetropolisHastingsMover is currently commented out, so this method is never actually invoked. I would advise reimplementing this method to utility_exit_with_message() in any subclasses you write, so that you don’t waste time writing an unused method but so you don’t confuse anyone if this feature gets revived in the future.

C++: protocols::canonical_sampling::ThermodynamicObserver::restart_simulation(class core::pose::Pose &, class protocols::canonical_sampling::MetropolisHastingsMover &, unsigned long &, unsigned long &, double &) –> bool

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

////////////////////////////end Job Distributor interface////////////////////////////////////////

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

set_current_tag(self: pyrosetta.rosetta.protocols.moves.Mover, new_tag: str) → None

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

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

setter for poses contained for rms

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

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

setter for native poses contained for rms —- we should get rid of this method? it is widely used, but a bit unsafe

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

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

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

show(*args, **kwargs)

Overloaded function.

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

Outputs details about the Mover, including current settings.

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

step_count(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder) → int

Return the number of iterations that have occurred so far.

C++: protocols::canonical_sampling::TrajectoryRecorder::step_count() const –> unsigned long

stride(*args, **kwargs)

Overloaded function.

1. stride(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder) -> int

Return how often models should be written to the trajectory.

C++: protocols::canonical_sampling::TrajectoryRecorder::stride() const –> unsigned long

2. stride(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder, stride: int) -> None

Set how often models should be written to the trajectory.

This option can also be specified on the command line using the

-trajectory:stride flag.

C++: protocols::canonical_sampling::TrajectoryRecorder::stride(unsigned long) –> void

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

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

Allows extra test specific functions to be called before applying

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

type(*args, **kwargs)

Overloaded function.

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

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

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

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

update_after_boltzmann(*args, **kwargs)

Overloaded function.

1. update_after_boltzmann(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder, pose: pyrosetta.rosetta.core.pose.Pose) -> None
2. update_after_boltzmann(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder, pose: pyrosetta.rosetta.core.pose.Pose, metropolis_hastings_mover: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) -> None

ThermodynamicObserver::apply

C++: protocols::canonical_sampling::TrajectoryRecorder::update_after_boltzmann(const class core::pose::Pose &, const class protocols::canonical_sampling::MetropolisHastingsMover *) –> void

3. update_after_boltzmann(self: pyrosetta.rosetta.protocols.canonical_sampling.TrajectoryRecorder, mc: pyrosetta.rosetta.protocols.moves.MonteCarlo) -> None

ThermodynamicObserver::apply

C++: protocols::canonical_sampling::TrajectoryRecorder::update_after_boltzmann(const class protocols::moves::MonteCarlo &) –> void

class pyrosetta.rosetta.protocols.canonical_sampling.TrialCounterObserver

Bases: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver

Record the acceptance rate for every type of move attempted.

Most of the work is done by observe_after_metropolis(). Separate statistics are recorded for moves made at different temperature levels.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.canonical_sampling.TrialCounterObserver) -> None
2. __init__(self: pyrosetta.rosetta.protocols.canonical_sampling.TrialCounterObserver, arg0: pyrosetta.rosetta.protocols.canonical_sampling.TrialCounterObserver) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

apply(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver, : pyrosetta.rosetta.core.pose.Pose) → None

Callback executed after each move is made.

Even though the argument is a reference to a non-const pose, this method should not make any changes to the pose. Making changes to the pose is the role of the ThermodynamicMover class. The role of this class is to simply observe the poses being generated.

C++: protocols::canonical_sampling::ThermodynamicObserver::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.canonical_sampling.TrialCounterObserver, : pyrosetta.rosetta.protocols.canonical_sampling.TrialCounterObserver) → pyrosetta.rosetta.protocols.canonical_sampling.TrialCounterObserver

C++: protocols::canonical_sampling::TrialCounterObserver::operator=(const class protocols::canonical_sampling::TrialCounterObserver &) –> class protocols::canonical_sampling::TrialCounterObserver &

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

C++: protocols::canonical_sampling::TrialCounterObserver::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>

finalize_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.TrialCounterObserver, pose: pyrosetta.rosetta.core.pose.Pose, metropolis_hastings_mover: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) → None

C++: protocols::canonical_sampling::TrialCounterObserver::finalize_simulation(class core::pose::Pose &, const class protocols::canonical_sampling::MetropolisHastingsMover &) –> void

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

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

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

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

fpd

Mechanism by which a mover may return multiple output poses from a single input pose.

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

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

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

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

A tag is a unique identifier used to identify structures produced

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

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

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

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

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

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

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

get_name(self: pyrosetta.rosetta.protocols.canonical_sampling.TrialCounterObserver) → str

C++: protocols::canonical_sampling::TrialCounterObserver::get_name() const –> std::string

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

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

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

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

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

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

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

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

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

non-const accessor

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

initialize_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.TrialCounterObserver, pose: pyrosetta.rosetta.core.pose.Pose, metropolis_hastings_mover: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover, cycle: int) → None

C++: protocols::canonical_sampling::TrialCounterObserver::initialize_simulation(class core::pose::Pose &, const class protocols::canonical_sampling::MetropolisHastingsMover &, unsigned long) –> void

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

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

mover_name() → str

C++: protocols::canonical_sampling::TrialCounterObserver::mover_name() –> std::string

name() → str

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

observe_after_metropolis(self: pyrosetta.rosetta.protocols.canonical_sampling.TrialCounterObserver, metropolis_hastings_mover: pyrosetta.rosetta.protocols.canonical_sampling.MetropolisHastingsMover) → None

C++: protocols::canonical_sampling::TrialCounterObserver::observe_after_metropolis(const class protocols::canonical_sampling::MetropolisHastingsMover &) –> void

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None

C++: protocols::canonical_sampling::TrialCounterObserver::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

register_options() → None

Overload this static method if you access options within the mover.

These options will end up in -help of your application if users of this mover call register_options. Do this recursively! If you use movers within your mover, call their register_options in your register_options() method.

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

reinitialize_for_each_job(self: pyrosetta.rosetta.protocols.moves.Mover) → bool

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be freshly regenerated on

each use.

C++: protocols::moves::Mover::reinitialize_for_each_job() const –> bool

reinitialize_for_new_input(self: pyrosetta.rosetta.protocols.moves.Mover) → bool

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be regenerated when the input

pose is about to change, (for example, if the Mover has special code on the first apply() that is only valid for that one input pose).

C++: protocols::moves::Mover::reinitialize_for_new_input() const –> bool

requires_pose(self: pyrosetta.rosetta.protocols.canonical_sampling.TrialCounterObserver) → bool

Return false, as a valid pose is not required for counting trials.

C++: protocols::canonical_sampling::TrialCounterObserver::requires_pose() –> 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

restart_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicObserver, : pyrosetta.rosetta.core.pose.Pose, : protocols::canonical_sampling::MetropolisHastingsMover, : int, : int, : float) → bool

Attempt to restart the last simulation that was recorded by this

observer.

For example, consider an observer that records trajectories. This method should open the file that was going to be written, read out the last pose in that trajectory, and assign it to the given pose reference so that the current trajectory can start from the same place. Other observers may help setup other parts of the simulation.

This is not a particularly robust system, because it may require several unrelated observers working in concert to properly reconstitute the simulation. In fact, the restart feature in MetropolisHastingsMover is currently commented out, so this method is never actually invoked. I would advise reimplementing this method to utility_exit_with_message() in any subclasses you write, so that you don’t waste time writing an unused method but so you don’t confuse anyone if this feature gets revived in the future.

C++: protocols::canonical_sampling::ThermodynamicObserver::restart_simulation(class core::pose::Pose &, class protocols::canonical_sampling::MetropolisHastingsMover &, unsigned long &, unsigned long &, double &) –> bool

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

////////////////////////////end Job Distributor interface////////////////////////////////////////

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

set_current_tag(self: pyrosetta.rosetta.protocols.moves.Mover, new_tag: str) → None

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

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

setter for poses contained for rms

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

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

setter for native poses contained for rms —- we should get rid of this method? it is widely used, but a bit unsafe

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

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

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

show(*args, **kwargs)

Overloaded function.

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

Outputs details about the Mover, including current settings.

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

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

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

Allows extra test specific functions to be called before applying

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

type(*args, **kwargs)

Overloaded function.

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

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

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

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

class pyrosetta.rosetta.protocols.canonical_sampling.TrialCounterObserverCreator

Bases: pyrosetta.rosetta.protocols.moves.MoverCreator

RosettaScripts factory for TrialCounterObserver.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.protocols.canonical_sampling.TrialCounterObserverCreator) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

assign(self: pyrosetta.rosetta.protocols.canonical_sampling.TrialCounterObserverCreator, : pyrosetta.rosetta.protocols.canonical_sampling.TrialCounterObserverCreator) → pyrosetta.rosetta.protocols.canonical_sampling.TrialCounterObserverCreator

C++: protocols::canonical_sampling::TrialCounterObserverCreator::operator=(const class protocols::canonical_sampling::TrialCounterObserverCreator &) –> class protocols::canonical_sampling::TrialCounterObserverCreator &

create_mover(self: pyrosetta.rosetta.protocols.canonical_sampling.TrialCounterObserverCreator) → pyrosetta.rosetta.protocols.moves.Mover

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

keyname(self: pyrosetta.rosetta.protocols.canonical_sampling.TrialCounterObserverCreator) → str

C++: protocols::canonical_sampling::TrialCounterObserverCreator::keyname() const –> std::string

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

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

pyrosetta.rosetta.protocols.canonical_sampling.canonical_sampling_main() → int

C++: protocols::canonical_sampling::canonical_sampling_main() –> int

pyrosetta.rosetta.protocols.canonical_sampling.interpolation_type_enum_to_string(interp_enum: pyrosetta.rosetta.protocols.canonical_sampling.InterpolationType) → str

C++: protocols::canonical_sampling::interpolation_type_enum_to_string(enum protocols::canonical_sampling::InterpolationType) –> std::string

pyrosetta.rosetta.protocols.canonical_sampling.interpolation_type_string_to_enum(interp_string: str) → pyrosetta.rosetta.protocols.canonical_sampling.InterpolationType

C++: protocols::canonical_sampling::interpolation_type_string_to_enum(const class std::basic_string<char> &) –> enum protocols::canonical_sampling::InterpolationType