carbohydrates

Bindings for protocols::carbohydrates namespace

class pyrosetta.rosetta.protocols.carbohydrates.GlycanRelaxMover

Bases: pyrosetta.rosetta.protocols.moves.Mover

Main mover for Glycan Relax, which optimizes glycans in a pose. Each round optimizes either one residue for BB sampling, linkage, or multiple for minimization. Currently uses a random sampler with a set of weights to each mover for sampling.

Weights are currently as follows:

.40 Phi/Psi Sugar BB Sampling .20 Linkage Conformer Sampling .30 Small BB Sampling - equal weight to phi, psi, or omega

-> .17 +/- 15 degrees -> .086 +/- 45 degrees -> .044 +/- 90 degrees

.05 MinMover .05 PackRotamersMover

Supports Symmetry

__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.carbohydrates.GlycanRelaxMover) -> None
2. __init__(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanRelaxMover, arg0: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector, arg1: pyrosetta.rosetta.core.scoring.ScoreFunction) -> None

doc

3. __init__(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanRelaxMover, selector: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction, rounds: int) -> None
4. __init__(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanRelaxMover, arg0: pyrosetta.rosetta.protocols.carbohydrates.GlycanRelaxMover) -> 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__(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanRelaxMover) → str

__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.carbohydrates.GlycanRelaxMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::carbohydrates::GlycanRelaxMover::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanRelaxMover, : pyrosetta.rosetta.protocols.carbohydrates.GlycanRelaxMover) → pyrosetta.rosetta.protocols.carbohydrates.GlycanRelaxMover

C++: protocols::carbohydrates::GlycanRelaxMover::operator=(const class protocols::carbohydrates::GlycanRelaxMover &) –> class protocols::carbohydrates::GlycanRelaxMover &

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

required in the context of the parser/scripting scheme

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

required in the context of the parser/scripting scheme

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

C++: protocols::carbohydrates::GlycanRelaxMover::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

mover_name() → str

C++: protocols::carbohydrates::GlycanRelaxMover::mover_name() –> std::string

name() → str

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

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

C++: protocols::carbohydrates::GlycanRelaxMover::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

randomize_glycan_torsions(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanRelaxMover, pose: pyrosetta.rosetta.core.pose.Pose, subset: pyrosetta.rosetta.utility.vector1_bool) → None

Randomize all torsions of the subset. Used to start the protocol.

C++: protocols::carbohydrates::GlycanRelaxMover::randomize_glycan_torsions(class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &) const –> void

register_options() → None

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

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

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

reinitialize_for_each_job(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanRelaxMover) → bool

C++: protocols::carbohydrates::GlycanRelaxMover::reinitialize_for_each_job() const –> bool

reinitialize_for_new_input(self: pyrosetta.rosetta.protocols.moves.Mover) → bool

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be regenerated when the input

pose is about to change, (for example, if the Mover has special code on the first apply() that is only valid for that one input pose).

C++: protocols::moves::Mover::reinitialize_for_new_input() const –> bool

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

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

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

set_conformer_sampling_sd(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanRelaxMover, conformer_sampling_sd: float) → None

Number of SDs to sample within during conformer sampling. Default is 2.0 SDs

Sample within X standard_deviations of the means when building [non-idealized] conformers

