carbohydrates

Bindings for protocols::carbohydrates namespace

class pyrosetta.rosetta.protocols.carbohydrates.CreateGlycanSequonMover

Bases: pyrosetta.rosetta.protocols.moves.Mover

Mutates residues to create a potential glycosylation site using known sequence motifs of N- or C- linked glycans. Includes options for Enhanced Sequons for N-linked glycans that have been shown to have higher rates of glycosylation

as well as other positions that have been shown to influence the glycosylation chemistry.

Creates the glycan sequence motif around (and including) the potential glycosylation site. If the site could not be created due to the position being too close to the beginning or end of the sequence, Will set the mover status to fail, do not retry.

Creates an N-Linked Sequence Motif by default using the non-enhanced motif. This can be changed in options.

apply(self: pyrosetta.rosetta.protocols.carbohydrates.CreateGlycanSequonMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

Apply the mover

If the sequon could not be created (for example the length of the sequon is longer than the protein/etc. It will set mover_failed_do_not retry. It is your responsiblity to catch this and do whatever you wish with it.

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

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

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

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

required in the context of the parser/scripting scheme

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

required in the context of the parser/scripting scheme

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

C++: protocols::carbohydrates::CreateGlycanSequonMover::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::CreateGlycanSequonMover::mover_name() –> std::string

name() → str

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

parse_my_tag(self: pyrosetta.rosetta.protocols.carbohydrates.CreateGlycanSequonMover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap, filters: pyrosetta.rosetta.std.map_std_string_std_shared_ptr_protocols_filters_Filter_t, movers: pyrosetta.rosetta.std.map_const_std_string_std_shared_ptr_protocols_moves_Mover_t, pose: pyrosetta.rosetta.core.pose.Pose) → None

parse XML tag (to use this Mover in Rosetta Scripts)

C++: protocols::carbohydrates::CreateGlycanSequonMover::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &, const class std::map<class std::basic_string<char>, class std::shared_ptr<class protocols::filters::Filter>, struct std::less<class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, class std::shared_ptr<class protocols::filters::Filter> > > > &, const class std::map<const class std::basic_string<char>, class std::shared_ptr<class protocols::moves::Mover>, struct std::less<const class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, class std::shared_ptr<class protocols::moves::Mover> > > > &, const class core::pose::Pose &) –> void

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

C++: protocols::carbohydrates::CreateGlycanSequonMover::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_design_neighbors(self: pyrosetta.rosetta.protocols.carbohydrates.CreateGlycanSequonMover, design_neighbors: bool) → None

Should we design neighbors of the motif? Default is False.

C++: protocols::carbohydrates::CreateGlycanSequonMover::set_design_neighbors(const bool) –> void

set_design_x_positions(self: pyrosetta.rosetta.protocols.carbohydrates.CreateGlycanSequonMover, design_x_positions: bool) → None

If there is an X in the motif, should we design it or leave it alone.

Default is to leave it alone.

C++: protocols::carbohydrates::CreateGlycanSequonMover::set_design_x_positions(const bool) –> void

set_glycan_sequon_type(self: pyrosetta.rosetta.protocols.carbohydrates.CreateGlycanSequonMover, sequon: pyrosetta.rosetta.protocols.carbohydrates.GlycanSequon) → None

Set any sequon type

C++: protocols::carbohydrates::CreateGlycanSequonMover::set_glycan_sequon_type(enum protocols::carbohydrates::GlycanSequon) –> void

set_glycosylation_position(self: pyrosetta.rosetta.protocols.carbohydrates.CreateGlycanSequonMover, position: int, pose: pyrosetta.rosetta.core.pose.Pose) → None

Set the target glycosylation position for which the sequence motif will be created around.

If this is in beginning or end of protein and could not be created, will set fail do not retry mover status.

C++: protocols::carbohydrates::CreateGlycanSequonMover::set_glycosylation_position(unsigned long, const class core::pose::Pose &) –> 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_pack_distance(self: pyrosetta.rosetta.protocols.carbohydrates.CreateGlycanSequonMover, pack_distance: float) → None

Set the neighbor detection distance for any packing/design of neighbors.

C++: protocols::carbohydrates::CreateGlycanSequonMover::set_pack_distance(const double) –> void

set_pack_neighbors(self: pyrosetta.rosetta.protocols.carbohydrates.CreateGlycanSequonMover, pack_neighbors: bool) → None

Should we pack neighbors of the motif? Default is True

C++: protocols::carbohydrates::CreateGlycanSequonMover::set_pack_neighbors(const bool) –> void

set_pack_rounds(self: pyrosetta.rosetta.protocols.carbohydrates.CreateGlycanSequonMover, pack_rounds: int) → None

Number of rounds to run packing/design. Default is 5

C++: protocols::carbohydrates::CreateGlycanSequonMover::set_pack_rounds(unsigned long) –> void

set_positions_as_start_of_sequon(self: pyrosetta.rosetta.protocols.carbohydrates.CreateGlycanSequonMover, positions_as_start: bool) → None

Instead of having each position be the glycosylation position, have each position be the start of the sequon.

This just makes using ResidueSelectors with this class a bit easier if needed.

This only effects the basic_enhanced and best_enhanced sequons!

C++: protocols::carbohydrates::CreateGlycanSequonMover::set_positions_as_start_of_sequon(bool) –> void

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

Set a number of positions using a residue selector.

The positions are where glycosylation is intended to occur.

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

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

C++: protocols::carbohydrates::CreateGlycanSequonMover::set_score_function(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> 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_basic_enhanced_n_linked_sequon(self: pyrosetta.rosetta.protocols.carbohydrates.CreateGlycanSequonMover, enhanced: bool) → None

Set to use the enhanced sequon which has been shown to result in higher rates of glycosylation and slightly lower complex types as the glycan site. (Aromatics at n+2)

DEFAULT: False

REFS:

“Enhanced Aromatic Sequons Increase Oligosaccharyltransferase Glycosylation Efficiency and Glycan Homogeneity”

Murray et al., 2015, Chemistry & Biology 22, 1052–1062 http://dx.doi.org/10.1016/j.chembiol.2015.06.017

“Residues Comprising the Enhanced Aromatic Sequon Influence Protein N‐Glycosylation Efficiency”

Yen-Wen Huang, J. Am. Chem. Soc. 2017, 139, 12947−12955 DOI: 10.1021/jacs.7b03868

C++: protocols::carbohydrates::CreateGlycanSequonMover::set_use_basic_enhanced_n_linked_sequon(bool) –> void

show(*args, **kwargs)

Overloaded function.

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

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

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

parse_my_tag(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanRelaxMover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap, filters: pyrosetta.rosetta.std.map_std_string_std_shared_ptr_protocols_filters_Filter_t, movers: pyrosetta.rosetta.std.map_const_std_string_std_shared_ptr_protocols_moves_Mover_t, pose: pyrosetta.rosetta.core.pose.Pose) → None

parse XML tag (to use this Mover in Rosetta Scripts)

C++: protocols::carbohydrates::GlycanRelaxMover::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &, const class std::map<class std::basic_string<char>, class std::shared_ptr<class protocols::filters::Filter>, struct std::less<class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, class std::shared_ptr<class protocols::filters::Filter> > > > &, const class std::map<const class std::basic_string<char>, class std::shared_ptr<class protocols::moves::Mover>, struct std::less<const class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, class std::shared_ptr<class protocols::moves::Mover> > > > &, const class core::pose::Pose &) –> void

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.GlycanSequon

Bases: pybind11_builtins.pybind11_object

Members:

n_linked_typical

n_linked_basic_enhanced

n_linked_best_enhanced

c_linked_NxC

c_linked_WxxW

c_linked_WSTxC

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

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

parse_my_tag(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeMinMover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap, filters: pyrosetta.rosetta.std.map_std_string_std_shared_ptr_protocols_filters_Filter_t, movers: pyrosetta.rosetta.std.map_const_std_string_std_shared_ptr_protocols_moves_Mover_t, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::carbohydrates::GlycanTreeMinMover::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &, const class std::map<class std::basic_string<char>, class std::shared_ptr<class protocols::filters::Filter>, struct std::less<class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, class std::shared_ptr<class protocols::filters::Filter> > > > &, const class std::map<const class std::basic_string<char>, class std::shared_ptr<class protocols::moves::Mover>, struct std::less<const class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, class std::shared_ptr<class protocols::moves::Mover> > > > &, const class core::pose::Pose &) –> void

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.minimization_packing.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::minimization_packing::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.

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

parse_my_tag(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeRelax, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap, filters: pyrosetta.rosetta.std.map_std_string_std_shared_ptr_protocols_filters_Filter_t, movers: pyrosetta.rosetta.std.map_const_std_string_std_shared_ptr_protocols_moves_Mover_t, pose: pyrosetta.rosetta.core.pose.Pose) → None

parse XML tag (to use this Mover in Rosetta Scripts)

C++: protocols::carbohydrates::GlycanTreeRelax::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &, const class std::map<class std::basic_string<char>, class std::shared_ptr<class protocols::filters::Filter>, struct std::less<class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, class std::shared_ptr<class protocols::filters::Filter> > > > &, const class std::map<const class std::basic_string<char>, class std::shared_ptr<class protocols::moves::Mover>, struct std::less<const class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, class std::shared_ptr<class protocols::moves::Mover> > > > &, const class core::pose::Pose &) –> void

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.IdealizeAnomericHydrogens

