kinematic_closure

Bindings for protocols::loops::loop_closure::kinematic_closure namespace

class pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.BaseTabooPerturber

Bases: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber

Taboo-sampling perturber base class, the two variants of which, share much code in common, but interface with separate Ramachandran potentials.

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

Initialize self. See help(type(self)) for accurate signature.

__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.loops.loop_closure.kinematic_closure.BaseTabooPerturber, : pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.BaseTabooPerturber) → pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.BaseTabooPerturber

C++: protocols::loops::loop_closure::kinematic_closure::BaseTabooPerturber::operator=(const class protocols::loops::loop_closure::kinematic_closure::BaseTabooPerturber &) –> class protocols::loops::loop_closure::kinematic_closure::BaseTabooPerturber &

clear_torsion_string_stack(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.BaseTabooPerturber) → None

C++: protocols::loops::loop_closure::kinematic_closure::BaseTabooPerturber::clear_torsion_string_stack() –> void

get_movemap(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → pyrosetta.rosetta.core.kinematics.MoveMap

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::get_movemap() const –> class std::shared_ptr<const class core::kinematics::MoveMap>

kinmover(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → pyrosetta.rosetta.std.weak_ptr_const_protocols_loops_loop_closure_kinematic_closure_KinematicMover_t

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::kinmover() const –> class std::weak_ptr<const class protocols::loops::loop_closure::kinematic_closure::KinematicMover>

max_sample_iterations(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → int

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::max_sample_iterations() const –> unsigned long

next_torsion_string(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.BaseTabooPerturber) → pyrosetta.rosetta.utility.vector0_core_conformation_ppo_torsion_bin

C++: protocols::loops::loop_closure::kinematic_closure::BaseTabooPerturber::next_torsion_string() –> class utility::vector0<enum core::conformation::ppo_torsion_bin, class std::allocator<enum core::conformation::ppo_torsion_bin> >

num_strings(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.BaseTabooPerturber) → int

C++: protocols::loops::loop_closure::kinematic_closure::BaseTabooPerturber::num_strings() const –> unsigned long

perturb_chain(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.BaseTabooPerturber, pose: pyrosetta.rosetta.core.pose.Pose, torsions: pyrosetta.rosetta.utility.vector1_double, bond_ang: pyrosetta.rosetta.utility.vector1_double, : pyrosetta.rosetta.utility.vector1_double) → None

C++: protocols::loops::loop_closure::kinematic_closure::BaseTabooPerturber::perturb_chain(const class core::pose::Pose &, class utility::vector1<double, class std::allocator<double> > &, class utility::vector1<double, class std::allocator<double> > &, class utility::vector1<double, class std::allocator<double> > &) –> void

perturber_exhausted(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → bool

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::perturber_exhausted() const –> bool

perturber_type(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → str

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::perturber_type() const –> std::string

set_kinmover(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber, kinmover: pyrosetta.rosetta.std.weak_ptr_const_protocols_loops_loop_closure_kinematic_closure_KinematicMover_t) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::set_kinmover(class std::weak_ptr<const class protocols::loops::loop_closure::kinematic_closure::KinematicMover>) –> void

set_max_sample_iterations(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber, sample_its: int) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::set_max_sample_iterations(unsigned long) –> void

set_movemap(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber, mm: pyrosetta.rosetta.core.kinematics.MoveMap) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::set_movemap(class std::shared_ptr<const class core::kinematics::MoveMap>) –> void

set_pose_after_closure(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.BaseTabooPerturber, pose: pyrosetta.rosetta.core.pose.Pose, torsions: pyrosetta.rosetta.utility.vector1_double, bond_ang: pyrosetta.rosetta.utility.vector1_double, bond_len: pyrosetta.rosetta.utility.vector1_double, closure_successful: bool) → None

C++: protocols::loops::loop_closure::kinematic_closure::BaseTabooPerturber::set_pose_after_closure(class core::pose::Pose &, const class utility::vector1<double, class std::allocator<double> > &, const class utility::vector1<double, class std::allocator<double> > &, const class utility::vector1<double, class std::allocator<double> > &, bool) const –> void

set_vary_ca_bond_angles(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.BaseTabooPerturber, vary_ca_bond_angles: bool) → None

C++: protocols::loops::loop_closure::kinematic_closure::BaseTabooPerturber::set_vary_ca_bond_angles(bool) –> void

class pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover

Bases: pyrosetta.rosetta.protocols.moves.Mover

A mover class for performing kinematic loop closure on a peptide segment

BANGLE_MIN(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover) → float

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::BANGLE_MIN() const –> double

BANGLE_SD(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover) → float

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::BANGLE_SD() const –> double

__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.loops.loop_closure.kinematic_closure.KinematicMover) -> None
2. __init__(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover, arg0: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover) -> 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_filter(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover, filter: pyrosetta.rosetta.protocols.filters.Filter) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::add_filter(class std::shared_ptr<const class protocols::filters::Filter>) –> void

apply(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover, : pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover, : pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover) → pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::operator=(const class protocols::loops::loop_closure::kinematic_closure::KinematicMover &) –> class protocols::loops::loop_closure::kinematic_closure::KinematicMover &

check_rama(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover, old_rama_score: float, new_rama_score: float) → bool

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::check_rama(double, double) –> bool

clear_filters(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::clear_filters() –> 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>

count_bb_atoms(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover, pose: pyrosetta.rosetta.core.pose.Pose, start_res: int, end_res: int) → int

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::count_bb_atoms(const class core::pose::Pose &, const unsigned long, const unsigned long) const –> unsigned long

count_bb_atoms_in_residue(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover, pose: pyrosetta.rosetta.core.pose.Pose, position: int) → int

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::count_bb_atoms_in_residue(const class core::pose::Pose &, const unsigned long) const –> unsigned long

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>

end_res(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover) → int

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::end_res() const –> unsigned long

frequency_in_taboo_map(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover, pos: int, : pyrosetta.rosetta.core.conformation.ppo_torsion_bin) → float

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::frequency_in_taboo_map(unsigned long, enum core::conformation::ppo_torsion_bin) const –> double

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_bb_atoms_for_residue(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover, res: pyrosetta.rosetta.core.conformation.Residue, bb_atom_index: int) → str

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::get_bb_atoms_for_residue(const class core::conformation::Residue &, const unsigned long) const –> std::string

get_bump_overlap_factor(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover) → float

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::get_bump_overlap_factor() const –> double

get_bumpcheck_atom_count_for_residue(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover, rsd: pyrosetta.rosetta.core.conformation.Residue) → int

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::get_bumpcheck_atom_count_for_residue(const class core::conformation::Residue &) const –> unsigned long

get_bumpcheck_atoms_for_residue(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover, rsd: pyrosetta.rosetta.core.conformation.Residue, bumpcheck_atom_index: int) → str

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::get_bumpcheck_atoms_for_residue(const class core::conformation::Residue &, const unsigned long) const –> std::string

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_hardsphere_bump_check(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover) → bool

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::get_hardsphere_bump_check() –> bool

get_idealize_loop_first(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover) → bool

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::get_idealize_loop_first() –> bool

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

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

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

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

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

get_loop_sequence(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover) → pyrosetta.rosetta.utility.vector1_core_chemical_AA

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::get_loop_sequence() const –> class utility::vector1<enum core::chemical::AA, class std::allocator<enum core::chemical::AA> >

get_name(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover) → str

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::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_rama_check(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover) → bool

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::get_rama_check() –> bool

get_sample_nonpivot_torsions(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover) → bool

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::get_sample_nonpivot_torsions() –> bool

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

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

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

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

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

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

get_vary_bondangles(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover) → bool

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::get_vary_bondangles() –> bool

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

insert_sampled_torsion_string_into_taboo_map(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover, ts: pyrosetta.rosetta.utility.vector0_core_conformation_ppo_torsion_bin) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::insert_sampled_torsion_string_into_taboo_map(const class utility::vector0<enum core::conformation::ppo_torsion_bin, class std::allocator<enum core::conformation::ppo_torsion_bin> > &) –> void

is_beta_aminoacid(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover, res: pyrosetta.rosetta.core.conformation.Residue) → bool

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::is_beta_aminoacid(const class core::conformation::Residue &) const –> bool

is_in_taboo_map(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover, ts: pyrosetta.rosetta.utility.vector0_core_conformation_ppo_torsion_bin) → bool

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::is_in_taboo_map(const class utility::vector0<enum core::conformation::ppo_torsion_bin, class std::allocator<enum core::conformation::ppo_torsion_bin> > &) const –> bool

last_move_succeeded(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover) → bool

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::last_move_succeeded() –> bool

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

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

loop_begin(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover) → int

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::loop_begin() const –> unsigned long

loop_end(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover) → int

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::loop_end() const –> unsigned long

middle_res(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover) → int

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::middle_res() const –> unsigned long

name() → str

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

perturber(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover) → pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::perturber() –> class std::shared_ptr<class protocols::loops::loop_closure::kinematic_closure::KinematicPerturber>

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

segment_length(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover) → int

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::segment_length() const –> unsigned long

set_bump_overlap_factor(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover, bump_overlap_factor: float) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::set_bump_overlap_factor(double) –> 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_do_sfxn_eval_every_iteration(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover, do_sfxn_eval: bool) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::set_do_sfxn_eval_every_iteration(bool) –> void

set_filters(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover, filters_in: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_protocols_filters_Filter_t) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::set_filters(const class utility::vector1<class std::shared_ptr<const class protocols::filters::Filter>, class std::allocator<class std::shared_ptr<const class protocols::filters::Filter> > > &) –> void

set_hardsphere_bump_check(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover, do_bump_check: bool) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::set_hardsphere_bump_check(bool) –> void

set_idealize_loop_first(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover, idealize: bool) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::set_idealize_loop_first(bool) –> void

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

setter for poses contained for rms

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

set_loop_begin_and_end(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover, loop_begin: int, loop_end: int) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::set_loop_begin_and_end(unsigned long, unsigned long) –> void

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

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

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

set_nonpivot_bb_torsion_id(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover, bbtorids: pyrosetta.rosetta.utility.vector1_unsigned_long) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::set_nonpivot_bb_torsion_id(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> void

set_nonpivot_res_to_sweep(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover, resids: pyrosetta.rosetta.utility.vector1_unsigned_long) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::set_nonpivot_res_to_sweep(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> void

set_perturber(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover, perturber_in: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::set_perturber(class std::shared_ptr<class protocols::loops::loop_closure::kinematic_closure::KinematicPerturber>) –> void

set_pivots(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover, start_res: int, middle_res: int, end_res: int) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::set_pivots(unsigned long, unsigned long, unsigned long) –> void

set_rama_check(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover, do_rama_check: bool) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::set_rama_check(bool) –> void

set_sample_nonpivot_torsions(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover, sample: bool) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::set_sample_nonpivot_torsions(bool) –> void

set_sfxn(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover, sfxn_in: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::set_sfxn(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> void

set_sweep_nonpivot_torsions(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover, sweep: bool) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::set_sweep_nonpivot_torsions(bool) –> void

set_sweep_nsteps(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover, nsteps: pyrosetta.rosetta.utility.vector1_unsigned_long) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::set_sweep_nsteps(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> void

set_sweep_start_angle(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover, angles_in_degrees: pyrosetta.rosetta.utility.vector1_double) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::set_sweep_start_angle(const class utility::vector1<double, class std::allocator<double> > &) –> void

set_sweep_step_size(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover, angle_steps_in_degrees: pyrosetta.rosetta.utility.vector1_double) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::set_sweep_step_size(const class utility::vector1<double, class std::allocator<double> > &) –> void

set_temperature(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover, temp_in: float) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::set_temperature(double) –> 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

set_vary_bondangles(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover, vary: bool) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::set_vary_bondangles(bool) –> void

show(*args, **kwargs)

Overloaded function.

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

Outputs details about the Mover, including current settings.

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

start_res(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover) → int

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::start_res() const –> unsigned long

sweep_incomplete(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover) → bool

returns true as long as the Lexicographical iterator has not covered all

angles – useful in a while-loop.

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::sweep_incomplete() const –> bool

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

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

Allows extra test specific functions to be called before applying

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

torsion_features_string(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.utility.vector0_core_conformation_ppo_torsion_bin

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::torsion_features_string(const class core::pose::Pose &) const –> class utility::vector0<enum core::conformation::ppo_torsion_bin, class std::allocator<enum core::conformation::ppo_torsion_bin> >

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_sequence(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover, sequence: pyrosetta.rosetta.utility.vector1_core_chemical_AA) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicMover::update_sequence(const class utility::vector1<enum core::chemical::AA, class std::allocator<enum core::chemical::AA> > &) –> void

class pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber

Bases: pybind11_builtins.pybind11_object

pure virtual base class for KinematicPerturber. KinematicPerturbers determine HOW loops should be perturbed. The base class contains a provision for determining WHERE they should be perturbed: MoveMap sensitivity.

__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.loops.loop_closure.kinematic_closure.KinematicPerturber) -> None
2. __init__(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber, arg0: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) -> 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.loops.loop_closure.kinematic_closure.KinematicPerturber, : pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::operator=(const class protocols::loops::loop_closure::kinematic_closure::KinematicPerturber &) –> class protocols::loops::loop_closure::kinematic_closure::KinematicPerturber &

clear_torsion_string_stack(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::clear_torsion_string_stack() –> void

get_movemap(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → pyrosetta.rosetta.core.kinematics.MoveMap

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::get_movemap() const –> class std::shared_ptr<const class core::kinematics::MoveMap>

kinmover(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → pyrosetta.rosetta.std.weak_ptr_const_protocols_loops_loop_closure_kinematic_closure_KinematicMover_t

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::kinmover() const –> class std::weak_ptr<const class protocols::loops::loop_closure::kinematic_closure::KinematicMover>

max_sample_iterations(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → int

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::max_sample_iterations() const –> unsigned long

perturb_chain(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber, pose: pyrosetta.rosetta.core.pose.Pose, torsions: pyrosetta.rosetta.utility.vector1_double, bond_ang: pyrosetta.rosetta.utility.vector1_double, bond_len: pyrosetta.rosetta.utility.vector1_double) → None

function that perturbs the chain, i.e. sets new values

for the torsions, bond angles and bond lengths note: the torsions/angles/lengths that are input to this function will be identical to the ones in the pose, i.e. only the dof values that are explicitly set by this function plus the pivots will have changed after loop closure

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::perturb_chain(const class core::pose::Pose &, class utility::vector1<double, class std::allocator<double> > &, class utility::vector1<double, class std::allocator<double> > &, class utility::vector1<double, class std::allocator<double> > &) –> void

perturber_exhausted(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → bool

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::perturber_exhausted() const –> bool

perturber_type(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → str

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::perturber_type() const –> std::string

set_kinmover(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber, kinmover: pyrosetta.rosetta.std.weak_ptr_const_protocols_loops_loop_closure_kinematic_closure_KinematicMover_t) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::set_kinmover(class std::weak_ptr<const class protocols::loops::loop_closure::kinematic_closure::KinematicMover>) –> void

set_max_sample_iterations(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber, sample_its: int) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::set_max_sample_iterations(unsigned long) –> void

set_movemap(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber, mm: pyrosetta.rosetta.core.kinematics.MoveMap) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::set_movemap(class std::shared_ptr<const class core::kinematics::MoveMap>) –> void

set_pose_after_closure(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber, pose: pyrosetta.rosetta.core.pose.Pose, torsions: pyrosetta.rosetta.utility.vector1_double, : pyrosetta.rosetta.utility.vector1_double, : pyrosetta.rosetta.utility.vector1_double, : bool) → None

after the kinmover has closed the loop, the perturber needs

to put the solutions into the pose note: the base class version of this function sets the torsions, so any KinematicPerturber that only changes the torsions will not have to implement this function

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::set_pose_after_closure(class core::pose::Pose &, const class utility::vector1<double, class std::allocator<double> > &, const class utility::vector1<double, class std::allocator<double> > &, const class utility::vector1<double, class std::allocator<double> > &, bool) const –> void

class pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicWrapper

Bases: pyrosetta.rosetta.protocols.moves.Mover

This class extends KinematicMover by composition (has-a KinematicMover). The idea is to make KinematicMover useful when ONLY the apply() function is available (as in MoverContainers, etc.). It will reapply KinematicMover until the KinematicMover reports a success. This class uses searches through loop begin/middle/end points while searching for solutions. You can pass a MoveMap; it will refuse to put pivots where the MoveMap is not mobile.

__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.loops.loop_closure.kinematic_closure.KinematicWrapper, arg0: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover, arg1: pyrosetta.rosetta.protocols.loops.Loop) -> None

doc

2. __init__(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicWrapper, kinmover_in: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover, loop: pyrosetta.rosetta.protocols.loops.Loop, cycles: int) -> None
3. __init__(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicWrapper, arg0: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover, arg1: int, arg2: int) -> None

doc

4. __init__(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicWrapper, kinmover_in: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicMover, loop_begin: int, loop_end: int, cycles: int) -> None
5. __init__(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicWrapper, arg0: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicWrapper) -> 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.loops.loop_closure.kinematic_closure.KinematicWrapper, pose: pyrosetta.rosetta.core.pose.Pose) → None

re-applies KinematicMover with different pivots until success

C++: protocols::loops::loop_closure::kinematic_closure::KinematicWrapper::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.moves.Mover, other: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::moves::Mover::operator=(const class protocols::moves::Mover &) –> class protocols::moves::Mover &

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

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

clear_info is called by jd2 before calling apply

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

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

Return a clone of the Mover object.

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

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

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

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

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

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

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

fpd

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

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.loops.loop_closure.kinematic_closure.KinematicWrapper) → str

C++: protocols::loops::loop_closure::kinematic_closure::KinematicWrapper::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_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

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

respect_this_movemap(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicWrapper, mm: pyrosetta.rosetta.core.kinematics.MoveMap) → None

this function derives the allowed_positions_ vector from mm and the loop begin/end

C++: protocols::loops::loop_closure::kinematic_closure::KinematicWrapper::respect_this_movemap(class std::shared_ptr<const class core::kinematics::MoveMap>) –> 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_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.loops.loop_closure.kinematic_closure.NeighborDependentTabooSamplingKinematicPerturber

Bases: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.BaseTabooPerturber

Neighbor-dependent Taboo-sampling kinematic perturber (still samples randomly, but only within a given torsion bin; the Taboo sampler ensures that this torsion bin is varied in each iteration) that uses neighbor-dependent Ramachandran distributions (rama2b)

Amelie Stein

Mon May 21 11:39:26 PDT 2012

__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.loops.loop_closure.kinematic_closure.NeighborDependentTabooSamplingKinematicPerturber, kinmover_in: pyrosetta.rosetta.std.weak_ptr_const_protocols_loops_loop_closure_kinematic_closure_KinematicMover_t) → 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.loops.loop_closure.kinematic_closure.BaseTabooPerturber, : pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.BaseTabooPerturber) → pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.BaseTabooPerturber

C++: protocols::loops::loop_closure::kinematic_closure::BaseTabooPerturber::operator=(const class protocols::loops::loop_closure::kinematic_closure::BaseTabooPerturber &) –> class protocols::loops::loop_closure::kinematic_closure::BaseTabooPerturber &

clear_torsion_string_stack(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.BaseTabooPerturber) → None

C++: protocols::loops::loop_closure::kinematic_closure::BaseTabooPerturber::clear_torsion_string_stack() –> void

get_movemap(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → pyrosetta.rosetta.core.kinematics.MoveMap

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::get_movemap() const –> class std::shared_ptr<const class core::kinematics::MoveMap>

kinmover(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → pyrosetta.rosetta.std.weak_ptr_const_protocols_loops_loop_closure_kinematic_closure_KinematicMover_t

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::kinmover() const –> class std::weak_ptr<const class protocols::loops::loop_closure::kinematic_closure::KinematicMover>

max_sample_iterations(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → int

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::max_sample_iterations() const –> unsigned long

next_torsion_string(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.BaseTabooPerturber) → pyrosetta.rosetta.utility.vector0_core_conformation_ppo_torsion_bin

C++: protocols::loops::loop_closure::kinematic_closure::BaseTabooPerturber::next_torsion_string() –> class utility::vector0<enum core::conformation::ppo_torsion_bin, class std::allocator<enum core::conformation::ppo_torsion_bin> >

num_strings(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.BaseTabooPerturber) → int

C++: protocols::loops::loop_closure::kinematic_closure::BaseTabooPerturber::num_strings() const –> unsigned long

perturb_chain(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.BaseTabooPerturber, pose: pyrosetta.rosetta.core.pose.Pose, torsions: pyrosetta.rosetta.utility.vector1_double, bond_ang: pyrosetta.rosetta.utility.vector1_double, : pyrosetta.rosetta.utility.vector1_double) → None

C++: protocols::loops::loop_closure::kinematic_closure::BaseTabooPerturber::perturb_chain(const class core::pose::Pose &, class utility::vector1<double, class std::allocator<double> > &, class utility::vector1<double, class std::allocator<double> > &, class utility::vector1<double, class std::allocator<double> > &) –> void

perturber_exhausted(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → bool

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::perturber_exhausted() const –> bool

perturber_type(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.NeighborDependentTabooSamplingKinematicPerturber) → str

C++: protocols::loops::loop_closure::kinematic_closure::NeighborDependentTabooSamplingKinematicPerturber::perturber_type() const –> std::string

set_kinmover(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber, kinmover: pyrosetta.rosetta.std.weak_ptr_const_protocols_loops_loop_closure_kinematic_closure_KinematicMover_t) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::set_kinmover(class std::weak_ptr<const class protocols::loops::loop_closure::kinematic_closure::KinematicMover>) –> void

set_max_sample_iterations(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber, sample_its: int) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::set_max_sample_iterations(unsigned long) –> void

set_movemap(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber, mm: pyrosetta.rosetta.core.kinematics.MoveMap) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::set_movemap(class std::shared_ptr<const class core::kinematics::MoveMap>) –> void

set_pose_after_closure(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.BaseTabooPerturber, pose: pyrosetta.rosetta.core.pose.Pose, torsions: pyrosetta.rosetta.utility.vector1_double, bond_ang: pyrosetta.rosetta.utility.vector1_double, bond_len: pyrosetta.rosetta.utility.vector1_double, closure_successful: bool) → None

C++: protocols::loops::loop_closure::kinematic_closure::BaseTabooPerturber::set_pose_after_closure(class core::pose::Pose &, const class utility::vector1<double, class std::allocator<double> > &, const class utility::vector1<double, class std::allocator<double> > &, const class utility::vector1<double, class std::allocator<double> > &, bool) const –> void

set_vary_ca_bond_angles(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.BaseTabooPerturber, vary_ca_bond_angles: bool) → None

C++: protocols::loops::loop_closure::kinematic_closure::BaseTabooPerturber::set_vary_ca_bond_angles(bool) –> void

class pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.NeighborDependentTorsionSamplingKinematicPerturber

Bases: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber

Amelie Stein

neighbor-dependent torsion sampling kinematic perturber – uses rama2b for phi/psi lookup

__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.loops.loop_closure.kinematic_closure.NeighborDependentTorsionSamplingKinematicPerturber, kinmover_in: pyrosetta.rosetta.std.weak_ptr_const_protocols_loops_loop_closure_kinematic_closure_KinematicMover_t) → 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.loops.loop_closure.kinematic_closure.KinematicPerturber, : pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::operator=(const class protocols::loops::loop_closure::kinematic_closure::KinematicPerturber &) –> class protocols::loops::loop_closure::kinematic_closure::KinematicPerturber &

clear_torsion_string_stack(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::clear_torsion_string_stack() –> void

get_movemap(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → pyrosetta.rosetta.core.kinematics.MoveMap

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::get_movemap() const –> class std::shared_ptr<const class core::kinematics::MoveMap>

kinmover(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → pyrosetta.rosetta.std.weak_ptr_const_protocols_loops_loop_closure_kinematic_closure_KinematicMover_t

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::kinmover() const –> class std::weak_ptr<const class protocols::loops::loop_closure::kinematic_closure::KinematicMover>

max_sample_iterations(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → int

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::max_sample_iterations() const –> unsigned long

perturb_chain(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.NeighborDependentTorsionSamplingKinematicPerturber, pose: pyrosetta.rosetta.core.pose.Pose, torsions: pyrosetta.rosetta.utility.vector1_double, bond_ang: pyrosetta.rosetta.utility.vector1_double, : pyrosetta.rosetta.utility.vector1_double) → None

C++: protocols::loops::loop_closure::kinematic_closure::NeighborDependentTorsionSamplingKinematicPerturber::perturb_chain(const class core::pose::Pose &, class utility::vector1<double, class std::allocator<double> > &, class utility::vector1<double, class std::allocator<double> > &, class utility::vector1<double, class std::allocator<double> > &) –> void

perturber_exhausted(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → bool

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::perturber_exhausted() const –> bool

perturber_type(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.NeighborDependentTorsionSamplingKinematicPerturber) → str

C++: protocols::loops::loop_closure::kinematic_closure::NeighborDependentTorsionSamplingKinematicPerturber::perturber_type() const –> std::string

set_kinmover(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber, kinmover: pyrosetta.rosetta.std.weak_ptr_const_protocols_loops_loop_closure_kinematic_closure_KinematicMover_t) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::set_kinmover(class std::weak_ptr<const class protocols::loops::loop_closure::kinematic_closure::KinematicMover>) –> void

set_max_sample_iterations(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber, sample_its: int) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::set_max_sample_iterations(unsigned long) –> void

set_movemap(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber, mm: pyrosetta.rosetta.core.kinematics.MoveMap) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::set_movemap(class std::shared_ptr<const class core::kinematics::MoveMap>) –> void

set_pose_after_closure(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.NeighborDependentTorsionSamplingKinematicPerturber, pose: pyrosetta.rosetta.core.pose.Pose, torsions: pyrosetta.rosetta.utility.vector1_double, bond_ang: pyrosetta.rosetta.utility.vector1_double, bond_len: pyrosetta.rosetta.utility.vector1_double, closure_successful: bool) → None

C++: protocols::loops::loop_closure::kinematic_closure::NeighborDependentTorsionSamplingKinematicPerturber::set_pose_after_closure(class core::pose::Pose &, const class utility::vector1<double, class std::allocator<double> > &, const class utility::vector1<double, class std::allocator<double> > &, const class utility::vector1<double, class std::allocator<double> > &, bool) const –> void

set_vary_ca_bond_angles(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.NeighborDependentTorsionSamplingKinematicPerturber, vary_ca_bond_angles: bool) → None

C++: protocols::loops::loop_closure::kinematic_closure::NeighborDependentTorsionSamplingKinematicPerturber::set_vary_ca_bond_angles(bool) –> void

class pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.TabooSamplingKinematicPerturber

Bases: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.BaseTabooPerturber

Taboo-sampling kinematic perturber (still samples randomly, but only within a specific torsion bin, and the Taboo sampler ensures that this torsion bin is varied in each iteration)

Amelie Stein

__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.loops.loop_closure.kinematic_closure.TabooSamplingKinematicPerturber, kinmover_in: pyrosetta.rosetta.std.weak_ptr_const_protocols_loops_loop_closure_kinematic_closure_KinematicMover_t) → 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.loops.loop_closure.kinematic_closure.BaseTabooPerturber, : pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.BaseTabooPerturber) → pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.BaseTabooPerturber

C++: protocols::loops::loop_closure::kinematic_closure::BaseTabooPerturber::operator=(const class protocols::loops::loop_closure::kinematic_closure::BaseTabooPerturber &) –> class protocols::loops::loop_closure::kinematic_closure::BaseTabooPerturber &

clear_torsion_string_stack(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.BaseTabooPerturber) → None

C++: protocols::loops::loop_closure::kinematic_closure::BaseTabooPerturber::clear_torsion_string_stack() –> void

get_movemap(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → pyrosetta.rosetta.core.kinematics.MoveMap

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::get_movemap() const –> class std::shared_ptr<const class core::kinematics::MoveMap>

kinmover(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → pyrosetta.rosetta.std.weak_ptr_const_protocols_loops_loop_closure_kinematic_closure_KinematicMover_t

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::kinmover() const –> class std::weak_ptr<const class protocols::loops::loop_closure::kinematic_closure::KinematicMover>

max_sample_iterations(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → int

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::max_sample_iterations() const –> unsigned long

next_torsion_string(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.BaseTabooPerturber) → pyrosetta.rosetta.utility.vector0_core_conformation_ppo_torsion_bin

C++: protocols::loops::loop_closure::kinematic_closure::BaseTabooPerturber::next_torsion_string() –> class utility::vector0<enum core::conformation::ppo_torsion_bin, class std::allocator<enum core::conformation::ppo_torsion_bin> >

num_strings(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.BaseTabooPerturber) → int

C++: protocols::loops::loop_closure::kinematic_closure::BaseTabooPerturber::num_strings() const –> unsigned long

perturb_chain(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.BaseTabooPerturber, pose: pyrosetta.rosetta.core.pose.Pose, torsions: pyrosetta.rosetta.utility.vector1_double, bond_ang: pyrosetta.rosetta.utility.vector1_double, : pyrosetta.rosetta.utility.vector1_double) → None

C++: protocols::loops::loop_closure::kinematic_closure::BaseTabooPerturber::perturb_chain(const class core::pose::Pose &, class utility::vector1<double, class std::allocator<double> > &, class utility::vector1<double, class std::allocator<double> > &, class utility::vector1<double, class std::allocator<double> > &) –> void

perturber_exhausted(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → bool

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::perturber_exhausted() const –> bool

perturber_type(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.TabooSamplingKinematicPerturber) → str

C++: protocols::loops::loop_closure::kinematic_closure::TabooSamplingKinematicPerturber::perturber_type() const –> std::string

set_kinmover(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber, kinmover: pyrosetta.rosetta.std.weak_ptr_const_protocols_loops_loop_closure_kinematic_closure_KinematicMover_t) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::set_kinmover(class std::weak_ptr<const class protocols::loops::loop_closure::kinematic_closure::KinematicMover>) –> void

set_max_sample_iterations(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber, sample_its: int) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::set_max_sample_iterations(unsigned long) –> void

set_movemap(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber, mm: pyrosetta.rosetta.core.kinematics.MoveMap) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::set_movemap(class std::shared_ptr<const class core::kinematics::MoveMap>) –> void

set_pose_after_closure(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.BaseTabooPerturber, pose: pyrosetta.rosetta.core.pose.Pose, torsions: pyrosetta.rosetta.utility.vector1_double, bond_ang: pyrosetta.rosetta.utility.vector1_double, bond_len: pyrosetta.rosetta.utility.vector1_double, closure_successful: bool) → None

C++: protocols::loops::loop_closure::kinematic_closure::BaseTabooPerturber::set_pose_after_closure(class core::pose::Pose &, const class utility::vector1<double, class std::allocator<double> > &, const class utility::vector1<double, class std::allocator<double> > &, const class utility::vector1<double, class std::allocator<double> > &, bool) const –> void

set_vary_ca_bond_angles(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.BaseTabooPerturber, vary_ca_bond_angles: bool) → None

C++: protocols::loops::loop_closure::kinematic_closure::BaseTabooPerturber::set_vary_ca_bond_angles(bool) –> void

class pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.TorsionRestrictedKinematicPerturber

Bases: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber

torsion-restricted kinematic perturber (still samples randomly, but only within a given torsion bin)

Amelie Stein

__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.loops.loop_closure.kinematic_closure.TorsionRestrictedKinematicPerturber, kinmover_in: pyrosetta.rosetta.std.weak_ptr_const_protocols_loops_loop_closure_kinematic_closure_KinematicMover_t, torsion_bins: pyrosetta.rosetta.utility.vector0_core_conformation_ppo_torsion_bin) → 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.loops.loop_closure.kinematic_closure.KinematicPerturber, : pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::operator=(const class protocols::loops::loop_closure::kinematic_closure::KinematicPerturber &) –> class protocols::loops::loop_closure::kinematic_closure::KinematicPerturber &

clear_torsion_string_stack(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::clear_torsion_string_stack() –> void

get_movemap(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → pyrosetta.rosetta.core.kinematics.MoveMap

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::get_movemap() const –> class std::shared_ptr<const class core::kinematics::MoveMap>

kinmover(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → pyrosetta.rosetta.std.weak_ptr_const_protocols_loops_loop_closure_kinematic_closure_KinematicMover_t

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::kinmover() const –> class std::weak_ptr<const class protocols::loops::loop_closure::kinematic_closure::KinematicMover>

max_sample_iterations(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → int

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::max_sample_iterations() const –> unsigned long

perturb_chain(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.TorsionRestrictedKinematicPerturber, pose: pyrosetta.rosetta.core.pose.Pose, torsions: pyrosetta.rosetta.utility.vector1_double, bond_ang: pyrosetta.rosetta.utility.vector1_double, : pyrosetta.rosetta.utility.vector1_double) → None

C++: protocols::loops::loop_closure::kinematic_closure::TorsionRestrictedKinematicPerturber::perturb_chain(const class core::pose::Pose &, class utility::vector1<double, class std::allocator<double> > &, class utility::vector1<double, class std::allocator<double> > &, class utility::vector1<double, class std::allocator<double> > &) –> void

perturber_exhausted(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → bool

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::perturber_exhausted() const –> bool

perturber_type(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.TorsionRestrictedKinematicPerturber) → str

C++: protocols::loops::loop_closure::kinematic_closure::TorsionRestrictedKinematicPerturber::perturber_type() const –> std::string

set_kinmover(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber, kinmover: pyrosetta.rosetta.std.weak_ptr_const_protocols_loops_loop_closure_kinematic_closure_KinematicMover_t) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::set_kinmover(class std::weak_ptr<const class protocols::loops::loop_closure::kinematic_closure::KinematicMover>) –> void

set_max_sample_iterations(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber, sample_its: int) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::set_max_sample_iterations(unsigned long) –> void

set_movemap(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber, mm: pyrosetta.rosetta.core.kinematics.MoveMap) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::set_movemap(class std::shared_ptr<const class core::kinematics::MoveMap>) –> void

set_pose_after_closure(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.TorsionRestrictedKinematicPerturber, pose: pyrosetta.rosetta.core.pose.Pose, torsions: pyrosetta.rosetta.utility.vector1_double, bond_ang: pyrosetta.rosetta.utility.vector1_double, bond_len: pyrosetta.rosetta.utility.vector1_double, closure_successful: bool) → None

C++: protocols::loops::loop_closure::kinematic_closure::TorsionRestrictedKinematicPerturber::set_pose_after_closure(class core::pose::Pose &, const class utility::vector1<double, class std::allocator<double> > &, const class utility::vector1<double, class std::allocator<double> > &, const class utility::vector1<double, class std::allocator<double> > &, bool) const –> void

set_vary_ca_bond_angles(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.TorsionRestrictedKinematicPerturber, vary_ca_bond_angles: bool) → None

C++: protocols::loops::loop_closure::kinematic_closure::TorsionRestrictedKinematicPerturber::set_vary_ca_bond_angles(bool) –> void

class pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.TorsionSamplingKinematicPerturber

Bases: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber

torsion sampling kinematic perturber

__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.loops.loop_closure.kinematic_closure.TorsionSamplingKinematicPerturber, kinmover_in: pyrosetta.rosetta.std.weak_ptr_const_protocols_loops_loop_closure_kinematic_closure_KinematicMover_t) → 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.loops.loop_closure.kinematic_closure.KinematicPerturber, : pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::operator=(const class protocols::loops::loop_closure::kinematic_closure::KinematicPerturber &) –> class protocols::loops::loop_closure::kinematic_closure::KinematicPerturber &

clear_torsion_string_stack(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::clear_torsion_string_stack() –> void

get_movemap(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → pyrosetta.rosetta.core.kinematics.MoveMap

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::get_movemap() const –> class std::shared_ptr<const class core::kinematics::MoveMap>

initialize_betaresidue_minima(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.TorsionSamplingKinematicPerturber, philist: pyrosetta.rosetta.utility.vector1_double, thetalist: pyrosetta.rosetta.utility.vector1_double, psilist: pyrosetta.rosetta.utility.vector1_double, mode: int) → None

Initialize positions of minima in the beta-amino acid Ramachandran cube.

C++: protocols::loops::loop_closure::kinematic_closure::TorsionSamplingKinematicPerturber::initialize_betaresidue_minima(class utility::vector1<double, class std::allocator<double> > &, class utility::vector1<double, class std::allocator<double> > &, class utility::vector1<double, class std::allocator<double> > &, const unsigned long) const –> void

kinmover(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → pyrosetta.rosetta.std.weak_ptr_const_protocols_loops_loop_closure_kinematic_closure_KinematicMover_t

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::kinmover() const –> class std::weak_ptr<const class protocols::loops::loop_closure::kinematic_closure::KinematicMover>

max_sample_iterations(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → int

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::max_sample_iterations() const –> unsigned long

perturb_beta_residue(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.TorsionSamplingKinematicPerturber, phi: float, theta: float, psi: float, beta_residue_type: int) → None

Varies torsions of a beta-amino acid residue based on minimia in the beta-amino acid Ramachandran cube. This randomly picks a minimum, then chooses phi/theta/psi values randomly in a Gaussian centered in that minimum.

C++: protocols::loops::loop_closure::kinematic_closure::TorsionSamplingKinematicPerturber::perturb_beta_residue(double &, double &, double &, const unsigned long) const –> void

perturb_chain(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.TorsionSamplingKinematicPerturber, pose: pyrosetta.rosetta.core.pose.Pose, torsions: pyrosetta.rosetta.utility.vector1_double, bond_ang: pyrosetta.rosetta.utility.vector1_double, : pyrosetta.rosetta.utility.vector1_double) → None

varies torsions always and bond angles sometimes. Currently torsion varying will respect a movemap if present; angles do NOT look for a movemap.

C++: protocols::loops::loop_closure::kinematic_closure::TorsionSamplingKinematicPerturber::perturb_chain(const class core::pose::Pose &, class utility::vector1<double, class std::allocator<double> > &, class utility::vector1<double, class std::allocator<double> > &, class utility::vector1<double, class std::allocator<double> > &) –> void

perturber_exhausted(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → bool

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::perturber_exhausted() const –> bool

perturber_type(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.TorsionSamplingKinematicPerturber) → str

C++: protocols::loops::loop_closure::kinematic_closure::TorsionSamplingKinematicPerturber::perturber_type() const –> std::string

set_kinmover(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber, kinmover: pyrosetta.rosetta.std.weak_ptr_const_protocols_loops_loop_closure_kinematic_closure_KinematicMover_t) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::set_kinmover(class std::weak_ptr<const class protocols::loops::loop_closure::kinematic_closure::KinematicMover>) –> void

set_max_sample_iterations(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber, sample_its: int) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::set_max_sample_iterations(unsigned long) –> void

set_movemap(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber, mm: pyrosetta.rosetta.core.kinematics.MoveMap) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::set_movemap(class std::shared_ptr<const class core::kinematics::MoveMap>) –> void

set_pose_after_closure(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.TorsionSamplingKinematicPerturber, pose: pyrosetta.rosetta.core.pose.Pose, torsions: pyrosetta.rosetta.utility.vector1_double, bond_ang: pyrosetta.rosetta.utility.vector1_double, bond_len: pyrosetta.rosetta.utility.vector1_double, closure_successful: bool) → None

C++: protocols::loops::loop_closure::kinematic_closure::TorsionSamplingKinematicPerturber::set_pose_after_closure(class core::pose::Pose &, const class utility::vector1<double, class std::allocator<double> > &, const class utility::vector1<double, class std::allocator<double> > &, const class utility::vector1<double, class std::allocator<double> > &, bool) const –> void

set_vary_ca_bond_angles(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.TorsionSamplingKinematicPerturber, vary_ca_bond_angles: bool) → None

C++: protocols::loops::loop_closure::kinematic_closure::TorsionSamplingKinematicPerturber::set_vary_ca_bond_angles(bool) –> void

class pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.TorsionSweepingKinematicPerturber

Bases: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber

Here’s some commentary on why the TorsionSweepingKinematicPerturber is Fun and Awesome to use! Basically, you take the loop as given and search for solutions nearby. Its purpose is not to produce large changes, but instead to produce small perturbations to find the bottom of the current energy well. It’s not meant to be used for the original KIC protocol, in which the pivots are changed regularly: you can’t sweep through nonpivot torsion space if the pivots don’t stay the same.

__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.loops.loop_closure.kinematic_closure.TorsionSweepingKinematicPerturber) -> None
2. __init__(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.TorsionSweepingKinematicPerturber, arg0: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.TorsionSweepingKinematicPerturber) -> 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.loops.loop_closure.kinematic_closure.TorsionSweepingKinematicPerturber, : pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.TorsionSweepingKinematicPerturber) → pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.TorsionSweepingKinematicPerturber

C++: protocols::loops::loop_closure::kinematic_closure::TorsionSweepingKinematicPerturber::operator=(const class protocols::loops::loop_closure::kinematic_closure::TorsionSweepingKinematicPerturber &) –> class protocols::loops::loop_closure::kinematic_closure::TorsionSweepingKinematicPerturber &

clear_torsion_string_stack(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::clear_torsion_string_stack() –> void

get_movemap(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → pyrosetta.rosetta.core.kinematics.MoveMap

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::get_movemap() const –> class std::shared_ptr<const class core::kinematics::MoveMap>

kinmover(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → pyrosetta.rosetta.std.weak_ptr_const_protocols_loops_loop_closure_kinematic_closure_KinematicMover_t

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::kinmover() const –> class std::weak_ptr<const class protocols::loops::loop_closure::kinematic_closure::KinematicMover>

max_sample_iterations(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → int

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::max_sample_iterations() const –> unsigned long

perturb_chain(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.TorsionSweepingKinematicPerturber, pose: pyrosetta.rosetta.core.pose.Pose, torsions: pyrosetta.rosetta.utility.vector1_double, bond_ang: pyrosetta.rosetta.utility.vector1_double, : pyrosetta.rosetta.utility.vector1_double) → None

movemap control NOT IMPLEMENTED in TorsionSweepingKP. It is also NOT NEEDED because you can use set_nonpivot_res_to_sweep instead.

C++: protocols::loops::loop_closure::kinematic_closure::TorsionSweepingKinematicPerturber::perturb_chain(const class core::pose::Pose &, class utility::vector1<double, class std::allocator<double> > &, class utility::vector1<double, class std::allocator<double> > &, class utility::vector1<double, class std::allocator<double> > &) –> void

perturber_exhausted(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.TorsionSweepingKinematicPerturber) → bool

C++: protocols::loops::loop_closure::kinematic_closure::TorsionSweepingKinematicPerturber::perturber_exhausted() const –> bool

perturber_type(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.TorsionSweepingKinematicPerturber) → str

C++: protocols::loops::loop_closure::kinematic_closure::TorsionSweepingKinematicPerturber::perturber_type() const –> std::string

set_kinmover(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber, kinmover: pyrosetta.rosetta.std.weak_ptr_const_protocols_loops_loop_closure_kinematic_closure_KinematicMover_t) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::set_kinmover(class std::weak_ptr<const class protocols::loops::loop_closure::kinematic_closure::KinematicMover>) –> void

set_max_sample_iterations(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber, sample_its: int) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::set_max_sample_iterations(unsigned long) –> void

set_movemap(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber, mm: pyrosetta.rosetta.core.kinematics.MoveMap) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::set_movemap(class std::shared_ptr<const class core::kinematics::MoveMap>) –> void

set_nonpivot_bb_torsion_id(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.TorsionSweepingKinematicPerturber, bbtorids: pyrosetta.rosetta.utility.vector1_unsigned_long) → None

C++: protocols::loops::loop_closure::kinematic_closure::TorsionSweepingKinematicPerturber::set_nonpivot_bb_torsion_id(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> void

set_nonpivot_res_to_sweep(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.TorsionSweepingKinematicPerturber, resids: pyrosetta.rosetta.utility.vector1_unsigned_long) → None

C++: protocols::loops::loop_closure::kinematic_closure::TorsionSweepingKinematicPerturber::set_nonpivot_res_to_sweep(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> void

set_pose_after_closure(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber, pose: pyrosetta.rosetta.core.pose.Pose, torsions: pyrosetta.rosetta.utility.vector1_double, : pyrosetta.rosetta.utility.vector1_double, : pyrosetta.rosetta.utility.vector1_double, : bool) → None

after the kinmover has closed the loop, the perturber needs

to put the solutions into the pose note: the base class version of this function sets the torsions, so any KinematicPerturber that only changes the torsions will not have to implement this function

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::set_pose_after_closure(class core::pose::Pose &, const class utility::vector1<double, class std::allocator<double> > &, const class utility::vector1<double, class std::allocator<double> > &, const class utility::vector1<double, class std::allocator<double> > &, bool) const –> void

set_sweep_nsteps(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.TorsionSweepingKinematicPerturber, nsteps: pyrosetta.rosetta.utility.vector1_unsigned_long) → None

C++: protocols::loops::loop_closure::kinematic_closure::TorsionSweepingKinematicPerturber::set_sweep_nsteps(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> void

set_sweep_start_angle(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.TorsionSweepingKinematicPerturber, angles_in_degrees: pyrosetta.rosetta.utility.vector1_double) → None

C++: protocols::loops::loop_closure::kinematic_closure::TorsionSweepingKinematicPerturber::set_sweep_start_angle(const class utility::vector1<double, class std::allocator<double> > &) –> void

set_sweep_step_size(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.TorsionSweepingKinematicPerturber, angle_steps_in_degrees: pyrosetta.rosetta.utility.vector1_double) → None

C++: protocols::loops::loop_closure::kinematic_closure::TorsionSweepingKinematicPerturber::set_sweep_step_size(const class utility::vector1<double, class std::allocator<double> > &) –> void

class pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.VicinitySamplingKinematicPerturber

Bases: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber

vicinity sampling kinematic perturber

Amelie Stein (just the refactoring)

__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.loops.loop_closure.kinematic_closure.VicinitySamplingKinematicPerturber, kinmover_in: pyrosetta.rosetta.std.weak_ptr_const_protocols_loops_loop_closure_kinematic_closure_KinematicMover_t) → 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.loops.loop_closure.kinematic_closure.VicinitySamplingKinematicPerturber, : pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.VicinitySamplingKinematicPerturber) → pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.VicinitySamplingKinematicPerturber

C++: protocols::loops::loop_closure::kinematic_closure::VicinitySamplingKinematicPerturber::operator=(const class protocols::loops::loop_closure::kinematic_closure::VicinitySamplingKinematicPerturber &) –> class protocols::loops::loop_closure::kinematic_closure::VicinitySamplingKinematicPerturber &

clear_torsion_string_stack(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::clear_torsion_string_stack() –> void

get_movemap(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → pyrosetta.rosetta.core.kinematics.MoveMap

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::get_movemap() const –> class std::shared_ptr<const class core::kinematics::MoveMap>

kinmover(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → pyrosetta.rosetta.std.weak_ptr_const_protocols_loops_loop_closure_kinematic_closure_KinematicMover_t

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::kinmover() const –> class std::weak_ptr<const class protocols::loops::loop_closure::kinematic_closure::KinematicMover>

max_sample_iterations(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → int

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::max_sample_iterations() const –> unsigned long

perturb_chain(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.VicinitySamplingKinematicPerturber, pose: pyrosetta.rosetta.core.pose.Pose, torsions: pyrosetta.rosetta.utility.vector1_double, bond_ang: pyrosetta.rosetta.utility.vector1_double, : pyrosetta.rosetta.utility.vector1_double) → None

varies torsions always and bond angles sometimes. Currently torsion varying will respect a movemap if present; angles do NOT look for a movemap. – note that the analytic closure and pivot selection currently do not respect movemaps though

C++: protocols::loops::loop_closure::kinematic_closure::VicinitySamplingKinematicPerturber::perturb_chain(const class core::pose::Pose &, class utility::vector1<double, class std::allocator<double> > &, class utility::vector1<double, class std::allocator<double> > &, class utility::vector1<double, class std::allocator<double> > &) –> void

perturber_exhausted(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber) → bool

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::perturber_exhausted() const –> bool

perturber_type(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.VicinitySamplingKinematicPerturber) → str

C++: protocols::loops::loop_closure::kinematic_closure::VicinitySamplingKinematicPerturber::perturber_type() const –> std::string

set_degree_vicinity(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.VicinitySamplingKinematicPerturber, degree_vicinity: float) → None

C++: protocols::loops::loop_closure::kinematic_closure::VicinitySamplingKinematicPerturber::set_degree_vicinity(double) –> void

set_kinmover(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber, kinmover: pyrosetta.rosetta.std.weak_ptr_const_protocols_loops_loop_closure_kinematic_closure_KinematicMover_t) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::set_kinmover(class std::weak_ptr<const class protocols::loops::loop_closure::kinematic_closure::KinematicMover>) –> void

set_max_sample_iterations(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber, sample_its: int) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::set_max_sample_iterations(unsigned long) –> void

set_movemap(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.KinematicPerturber, mm: pyrosetta.rosetta.core.kinematics.MoveMap) → None

C++: protocols::loops::loop_closure::kinematic_closure::KinematicPerturber::set_movemap(class std::shared_ptr<const class core::kinematics::MoveMap>) –> void

set_pose_after_closure(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.VicinitySamplingKinematicPerturber, pose: pyrosetta.rosetta.core.pose.Pose, torsions: pyrosetta.rosetta.utility.vector1_double, bond_ang: pyrosetta.rosetta.utility.vector1_double, bond_len: pyrosetta.rosetta.utility.vector1_double, closure_successful: bool) → None

C++: protocols::loops::loop_closure::kinematic_closure::VicinitySamplingKinematicPerturber::set_pose_after_closure(class core::pose::Pose &, const class utility::vector1<double, class std::allocator<double> > &, const class utility::vector1<double, class std::allocator<double> > &, const class utility::vector1<double, class std::allocator<double> > &, bool) const –> void

set_vary_ca_bond_angles(self: pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure.VicinitySamplingKinematicPerturber, vary_ca_bond_angles: bool) → None

C++: protocols::loops::loop_closure::kinematic_closure::VicinitySamplingKinematicPerturber::set_vary_ca_bond_angles(bool) –> void