C++: protocols::carbohydrates::GlycanRelaxMover::set_conformer_sampling_sd(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_defaults(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanRelaxMover) → None

C++: protocols::carbohydrates::GlycanRelaxMover::set_defaults() –> void

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

setter for poses contained for rms

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

set_kt(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanRelaxMover, kt: float) → None

C++: protocols::carbohydrates::GlycanRelaxMover::set_kt(double) –> void

set_min_rings(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanRelaxMover, min_rings: bool) → None

set to minimize ring torsions during minimzation. Default false.

C++: protocols::carbohydrates::GlycanRelaxMover::set_min_rings(bool) –> 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_population_based_conformer_sampling(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanRelaxMover, pop_based_sampling: bool) → None

Set how our Conformer mover samples. Default is to do uniform sampling on the conformers instead of using the population as probabilities.

C++: protocols::carbohydrates::GlycanRelaxMover::set_population_based_conformer_sampling(bool) –> void

set_refine(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanRelaxMover, refine: bool) → None

Set refinement mode instead of denovo modeling mode.

C++: protocols::carbohydrates::GlycanRelaxMover::set_refine(bool) –> void

set_residue_selector(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanRelaxMover, selector: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector) → None

Set the Movemap

C++: protocols::carbohydrates::GlycanRelaxMover::set_residue_selector(class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>) –> void

set_rounds(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanRelaxMover, rounds: int) → None

Each round applys a random mover to pose.

This setting is multiplied by the number of glycan residues in the movemap for the total number of rounds

C++: protocols::carbohydrates::GlycanRelaxMover::set_rounds(unsigned long) –> void

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

Set the ScoreFunction

C++: protocols::carbohydrates::GlycanRelaxMover::set_scorefunction(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> void

set_selector(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanRelaxMover, selector: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector) → None

Set a ResidueSelector for glycan residue selection, instead of the typical movemap.

C++: protocols::carbohydrates::GlycanRelaxMover::set_selector(class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>) –> void

set_taskfactory(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanRelaxMover, tf: pyrosetta.rosetta.core.pack.task.TaskFactory) → None

Set the TaskFactory to control side-chain packing of surrounding amino acids and the OH groups of the glycans.

C++: protocols::carbohydrates::GlycanRelaxMover::set_taskfactory(class std::shared_ptr<const class core::pack::task::TaskFactory>) –> 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_uniform_sd_sampling(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanRelaxMover, uniform_sd_sampling: bool) → None

Set whether if we are sampling uniform within the set number of standard deviations or by uniform within the SD.

Default True

C++: protocols::carbohydrates::GlycanRelaxMover::set_uniform_sd_sampling(bool) –> void

show(*args, **kwargs)

Overloaded function.

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

C++: protocols::carbohydrates::GlycanRelaxMover::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

use_cartmin(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanRelaxMover, use_cartmin: bool) → None

Use Cartesian minimization instead of Dihedral minimization.

Default (for now) is dihedral.

C++: protocols::carbohydrates::GlycanRelaxMover::use_cartmin(bool) –> void

class pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeMinMover

Bases: pyrosetta.rosetta.protocols.moves.Mover

A class that selects the downstream branch from residues in a movemap/selector, and minimizes those residues if on in the primary glycan movemap. Multiple Applies randomly select a different residue in the movemap/selector

Supports Symmetry

__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.carbohydrates.GlycanTreeMinMover) -> None
2. __init__(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeMinMover, arg0: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector) -> None

doc

3. __init__(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeMinMover, arg0: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector, arg1: bool) -> None

doc

4. __init__(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeMinMover, arg0: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector, arg1: bool, arg2: bool) -> None

doc

5. __init__(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeMinMover, selector: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector, min_rings: bool, min_bb: bool, min_chi: bool) -> None
6. __init__(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeMinMover, arg0: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeMinMover) -> 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.carbohydrates.GlycanTreeMinMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

Apply the mover

C++: protocols::carbohydrates::GlycanTreeMinMover::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeMinMover, : pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeMinMover) → pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeMinMover

C++: protocols::carbohydrates::GlycanTreeMinMover::operator=(const class protocols::carbohydrates::GlycanTreeMinMover &) –> class protocols::carbohydrates::GlycanTreeMinMover &

class_name() → str

Show the contents of the Mover

C++: protocols::carbohydrates::GlycanTreeMinMover::class_name() –> std::string

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

required in the context of the parser/scripting scheme

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

required in the context of the parser/scripting scheme

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

Get the name of the Mover

C++: protocols::carbohydrates::GlycanTreeMinMover::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

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

C++: protocols::carbohydrates::GlycanTreeMinMover::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

register_options() → None

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

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

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

reinitialize_for_each_job(self: pyrosetta.rosetta.protocols.moves.Mover) → bool

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be freshly regenerated on

each use.

C++: protocols::moves::Mover::reinitialize_for_each_job() const –> bool

reinitialize_for_new_input(self: pyrosetta.rosetta.protocols.moves.Mover) → bool

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be regenerated when the input

pose is about to change, (for example, if the Mover has special code on the first apply() that is only valid for that one input pose).