Bases: pyrosetta.rosetta.protocols.moves.Mover

This code sets all the anomeric hydrogen positions based on the input structure

apply(self: pyrosetta.rosetta.protocols.carbohydrates.IdealizeAnomericHydrogens, pose: pyrosetta.rosetta.core.pose.Pose) → None

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

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

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

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

required in the context of the parser/scripting scheme

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

required in the context of the parser/scripting scheme

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

C++: protocols::carbohydrates::IdealizeAnomericHydrogens::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::IdealizeAnomericHydrogens::mover_name() –> std::string

name() → str

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

parse_my_tag(self: pyrosetta.rosetta.protocols.moves.Mover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap, filters: pyrosetta.rosetta.std.map_std_string_std_shared_ptr_protocols_filters_Filter_t, movers: pyrosetta.rosetta.std.map_const_std_string_std_shared_ptr_protocols_moves_Mover_t, pose: pyrosetta.rosetta.core.pose.Pose) → None

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

C++: protocols::moves::Mover::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &, const class std::map<class std::basic_string<char>, class std::shared_ptr<class protocols::filters::Filter>, struct std::less<class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, class std::shared_ptr<class protocols::filters::Filter> > > > &, const class std::map<const class std::basic_string<char>, class std::shared_ptr<class protocols::moves::Mover>, struct std::less<const class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, class std::shared_ptr<class protocols::moves::Mover> > > > &, const class core::pose::Pose &) –> void

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

