options

Bindings for protocols::stepwise::monte_carlo::options namespace

class pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions

Bases: StepWiseBasicOptions, StepWiseMoveSelectorOptions

VDW_rep_screen_info(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions) → pyrosetta.rosetta.utility.vector1_std_string

C++: protocols::stepwise::options::StepWiseBasicOptions::VDW_rep_screen_info() const –> const class utility::vector1<std::string, class std::allocator<std::string > > &

add_delete_frequency(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.mover.options.StepWiseMoveSelectorOptions) → float

C++: protocols::stepwise::monte_carlo::mover::options::StepWiseMoveSelectorOptions::add_delete_frequency() const –> double

add_proposal_density_factor(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → float

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::add_proposal_density_factor() const –> const double &

allow_internal_hinge_moves(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.mover.options.StepWiseMoveSelectorOptions) → bool

C++: protocols::stepwise::monte_carlo::mover::options::StepWiseMoveSelectorOptions::allow_internal_hinge_moves() const –> bool

allow_internal_local_moves(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.mover.options.StepWiseMoveSelectorOptions) → bool

C++: protocols::stepwise::monte_carlo::mover::options::StepWiseMoveSelectorOptions::allow_internal_local_moves() const –> bool

allow_split_off(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → bool

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::allow_split_off() const –> const bool &

allow_submotif_split(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.mover.options.StepWiseMoveSelectorOptions) → bool

C++: protocols::stepwise::monte_carlo::mover::options::StepWiseMoveSelectorOptions::allow_submotif_split() const –> bool

allow_virtual_o2prime_hydrogens(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → bool

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::allow_virtual_o2prime_hydrogens() const –> const bool &

allow_virtual_side_chains(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → bool

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::allow_virtual_side_chains() const –> const bool &

assign(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, : pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::operator=(const class protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions &) –> class protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions &

atr_rep_screen(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions) → bool

C++: protocols::stepwise::options::StepWiseBasicOptions::atr_rep_screen() const –> bool

atr_rep_screen_for_docking(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions) → bool

C++: protocols::stepwise::options::StepWiseBasicOptions::atr_rep_screen_for_docking() const –> bool

boltzmann_choice_post_enumerated_minimize(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions) → bool

C++: protocols::stepwise::options::StepWiseBasicOptions::boltzmann_choice_post_enumerated_minimize() const –> bool

chainbreak_weight(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → float

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::chainbreak_weight() const –> const double &

checkpoint(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → bool

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::checkpoint() const –> bool

checkpointing_frequency(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → int

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::checkpointing_frequency() const –> unsigned long

clone(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::clone() const –> class std::shared_ptr<class protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions>

cluster_rmsd(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions) → float

C++: protocols::stepwise::options::StepWiseBasicOptions::cluster_rmsd() const –> double

continue_until_none_missing(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → bool

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::continue_until_none_missing() const –> bool

cycles(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → int

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::cycles() const –> const unsigned long &

designing_with_noncanonicals(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → bool

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::designing_with_noncanonicals() const –> bool

disallow_pack_polar_hydrogens(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions) → bool

C++: protocols::stepwise::options::StepWiseBasicOptions::disallow_pack_polar_hydrogens() const –> bool

docking_frequency(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.mover.options.StepWiseMoveSelectorOptions) → float

C++: protocols::stepwise::monte_carlo::mover::options::StepWiseMoveSelectorOptions::docking_frequency() const –> double

enumerate(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → bool

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::enumerate() const –> const bool &

erraser(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → bool

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::erraser() const –> const bool &

eval_base_pairs(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → bool

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::eval_base_pairs() const –> bool

exclude_submotifs(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → pyrosetta.rosetta.utility.vector1_std_string

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::exclude_submotifs() const –> class utility::vector1<std::string, class std::allocator<std::string > >

filter_complex_cycles(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.mover.options.StepWiseMoveSelectorOptions) → bool

C++: protocols::stepwise::monte_carlo::mover::options::StepWiseMoveSelectorOptions::filter_complex_cycles() const –> bool

filter_native_big_bins(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → bool

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::filter_native_big_bins() const –> const bool &

force_centroid_interaction(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → bool

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::force_centroid_interaction() const –> const bool &

force_moving_res_for_erraser(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → bool

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::force_moving_res_for_erraser() const –> bool

force_phosphate_instantiation(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → bool

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::force_phosphate_instantiation() const –> const bool &

force_submotif_without_intervening_bulge(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.mover.options.StepWiseMoveSelectorOptions) → bool

C++: protocols::stepwise::monte_carlo::mover::options::StepWiseMoveSelectorOptions::force_submotif_without_intervening_bulge() const –> bool

from_scratch_frequency(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.mover.options.StepWiseMoveSelectorOptions) → float

C++: protocols::stepwise::monte_carlo::mover::options::StepWiseMoveSelectorOptions::from_scratch_frequency() const –> double

hydrate_magnesiums(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions) → bool

C++: protocols::stepwise::options::StepWiseBasicOptions::hydrate_magnesiums() const –> bool

initialize_from_command_line(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::initialize_from_command_line() –> void

initialize_from_options_collection(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, options: pyrosetta.rosetta.utility.options.OptionCollection) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::initialize_from_options_collection(const class utility::options::OptionCollection &) –> void

integration_test_mode(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → bool

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::integration_test_mode() const –> const bool &

just_min_after_mutation_frequency(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → float

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::just_min_after_mutation_frequency() const –> const double &

static list_options_read(opts: pyrosetta.rosetta.std.list_utility_keys_VariantKey_utility_options_OptionKey_t) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::list_options_read(class std::list<class utility::keys::VariantKey<class utility::options::OptionKey>, class std::allocator<class utility::keys::VariantKey<class utility::options::OptionKey> > > &) –> void

local_redock_only(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → bool

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::local_redock_only() const –> const bool &

lores(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions) → bool

C++: protocols::stepwise::options::StepWiseBasicOptions::lores() const –> bool

make_movie(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → bool

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::make_movie() const –> const bool &

mapfile_activated(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions) → bool

C++: protocols::stepwise::options::StepWiseBasicOptions::mapfile_activated() const –> bool

max_missing_weight(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → float

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::max_missing_weight() const –> const double &

max_tries_multiplier_for_ccd(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions) → int

C++: protocols::stepwise::options::StepWiseBasicOptions::max_tries_multiplier_for_ccd() const –> unsigned long

min_tolerance(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions) → float

C++: protocols::stepwise::options::StepWiseBasicOptions::min_tolerance() const –> double

min_type(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions) → str

C++: protocols::stepwise::options::StepWiseBasicOptions::min_type() const –> std::string

minimize_after_delete(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → bool

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::minimize_after_delete() const –> const bool &

minimize_single_res_frequency(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → float

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::minimize_single_res_frequency() const –> const double &

minimize_waters(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions) → bool

C++: protocols::stepwise::options::StepWiseBasicOptions::minimize_waters() const –> bool

minimizer_mode(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions) → pyrosetta.rosetta.protocols.stepwise.modeler.MinimizerMode

C++: protocols::stepwise::options::StepWiseBasicOptions::minimizer_mode() const –> const enum protocols::stepwise::modeler::MinimizerMode &

n_cycles(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions) → int

C++: protocols::stepwise::options::StepWiseBasicOptions::n_cycles() const –> unsigned long

n_sample(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → int

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::n_sample() const –> const unsigned long &

new_move_selector(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → bool

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::new_move_selector() const –> const bool &

num_pose_minimize(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions) → int

C++: protocols::stepwise::options::StepWiseBasicOptions::num_pose_minimize() const –> unsigned long

num_random_samples(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions) → int

C++: protocols::stepwise::options::StepWiseBasicOptions::num_random_samples() const –> unsigned long

o2prime_legacy_mode(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → bool

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::o2prime_legacy_mode() const –> const bool &

output_cluster_size(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions) → bool

C++: protocols::stepwise::options::StepWiseBasicOptions::output_cluster_size() const –> bool

output_minimized_pose_list(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions) → bool

C++: protocols::stepwise::options::StepWiseBasicOptions::output_minimized_pose_list() const –> bool

pack_protein_side_chains(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → bool

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::pack_protein_side_chains() const –> const bool &

parse_my_tag(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, : pyrosetta.rosetta.utility.tag.Tag) → None

Initialize from the recursive “tag” structure.

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>) –> void

preminimize(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → bool

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::preminimize() const –> const bool &

protein_prepack(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → bool

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::protein_prepack() const –> const bool &

rebuild_bulge_mode(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → bool

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::rebuild_bulge_mode() const –> const bool &

recover_low(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → bool

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::recover_low() const –> const bool &

rmsd_screen(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions) → float

C++: protocols::stepwise::options::StepWiseBasicOptions::rmsd_screen() const –> double

sample_pH(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions) → bool

C++: protocols::stepwise::options::StepWiseBasicOptions::sample_pH() const –> bool

sampler_max_centroid_distance(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → float

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::sampler_max_centroid_distance() const –> const double &

sampler_num_pose_kept(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions) → int

C++: protocols::stepwise::options::StepWiseBasicOptions::sampler_num_pose_kept() const –> unsigned long

sampler_perform_phosphate_pack(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → bool

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::sampler_perform_phosphate_pack() const –> const bool &

sampler_silent_file(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions) → str

C++: protocols::stepwise::options::StepWiseBasicOptions::sampler_silent_file() const –> const std::string &

save_times(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → bool

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::save_times() const –> const bool &

set_VDW_rep_screen_info(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions, setting: pyrosetta.rosetta.utility.vector1_std_string) → None

C++: protocols::stepwise::options::StepWiseBasicOptions::set_VDW_rep_screen_info(const class utility::vector1<std::string, class std::allocator<std::string > > &) –> void

set_add_delete_frequency(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.mover.options.StepWiseMoveSelectorOptions, setting: float) → None

C++: protocols::stepwise::monte_carlo::mover::options::StepWiseMoveSelectorOptions::set_add_delete_frequency(const double &) –> void

set_add_proposal_density_factor(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: float) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_add_proposal_density_factor(const double &) –> void

set_allow_internal_hinge_moves(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.mover.options.StepWiseMoveSelectorOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::mover::options::StepWiseMoveSelectorOptions::set_allow_internal_hinge_moves(const bool &) –> void

set_allow_internal_local_moves(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.mover.options.StepWiseMoveSelectorOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::mover::options::StepWiseMoveSelectorOptions::set_allow_internal_local_moves(const bool &) –> void

set_allow_split_off(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_allow_split_off(const bool &) –> void

set_allow_submotif_split(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.mover.options.StepWiseMoveSelectorOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::mover::options::StepWiseMoveSelectorOptions::set_allow_submotif_split(const bool &) –> void

set_allow_virtual_o2prime_hydrogens(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_allow_virtual_o2prime_hydrogens(const bool &) –> void

set_allow_virtual_side_chains(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_allow_virtual_side_chains(const bool &) –> void

set_atr_rep_screen(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions, setting: bool) → None

C++: protocols::stepwise::options::StepWiseBasicOptions::set_atr_rep_screen(const bool &) –> void

set_atr_rep_screen_for_docking(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions, setting: bool) → None

C++: protocols::stepwise::options::StepWiseBasicOptions::set_atr_rep_screen_for_docking(const bool &) –> void

set_boltzmann_choice_post_enumerated_minimize(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions, setting: bool) → None

C++: protocols::stepwise::options::StepWiseBasicOptions::set_boltzmann_choice_post_enumerated_minimize(const bool) –> void

set_chainbreak_weight(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: float) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_chainbreak_weight(const double &) –> void

set_checkpoint(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_checkpoint(const bool) –> void

set_checkpointing_frequency(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: int) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_checkpointing_frequency(const unsigned long) –> void

set_cluster_rmsd(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions, setting: float) → None

C++: protocols::stepwise::options::StepWiseBasicOptions::set_cluster_rmsd(const double &) –> void

set_continue_until_none_missing(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_continue_until_none_missing(const bool) –> void

set_cycles(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: int) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_cycles(const unsigned long &) –> void

set_designing_with_noncanonicals(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_designing_with_noncanonicals(const bool &) –> void

set_disallow_pack_polar_hydrogens(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions, setting: bool) → None

C++: protocols::stepwise::options::StepWiseBasicOptions::set_disallow_pack_polar_hydrogens(const bool &) –> void

set_docking_frequency(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.mover.options.StepWiseMoveSelectorOptions, setting: float) → None

C++: protocols::stepwise::monte_carlo::mover::options::StepWiseMoveSelectorOptions::set_docking_frequency(const double &) –> void

set_enumerate(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_enumerate(const bool &) –> void

set_erraser(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_erraser(const bool &) –> void

set_eval_base_pairs(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_eval_base_pairs(const bool) –> void

set_exclude_submotifs(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: pyrosetta.rosetta.utility.vector1_std_string) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_exclude_submotifs(const class utility::vector1<std::string, class std::allocator<std::string > > &) –> void

set_filter_complex_cycles(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.mover.options.StepWiseMoveSelectorOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::mover::options::StepWiseMoveSelectorOptions::set_filter_complex_cycles(const bool &) –> void

set_filter_native_big_bins(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_filter_native_big_bins(const bool &) –> void

set_force_centroid_interaction(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_force_centroid_interaction(const bool &) –> void

set_force_moving_res_for_erraser(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_force_moving_res_for_erraser(const bool) –> void

set_force_phosphate_instantiation(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_force_phosphate_instantiation(const bool &) –> void

set_force_submotif_without_intervening_bulge(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.mover.options.StepWiseMoveSelectorOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::mover::options::StepWiseMoveSelectorOptions::set_force_submotif_without_intervening_bulge(const bool &) –> void

set_from_scratch_frequency(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.mover.options.StepWiseMoveSelectorOptions, setting: float) → None

C++: protocols::stepwise::monte_carlo::mover::options::StepWiseMoveSelectorOptions::set_from_scratch_frequency(const double &) –> void

set_hydrate_magnesiums(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions, setting: bool) → None

C++: protocols::stepwise::options::StepWiseBasicOptions::set_hydrate_magnesiums(const bool &) –> void

set_integration_test_mode(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_integration_test_mode(const bool &) –> void

set_just_min_after_mutation_frequency(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: float) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_just_min_after_mutation_frequency(const double &) –> void

set_local_redock_only(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_local_redock_only(const bool &) –> void

set_lores(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions, setting: bool) → None

C++: protocols::stepwise::options::StepWiseBasicOptions::set_lores(const bool &) –> void

set_make_movie(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_make_movie(const bool &) –> void

set_mapfile_activated(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions, setting: bool) → None

C++: protocols::stepwise::options::StepWiseBasicOptions::set_mapfile_activated(const bool &) –> void

set_max_missing_weight(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: float) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_max_missing_weight(const double &) –> void

set_max_tries_multiplier_for_ccd(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions, setting: int) → None

C++: protocols::stepwise::options::StepWiseBasicOptions::set_max_tries_multiplier_for_ccd(const unsigned long &) –> void

set_min_tolerance(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions, setting: float) → None

C++: protocols::stepwise::options::StepWiseBasicOptions::set_min_tolerance(const double &) –> void

set_min_type(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions, setting: str) → None

C++: protocols::stepwise::options::StepWiseBasicOptions::set_min_type(const std::string &) –> void

set_minimize_after_delete(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_minimize_after_delete(const bool &) –> void

set_minimize_single_res_frequency(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: float) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_minimize_single_res_frequency(const double &) –> void

set_minimize_waters(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions, setting: bool) → None

C++: protocols::stepwise::options::StepWiseBasicOptions::set_minimize_waters(const bool &) –> void

set_minimizer_mode(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions, setting: pyrosetta.rosetta.protocols.stepwise.modeler.MinimizerMode) → None

C++: protocols::stepwise::options::StepWiseBasicOptions::set_minimizer_mode(const enum protocols::stepwise::modeler::MinimizerMode &) –> void

set_n_cycles(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions, setting: int) → None

C++: protocols::stepwise::options::StepWiseBasicOptions::set_n_cycles(const unsigned long) –> void

set_n_sample(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: int) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_n_sample(const unsigned long &) –> void

set_new_move_selector(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_new_move_selector(const bool &) –> void

set_num_pose_minimize(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions, setting: int) → None

C++: protocols::stepwise::options::StepWiseBasicOptions::set_num_pose_minimize(const unsigned long &) –> void

set_num_random_samples(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions, setting: int) → None

C++: protocols::stepwise::options::StepWiseBasicOptions::set_num_random_samples(const unsigned long &) –> void

set_o2prime_legacy_mode(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_o2prime_legacy_mode(const bool &) –> void

set_output_cluster_size(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions, setting: bool) → None

C++: protocols::stepwise::options::StepWiseBasicOptions::set_output_cluster_size(const bool &) –> void

set_output_minimized_pose_list(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions, setting: bool) → None

C++: protocols::stepwise::options::StepWiseBasicOptions::set_output_minimized_pose_list(const bool &) –> void

set_pack_protein_side_chains(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_pack_protein_side_chains(const bool &) –> void

set_preminimize(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_preminimize(const bool &) –> void

set_protein_prepack(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_protein_prepack(const bool &) –> void

set_rebuild_bulge_mode(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_rebuild_bulge_mode(const bool &) –> void

set_recover_low(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_recover_low(const bool &) –> void

set_rmsd_screen(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions, setting: float) → None

C++: protocols::stepwise::options::StepWiseBasicOptions::set_rmsd_screen(const double &) –> void

set_sample_pH(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions, setting: bool) → None

C++: protocols::stepwise::options::StepWiseBasicOptions::set_sample_pH(const bool) –> void

set_sampler_max_centroid_distance(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: float) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_sampler_max_centroid_distance(const double &) –> void

set_sampler_num_pose_kept(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions, setting: int) → None

C++: protocols::stepwise::options::StepWiseBasicOptions::set_sampler_num_pose_kept(const unsigned long &) –> void

set_sampler_perform_phosphate_pack(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_sampler_perform_phosphate_pack(const bool &) –> void

set_sampler_silent_file(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions, setting: str) → None

C++: protocols::stepwise::options::StepWiseBasicOptions::set_sampler_silent_file(const std::string &) –> void

set_save_times(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_save_times(const bool &) –> void

set_silent_file(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions, setting: str) → None

C++: protocols::stepwise::options::StepWiseBasicOptions::set_silent_file(const std::string &) –> void

set_skip_bulge_frequency(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.mover.options.StepWiseMoveSelectorOptions, setting: float) → None

C++: protocols::stepwise::monte_carlo::mover::options::StepWiseMoveSelectorOptions::set_skip_bulge_frequency(const double &) –> void

set_skip_coord_constraints(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_skip_coord_constraints(const bool &) –> void

set_skip_deletions(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_skip_deletions(const bool &) –> void

set_skip_preminimize(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_skip_preminimize(const bool &) –> void

set_submotif_frequency(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.mover.options.StepWiseMoveSelectorOptions, setting: float) → None

C++: protocols::stepwise::monte_carlo::mover::options::StepWiseMoveSelectorOptions::set_submotif_frequency(const double &) –> void

set_superimpose_over_all(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_superimpose_over_all(const bool) –> void

set_switch_focus_frequency(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.mover.options.StepWiseMoveSelectorOptions, setting: float) → None

C++: protocols::stepwise::monte_carlo::mover::options::StepWiseMoveSelectorOptions::set_switch_focus_frequency(const double &) –> void

set_temperature(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: float) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_temperature(const double &) –> void

set_test_all_mg_hydration_frames(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions, setting: bool) → None

C++: protocols::stepwise::options::StepWiseBasicOptions::set_test_all_mg_hydration_frames(const bool &) –> void

set_test_all_moves(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_test_all_moves(const bool &) –> void

set_tether_jump(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_tether_jump(const bool &) –> void

set_thermal_sampler_output_min_pose(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions, setting: bool) → None

C++: protocols::stepwise::options::StepWiseBasicOptions::set_thermal_sampler_output_min_pose(const bool) –> void

set_use_first_jump_for_submotif(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_use_first_jump_for_submotif(const bool &) –> void

set_use_packer_instead_of_rotamer_trials(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions, setting: bool) → None

C++: protocols::stepwise::options::StepWiseBasicOptions::set_use_packer_instead_of_rotamer_trials(const bool &) –> void

set_use_phenix_geo(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_use_phenix_geo(const bool &) –> void

set_use_precomputed_library(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_use_precomputed_library(const bool &) –> void

set_vary_loop_length_frequency(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.mover.options.StepWiseMoveSelectorOptions, setting: float) → None

C++: protocols::stepwise::monte_carlo::mover::options::StepWiseMoveSelectorOptions::set_vary_loop_length_frequency(const double &) –> void

set_vary_polar_hydrogen_geometry(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions, setting: bool) → None

C++: protocols::stepwise::options::StepWiseBasicOptions::set_vary_polar_hydrogen_geometry(const bool &) –> void

set_vary_rna_bond_geometry(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions, setting: bool) → None

C++: protocols::stepwise::options::StepWiseBasicOptions::set_vary_rna_bond_geometry(const bool &) –> void

set_verbose_sampler(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions, setting: bool) → None

C++: protocols::stepwise::options::StepWiseBasicOptions::set_verbose_sampler(const bool &) –> void

set_verbose_scores(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_verbose_scores(const bool &) –> void

set_virtual_sugar_do_minimize(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_virtual_sugar_do_minimize(const bool &) –> void

set_virtual_sugar_keep_base_fixed(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_virtual_sugar_keep_base_fixed(const bool &) –> void

set_virtualize_packable_moieties_in_screening_pose(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, setting: bool) → None

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::set_virtualize_packable_moieties_in_screening_pose(const bool &) –> void

setup_modeler_options(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → pyrosetta.rosetta.protocols.stepwise.modeler.options.StepWiseModelerOptions

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::setup_modeler_options() const –> class std::shared_ptr<class protocols::stepwise::modeler::options::StepWiseModelerOptions>

show(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions, : pyrosetta.rosetta.std.ostream) → None

Describe this instance to a given output stream

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::show(std::ostream &) const –> void

silent_file(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions) → str

C++: protocols::stepwise::options::StepWiseBasicOptions::silent_file() const –> const std::string &

skip_bulge_frequency(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.mover.options.StepWiseMoveSelectorOptions) → float

C++: protocols::stepwise::monte_carlo::mover::options::StepWiseMoveSelectorOptions::skip_bulge_frequency() const –> double

skip_coord_constraints(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → bool

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::skip_coord_constraints() const –> const bool &

skip_deletions(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → bool

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::skip_deletions() const –> const bool &

skip_preminimize(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → bool

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::skip_preminimize() const –> const bool &

submotif_frequency(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.mover.options.StepWiseMoveSelectorOptions) → float

C++: protocols::stepwise::monte_carlo::mover::options::StepWiseMoveSelectorOptions::submotif_frequency() const –> double

superimpose_over_all(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → bool

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::superimpose_over_all() const –> bool

switch_focus_frequency(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.mover.options.StepWiseMoveSelectorOptions) → float

C++: protocols::stepwise::monte_carlo::mover::options::StepWiseMoveSelectorOptions::switch_focus_frequency() const –> double

temperature(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → float

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::temperature() const –> const double &

test_all_mg_hydration_frames(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions) → bool

C++: protocols::stepwise::options::StepWiseBasicOptions::test_all_mg_hydration_frames() const –> bool

test_all_moves(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → bool

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::test_all_moves() const –> const bool &

tether_jump(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → bool

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::tether_jump() const –> const bool &

thermal_sampler_output_min_pose(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions) → bool

C++: protocols::stepwise::options::StepWiseBasicOptions::thermal_sampler_output_min_pose() const –> bool

thermal_sampler_temperature(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions) → float

C++: protocols::stepwise::options::StepWiseBasicOptions::thermal_sampler_temperature() const –> double

type(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → str

The class name (its type) for a particular instance.

This function allows for better error message delivery.

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::type() const –> std::string

use_first_jump_for_submotif(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → bool

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::use_first_jump_for_submotif() const –> const bool &

use_packer_instead_of_rotamer_trials(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions) → bool

C++: protocols::stepwise::options::StepWiseBasicOptions::use_packer_instead_of_rotamer_trials() const –> bool

use_phenix_geo(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → bool

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::use_phenix_geo() const –> const bool &

use_precomputed_library(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → bool

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::use_precomputed_library() const –> const bool &

vary_loop_length_frequency(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.mover.options.StepWiseMoveSelectorOptions) → float

C++: protocols::stepwise::monte_carlo::mover::options::StepWiseMoveSelectorOptions::vary_loop_length_frequency() const –> double

vary_polar_hydrogen_geometry(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions) → bool

C++: protocols::stepwise::options::StepWiseBasicOptions::vary_polar_hydrogen_geometry() const –> bool

vary_rna_bond_geometry(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions) → bool

C++: protocols::stepwise::options::StepWiseBasicOptions::vary_rna_bond_geometry() const –> bool

verbose_sampler(self: pyrosetta.rosetta.protocols.stepwise.options.StepWiseBasicOptions) → bool

C++: protocols::stepwise::options::StepWiseBasicOptions::verbose_sampler() const –> bool

verbose_scores(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → bool

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::verbose_scores() const –> const bool &

virtual_sugar_do_minimize(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → bool

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::virtual_sugar_do_minimize() const –> const bool &

virtual_sugar_keep_base_fixed(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → bool

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::virtual_sugar_keep_base_fixed() const –> const bool &

virtualize_packable_moieties_in_screening_pose(self: pyrosetta.rosetta.protocols.stepwise.monte_carlo.options.StepWiseMonteCarloOptions) → bool

C++: protocols::stepwise::monte_carlo::options::StepWiseMonteCarloOptions::virtualize_packable_moieties_in_screening_pose() const –> const bool &