C++: protocols::moves::Mover::reinitialize_for_new_input() const –> bool

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

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

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

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

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

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

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

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

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

setter for poses contained for rms

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

set_min_bb(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeMinMover, min_bb: bool) → None

Minimize BB? Default True

C++: protocols::carbohydrates::GlycanTreeMinMover::set_min_bb(bool) –> void

set_min_chi(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeMinMover, min_chi: bool) → None

Minimize Chi? Default True

C++: protocols::carbohydrates::GlycanTreeMinMover::set_min_chi(bool) –> void

set_min_rings(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeMinMover, min_rings: bool) → None

Minimize Rings? Default False

C++: protocols::carbohydrates::GlycanTreeMinMover::set_min_rings(bool) –> void

set_minmover(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeMinMover, min_mover: pyrosetta.rosetta.protocols.simple_moves.MinMover) → None

Set a pre-configured MinMover for this class.

Will OVERRIDE movemap settings.

C++: protocols::carbohydrates::GlycanTreeMinMover::set_minmover(class std::shared_ptr<const class protocols::simple_moves::MinMover>) –> 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_residue_selector(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeMinMover, selector: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector) → None

C++: protocols::carbohydrates::GlycanTreeMinMover::set_residue_selector(class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>) –> 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.carbohydrates.GlycanTreeRelax

Bases: pyrosetta.rosetta.protocols.moves.Mover

A protocol for optimizing glycan trees using GlycanRelax from the base of the tree out to the leaves.

Works by making all other residues virtual except the ones it is working on (current Layer). A virtual residue is not scored. It will start at the first glycan residues, and then move out to the edges.

GENERAL ALGORITHM

We start at the roots, and make all other glycan residues virtual. We first model towards the leaves and this is considered the forward direction. GlycanRelax is used for the actual modeling, we only model a layer at a time, until we reach the tips. If more than one round is set, the protocol will move backwards on the next round, from the leafs to the roots. A third round will involve relaxation again in the forward direction. So we go forward, back, forward, etc. for how ever many rounds you set.

QUECHING

By default, we model all glycans simultaneously. First, all glycan roots (the start of the tree), and slowly unvirtualize all glycan residues, while only modeling each layer. Alternatively, we can choose a particular glycan tree, run the algorithm, and then choose another glycan tree randomly until all glycan trees have been optimized. Here, we call this quenching.

GLYCAN LAYERS

Draw a tree on a paper. We start with the beginning N residues, and work our way out towards the leaves. Layers are defined by the glycan residue distance to the rooot. This enables branching residues to be considered the same layer conceptually and computationally, and allows them to be modeled together.

--LAYER SIZE–

The distance that make up a layer. If we have a distance of 2, we first model all glycans that are equal to or less than 2 residue distance to the root. We then slide this layer up. So we take all residues that have a distance between 3 and 1, and so on. –WINDOW SIZE– The layers are slid down throught the tree of the glycan. The window size represents the overlap in the layers. A window size of 1, means that the last residue (or residues of layer 1) from the last modeling effort, will be used again as part of the next layer. A window size of 0, means that no residues will be re-modeled. Typically, we would want at least a window size of 1.

__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.carbohydrates.GlycanTreeRelax) -> None
2. __init__(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeRelax, arg0: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeRelax) -> 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__(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeRelax) → str

__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.carbohydrates.GlycanTreeRelax, pose: pyrosetta.rosetta.core.pose.Pose) → None

Apply the mover

C++: protocols::carbohydrates::GlycanTreeRelax::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeRelax, : pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeRelax) → pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeRelax

C++: protocols::carbohydrates::GlycanTreeRelax::operator=(const class protocols::carbohydrates::GlycanTreeRelax &) –> class protocols::carbohydrates::GlycanTreeRelax &

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

required in the context of the parser/scripting scheme

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

required in the context of the parser/scripting scheme

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

C++: protocols::carbohydrates::GlycanTreeRelax::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

mover_name() → str

C++: protocols::carbohydrates::GlycanTreeRelax::mover_name() –> std::string

name() → str

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

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

C++: protocols::carbohydrates::GlycanTreeRelax::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

register_options() → None

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

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

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