C++: protocols::carbohydrates::IdealizeAnomericHydrogens::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_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.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 //

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

parse_my_tag(self: pyrosetta.rosetta.protocols.carbohydrates.LinkageConformerMover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap, filters: pyrosetta.rosetta.std.map_std_string_std_shared_ptr_protocols_filters_Filter_t, movers: pyrosetta.rosetta.std.map_const_std_string_std_shared_ptr_protocols_moves_Mover_t, pose: pyrosetta.rosetta.core.pose.Pose) → None

parse XML tag (to use this Mover in Rosetta Scripts)

C++: protocols::carbohydrates::LinkageConformerMover::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &, const class std::map<class std::basic_string<char>, class std::shared_ptr<class protocols::filters::Filter>, struct std::less<class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, class std::shared_ptr<class protocols::filters::Filter> > > > &, const class std::map<const class std::basic_string<char>, class std::shared_ptr<class protocols::moves::Mover>, struct std::less<const class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, class std::shared_ptr<class protocols::moves::Mover> > > > &, const class core::pose::Pose &) –> void

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.QuenchDirection

Bases: pybind11_builtins.pybind11_object

Members:

forward

backward

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

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

parse_my_tag(self: pyrosetta.rosetta.protocols.carbohydrates.SimpleGlycosylateMover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap, filters: pyrosetta.rosetta.std.map_std_string_std_shared_ptr_protocols_filters_Filter_t, movers: pyrosetta.rosetta.std.map_const_std_string_std_shared_ptr_protocols_moves_Mover_t, pose: pyrosetta.rosetta.core.pose.Pose) → None

parse XML tag (to use this Mover in Rosetta Scripts)

C++: protocols::carbohydrates::SimpleGlycosylateMover::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &, const class std::map<class std::basic_string<char>, class std::shared_ptr<class protocols::filters::Filter>, struct std::less<class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, class std::shared_ptr<class protocols::filters::Filter> > > > &, const class std::map<const class std::basic_string<char>, class std::shared_ptr<class protocols::moves::Mover>, struct std::less<const class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, class std::shared_ptr<class protocols::moves::Mover> > > > &, const class core::pose::Pose &) –> void

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.create_sequons() → pyrosetta.rosetta.std.map_protocols_carbohydrates_GlycanSequon_std_string

Create a map of the name and full sequon

C++: protocols::carbohydrates::create_sequons() –> class std::map<enum protocols::carbohydrates::GlycanSequon, std::string, struct std::less<enum protocols::carbohydrates::GlycanSequon>, class std::allocator<struct std::pair<const enum protocols::carbohydrates::GlycanSequon, std::string > > >

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>