reinitialize_for_each_job(self: pyrosetta.rosetta.protocols.moves.Mover) → bool

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be freshly regenerated on

each use.

C++: protocols::moves::Mover::reinitialize_for_each_job() const –> bool

reinitialize_for_new_input(self: pyrosetta.rosetta.protocols.moves.Mover) → bool

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be regenerated when the input

pose is about to change, (for example, if the Mover has special code on the first apply() that is only valid for that one input pose).

C++: protocols::moves::Mover::reinitialize_for_new_input() const –> bool

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

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

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

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

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

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

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

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

set_final_min_pack_min(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeRelax, minpackmin: bool) → None

Change the setting to do a final min/pack/min of all glycan residues or glycan residues set by the selector

at the end of the protocol.

C++: protocols::carbohydrates::GlycanTreeRelax::set_final_min_pack_min(const bool) –> void

set_glycan_relax_rounds(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeRelax, glycan_relax_rounds: int) → None

Override Glycan Relax rounds.

C++: protocols::carbohydrates::GlycanTreeRelax::set_glycan_relax_rounds(unsigned long) –> 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_layer_size(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeRelax, layer_size: int) → None

Set the layer size we will be using. A layer is a set of glycan residues that we will be optimizing.

We work our way through the layers, while the rest of the residues are virtual (not scored).

The distance that make up a layer. If we have a distance of 2, we first model all glycans that are equal to or less than 2 residue distance to the root. We then slide this layer up. So we take all residues that have a distance between 3 and 1, and so on.

C++: protocols::carbohydrates::GlycanTreeRelax::set_layer_size(const 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_quench_mode(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeRelax, quench_mode: bool) → None

Set the protocol to use a quench-like algorithm, where we work on a single glycan tree at a time until

all are modeled.

C++: protocols::carbohydrates::GlycanTreeRelax::set_quench_mode(bool) –> void

set_refine(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeRelax, refine: bool) → None

Set a boolean that we will be refining instead of de-novo modeling.

C++: protocols::carbohydrates::GlycanTreeRelax::set_refine(const bool) –> void

set_rounds(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeRelax, rounds: int) → None

C++: protocols::carbohydrates::GlycanTreeRelax::set_rounds(const unsigned long) –> void

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

Set the scorefunction used for modeling.

C++: protocols::carbohydrates::GlycanTreeRelax::set_scorefxn(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> void

set_selector(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeRelax, selector: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector) → None

Set a residue selector to limit the residues we will be modeling.

If you are using quench mode, the selector will limit the trees to model. So the residues that are true should correspond to the start of the trees you wish to model.

If you wish to limit further, this is not currently supported. So email me and I can add it.

C++: protocols::carbohydrates::GlycanTreeRelax::set_selector(class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>) –> 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_window_size(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeRelax, window_size: int) → None

Set the window size. This is the overlap of the layers during modeling.

The layers are slid down throught the tree of the glycan. The window size represents the overlap in the layers. A window size of 1, means that the last residue (or residues of layer 1) from the last modeling effort, will be used again as part of the next layer. A window size of 0, means that no residues will be re-modeled. Typically, we would want at least a window size of 1.

C++: protocols::carbohydrates::GlycanTreeRelax::set_window_size(const unsigned long) –> void

show(*args, **kwargs)

Overloaded function.

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

C++: protocols::carbohydrates::GlycanTreeRelax::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.carbohydrates.LinkageConformerMover

Bases: pyrosetta.rosetta.protocols.moves.Mover

This code changes all of the dihedrals of a particular glycosidic linkage based on database info,

esentially sampling carbohydrate dihedral conformers of two residues. Randomly samples on any set selector at each apply or (default) samples a linkage conformer for each residue set.

The linkage conformers are carbohydrate residue type and (and linkage oxygen) dependant ie MAN-MAN If data is not known here, by default we sample from restype-independant data. If there are multiple conformers for a given linkage, will randomly select from them.

3 Main Conformer Sampling Strategies:

/ 1) Mean + uniform in X standard deviations (Default) / ->Build conformers using the means of dihedrals + or - some amount within X standard deviations of the mean. / / See Also: / LinkageConformerMover.set_x_standard_deviations / / 2) Mean + probability in X standard deviations / / 3) Idealize / -> Use only means when building linkage conformers. / / See: / LinkageConformerMover.set_idealize_torsions //

__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.carbohydrates.LinkageConformerMover) -> None
2. __init__(self: pyrosetta.rosetta.protocols.carbohydrates.LinkageConformerMover, selector: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector) -> None
3. __init__(self: pyrosetta.rosetta.protocols.carbohydrates.LinkageConformerMover, arg0: pyrosetta.rosetta.protocols.carbohydrates.LinkageConformerMover) -> 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__(self: pyrosetta.rosetta.protocols.carbohydrates.LinkageConformerMover) → str

__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.carbohydrates.LinkageConformerMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::carbohydrates::LinkageConformerMover::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.carbohydrates.LinkageConformerMover, : pyrosetta.rosetta.protocols.carbohydrates.LinkageConformerMover) → pyrosetta.rosetta.protocols.carbohydrates.LinkageConformerMover

C++: protocols::carbohydrates::LinkageConformerMover::operator=(const class protocols::carbohydrates::LinkageConformerMover &) –> class protocols::carbohydrates::LinkageConformerMover &

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

required in the context of the parser/scripting scheme

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

conformer_found(self: pyrosetta.rosetta.protocols.carbohydrates.LinkageConformerMover) → bool

Boolean for if the restype-dependant conformer was found at apply. Resets at successive applies.

C++: protocols::carbohydrates::LinkageConformerMover::conformer_found() const –> bool

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

required in the context of the parser/scripting scheme

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

C++: protocols::carbohydrates::LinkageConformerMover::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

mover_name() → str

C++: protocols::carbohydrates::LinkageConformerMover::mover_name() –> std::string

name() → str

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

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

C++: protocols::carbohydrates::LinkageConformerMover::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

register_options() → None

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

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

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

reinitialize_for_each_job(self: pyrosetta.rosetta.protocols.carbohydrates.LinkageConformerMover) → bool

C++: protocols::carbohydrates::LinkageConformerMover::reinitialize_for_each_job() const –> bool

reinitialize_for_new_input(self: pyrosetta.rosetta.protocols.carbohydrates.LinkageConformerMover) → bool

C++: protocols::carbohydrates::LinkageConformerMover::reinitialize_for_new_input() const –> bool

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

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

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

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

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

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

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

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

set_defaults(self: pyrosetta.rosetta.protocols.carbohydrates.LinkageConformerMover) → None

Set everything to default values, including linkage pairs.

C++: protocols::carbohydrates::LinkageConformerMover::set_defaults() –> void

set_idealize_torsions(self: pyrosetta.rosetta.protocols.carbohydrates.LinkageConformerMover, idealize_torsions: bool) → None

Idealize the torsion angles instead of sampling from SD.

Default FALSE

C++: protocols::carbohydrates::LinkageConformerMover::set_idealize_torsions(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_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_prob_sd_sampling(self: pyrosetta.rosetta.protocols.carbohydrates.LinkageConformerMover, prob_sd_sample: bool) → None

Set whether if we are sampling uniform within the set number of standard deviations or by uniform within the SD.

Default FALSE

C++: protocols::carbohydrates::LinkageConformerMover::set_prob_sd_sampling(bool) –> void

set_residue_selector(self: pyrosetta.rosetta.protocols.carbohydrates.LinkageConformerMover, selector: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector) → None

Set the Selector. Each apply will randomly sample Selector.

If the conformer is not found, will set move status to false. Will optimize the linkage between the residue and the parent residue.

C++: protocols::carbohydrates::LinkageConformerMover::set_residue_selector(class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>) –> void

set_single_resnum(self: pyrosetta.rosetta.protocols.carbohydrates.LinkageConformerMover, pose: pyrosetta.rosetta.core.pose.Pose, resnum: int) → None

Set a single resnum to sample on instead of a movemap.

C++: protocols::carbohydrates::LinkageConformerMover::set_single_resnum(const class core::pose::Pose &, unsigned long) –> 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_use_conformer_population_stats(self: pyrosetta.rosetta.protocols.carbohydrates.LinkageConformerMover, setting: bool) → None

Use conformer population data to weight sampling. Default TRUE.

C++: protocols::carbohydrates::LinkageConformerMover::set_use_conformer_population_stats(const bool) –> void

set_use_sugar_bb_data_if_needed(self: pyrosetta.rosetta.protocols.carbohydrates.LinkageConformerMover, use_sugar_bb: bool) → None

Use phi/psi data if restype-dependant conformer data unavailable.

Will set phi/psi to lowest energy values if idealize is true. Default FALSE

C++: protocols::carbohydrates::LinkageConformerMover::set_use_sugar_bb_data_if_needed(bool) –> void

set_x_standard_deviations(self: pyrosetta.rosetta.protocols.carbohydrates.LinkageConformerMover, standard_deviations: float) → None

Sample within X standard_deviations of the means when building [non-idealized] conformers

C++: protocols::carbohydrates::LinkageConformerMover::set_x_standard_deviations(double) –> void

show(*args, **kwargs)

Overloaded function.

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

C++: protocols::carbohydrates::LinkageConformerMover::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.carbohydrates.SimpleGlycosylateMover

Bases: pyrosetta.rosetta.protocols.moves.Mover

A mover for glycosylation of biological glycosylations. Currently glysolylation is done based on string, not from PDB. Use GlycanRelax to model the resulting glycosylation!.

Single Glycosylation:

If a single glycosylation is passed, it will glycosylate all positions set with this glycan.

Multiple Glycosylations:

If multiple glycosylations are passed, will randomly select from these on apply to sample glycan hetergenecity. see glyco.set_weights to set weights for these glycans to sample non-random heterogenecity in the glycoform.

The site should be ASN for N-linked glycosylations OR SER/THR for O-linked glycosylations

If a glycan already exists, will strip off the current glycan by default. set glyco.set_strip_existing_glycans( false ) to branch off existing glycans instead of deleting them.

see CreateGlycoSiteMover to create glyco sites (as N-linked glycosylations will need a specific motif to be biological)

Will randomly select from set positions and glycosylate all positions set.

Glycosylations:

1. If your name ends with .iupac or .gws (GlycoWorkBench), will try to load the file
2. Next, it will check the short names in the Rosetta database for your string. If the string is in common_names.txt, will load the paired iupac sequence. See database/chemical/carbohydrates/common_glycans/common_names.txt for accepted short names.

Names include man3, man5, and man9.

3. If the name is not found, will attempt to build the glycan as an iupac sequence from the string.

TODO JAB: Add Glycosylate from pdb/cif files in addition to IUPAC and short names.

No current RosettaCarbohydrate functionality to load from PDB/CIF and attach to an existing pose..

__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.carbohydrates.SimpleGlycosylateMover) -> None
2. __init__(self: pyrosetta.rosetta.protocols.carbohydrates.SimpleGlycosylateMover, arg0: pyrosetta.rosetta.protocols.carbohydrates.SimpleGlycosylateMover) -> 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__(self: pyrosetta.rosetta.protocols.carbohydrates.SimpleGlycosylateMover) → str

__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.carbohydrates.SimpleGlycosylateMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::carbohydrates::SimpleGlycosylateMover::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.carbohydrates.SimpleGlycosylateMover, : pyrosetta.rosetta.protocols.carbohydrates.SimpleGlycosylateMover) → pyrosetta.rosetta.protocols.carbohydrates.SimpleGlycosylateMover

C++: protocols::carbohydrates::SimpleGlycosylateMover::operator=(const class protocols::carbohydrates::SimpleGlycosylateMover &) –> class protocols::carbohydrates::SimpleGlycosylateMover &

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

required in the context of the parser/scripting scheme

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

required in the context of the parser/scripting scheme

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

C++: protocols::carbohydrates::SimpleGlycosylateMover::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

mover_name() → str

C++: protocols::carbohydrates::SimpleGlycosylateMover::mover_name() –> std::string

name() → str

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

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

C++: protocols::carbohydrates::SimpleGlycosylateMover::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

register_options() → None

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

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

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

reinitialize_for_each_job(self: pyrosetta.rosetta.protocols.moves.Mover) → bool

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be freshly regenerated on

each use.

C++: protocols::moves::Mover::reinitialize_for_each_job() const –> bool

reinitialize_for_new_input(self: pyrosetta.rosetta.protocols.moves.Mover) → bool

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be regenerated when the input

pose is about to change, (for example, if the Mover has special code on the first apply() that is only valid for that one input pose).

C++: protocols::moves::Mover::reinitialize_for_new_input() const –> bool

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

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

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

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

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

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

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

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

set_glycosylation(self: pyrosetta.rosetta.protocols.carbohydrates.SimpleGlycosylateMover, iupac_or_common_string: str) → None

Set the glycosylation that will happen.

See database/chemical/carbohydrates/common_glycans for common names. Names include man3, man5, and man9.

Can also use full iupac names.

See also: glycosylate.set_glycosylation_weights

C++: protocols::carbohydrates::SimpleGlycosylateMover::set_glycosylation(const class std::basic_string<char> &) –> void

set_glycosylation_weights(self: pyrosetta.rosetta.protocols.carbohydrates.SimpleGlycosylateMover, weights: pyrosetta.rosetta.utility.vector1_double) → None

Set weights for potential glycosylation if more than one is set.

C++: protocols::carbohydrates::SimpleGlycosylateMover::set_glycosylation_weights(const class utility::vector1<double, class std::allocator<double> > &) –> void

set_glycosylations(self: pyrosetta.rosetta.protocols.carbohydrates.SimpleGlycosylateMover, iupac_or_common_strings: pyrosetta.rosetta.utility.vector1_std_string) → None

Set possible glycosylations - the mover will randomly pick these on apply

See database/chemical/carbohydrates/common_glycans for accepted names. Names include man3, man5, and man9.

Can also use full iupac names.

See also: glycosylate.set_glycosylation_weights

C++: protocols::carbohydrates::SimpleGlycosylateMover::set_glycosylations(const class utility::vector1<class std::basic_string<char>, class std::allocator<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_position(self: pyrosetta.rosetta.protocols.carbohydrates.SimpleGlycosylateMover, position: int) → None

Set a single resnum position

C++: protocols::carbohydrates::SimpleGlycosylateMover::set_position(unsigned long) –> void

set_residue_selector(self: pyrosetta.rosetta.protocols.carbohydrates.SimpleGlycosylateMover, selector: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector) → None

Set positions from a Residue Selector.

C++: protocols::carbohydrates::SimpleGlycosylateMover::set_residue_selector(class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>) –> void

set_strip_existing_glycans(self: pyrosetta.rosetta.protocols.carbohydrates.SimpleGlycosylateMover, strip_existing: bool) → None

This sets whether if we already have a glycan at a position, whether to extend it or delete the existing glycan.

Advanced functionality - use with caution.

Not yet work.

C++: protocols::carbohydrates::SimpleGlycosylateMover::set_strip_existing_glycans(bool) –> void

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

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

show(*args, **kwargs)

Overloaded function.

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

C++: protocols::carbohydrates::SimpleGlycosylateMover::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

pyrosetta.rosetta.protocols.carbohydrates.get_all_glycans_and_neighbor_res_task_factory(*args, **kwargs)

Overloaded function.

1. get_all_glycans_and_neighbor_res_task_factory(subset: pyrosetta.rosetta.utility.vector1_bool) -> pyrosetta.rosetta.core.pack.task.TaskFactory
2. get_all_glycans_and_neighbor_res_task_factory(subset: pyrosetta.rosetta.utility.vector1_bool, pack_distance: float) -> pyrosetta.rosetta.core.pack.task.TaskFactory
3. get_all_glycans_and_neighbor_res_task_factory(subset: pyrosetta.rosetta.utility.vector1_bool, pack_distance: float, read_resfile: bool) -> pyrosetta.rosetta.core.pack.task.TaskFactory

Get a TaskFactory of all residues in the subset and neighboring residues.

Operations:

InitializeFromCommandline ReadResFile? If option given on cmd-line, returns TF up to this. NeighborhoodResidueSelector/OperateOnResidueSubset RestrictRepacking/PreventRepacking

C++: protocols::carbohydrates::get_all_glycans_and_neighbor_res_task_factory(const class utility::vector1<bool, class std::allocator<bool> > &, double, bool) –> class std::shared_ptr<class core::pack::task::TaskFactory>