carbohydrates¶

Bindings for protocols::carbohydrates namespace

class pyrosetta.rosetta.protocols.carbohydrates.CreateGlycanSequonMover¶

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

Supported in JD2. Will attempt to grab additional poses until a nullptr is returned.

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

static mover_name() → str¶: C++: protocols::carbohydrates::CreateGlycanSequonMover::mover_name() –> std::string

static 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) → 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 &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.carbohydrates.CreateGlycanSequonMover, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide the citation.

C++: protocols::carbohydrates::CreateGlycanSequonMover::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::carbohydrates::CreateGlycanSequonMover::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

static 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¶: 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 std::string &) –> 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¶

Set the ‘type’ string

C++: protocols::moves::Mover::set_type(const std::string &) –> 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.

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

C++: protocols::carbohydrates::CreateGlycanSequonMover::show(std::ostream &) 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.

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

Set the ‘type’ string

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

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

Get the set ‘type’ string

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

class pyrosetta.rosetta.protocols.carbohydrates.CreateGlycanSequonMoverCreator¶

Bases: MoverCreator

assign(self: pyrosetta.rosetta.protocols.carbohydrates.CreateGlycanSequonMoverCreator, : pyrosetta.rosetta.protocols.carbohydrates.CreateGlycanSequonMoverCreator) → pyrosetta.rosetta.protocols.carbohydrates.CreateGlycanSequonMoverCreator¶: C++: protocols::carbohydrates::CreateGlycanSequonMoverCreator::operator=(const class protocols::carbohydrates::CreateGlycanSequonMoverCreator &) –> class protocols::carbohydrates::CreateGlycanSequonMoverCreator &

create_mover(self: pyrosetta.rosetta.protocols.carbohydrates.CreateGlycanSequonMoverCreator) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::carbohydrates::CreateGlycanSequonMoverCreator::create_mover() const –> class std::shared_ptr<class protocols::moves::Mover>

keyname(self: pyrosetta.rosetta.protocols.carbohydrates.CreateGlycanSequonMoverCreator) → str¶: C++: protocols::carbohydrates::CreateGlycanSequonMoverCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.carbohydrates.CreateGlycanSequonMoverCreator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::carbohydrates::CreateGlycanSequonMoverCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.protocols.carbohydrates.GlycanSampler¶

Bases: 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 GlycanTreeMinMover .05 PackRotamersMover

Supports Symmetry

apply(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanSampler, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::carbohydrates::GlycanSampler::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanSampler, : pyrosetta.rosetta.protocols.carbohydrates.GlycanSampler) → pyrosetta.rosetta.protocols.carbohydrates.GlycanSampler¶: C++: protocols::carbohydrates::GlycanSampler::operator=(const class protocols::carbohydrates::GlycanSampler &) –> class protocols::carbohydrates::GlycanSampler &

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

required in the context of the parser/scripting scheme

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

force_total_rounds(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanSampler, total_rounds: int) → None¶

This allows us to force a number of rounds instead of doing rounds*glycan residues

C++: protocols::carbohydrates::GlycanSampler::force_total_rounds(unsigned long) –> void

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

required in the context of the parser/scripting scheme

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

Supported in JD2. Will attempt to grab additional poses until a nullptr is returned.

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_glycan_sampler_rounds(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanSampler) → int¶

Get the number of glycan sampler rounds this class is set to run.

C++: protocols::carbohydrates::GlycanSampler::get_glycan_sampler_rounds() –> unsigned long

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

idealize_glycan_residues(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanSampler, pose: pyrosetta.rosetta.core.pose.Pose, tree_subset: pyrosetta.rosetta.utility.vector1_unsigned_long) → None¶

Attempt to idealize all residues in of a set of trees. Experimental!

C++: protocols::carbohydrates::GlycanSampler::idealize_glycan_residues(class core::pose::Pose &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> void

info(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.list_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

static mover_name() → str¶: C++: protocols::carbohydrates::GlycanSampler::mover_name() –> std::string

static name() → str¶: C++: protocols::moves::Mover::name() –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanSampler, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

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

C++: protocols::carbohydrates::GlycanSampler::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanSampler, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide the citation.

C++: protocols::carbohydrates::GlycanSampler::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::carbohydrates::GlycanSampler::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

randomize_glycan_torsions(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanSampler, 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::GlycanSampler::randomize_glycan_torsions(class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &) const –> void

static 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.GlycanSampler) → bool¶: C++: protocols::carbohydrates::GlycanSampler::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¶: 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 std::string &) –> void

set_defaults(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanSampler) → None¶: C++: protocols::carbohydrates::GlycanSampler::set_defaults() –> void

set_inner_bb_cycles(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanSampler, inner_bb_cycles: int) → None¶

Set the number of inner cycles for BB sampling through small/sugarBB.: This is multiplied by the number of glycan residues Default 1

C++: protocols::carbohydrates::GlycanSampler::set_inner_bb_cycles(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_kt(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanSampler, kt: float) → None¶: C++: protocols::carbohydrates::GlycanSampler::set_kt(double) –> void

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

set to minimize ring torsions during minimzation. Default false.

C++: protocols::carbohydrates::GlycanSampler::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.GlycanSampler, 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::GlycanSampler::set_population_based_conformer_sampling(bool) –> void

set_protein_linkage_prob_sampling(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanSampler, root_probs: bool) → None¶

Set Conformer Sampling through probabilities at the linkage to the protein only

C++: protocols::carbohydrates::GlycanSampler::set_protein_linkage_prob_sampling(bool) –> void

set_randomize_first(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanSampler, randomize_first: bool) → None¶

Set the protocol to randomize torsions before beginning.: This actually helps get to lower energy models. Default True. If doing refinement, this is automatically turned off.

C++: protocols::carbohydrates::GlycanSampler::set_randomize_first(bool) –> void

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

Set refinement mode instead of denovo modeling mode.

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

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

Set the Movemap

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

set_rounds(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanSampler, 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::GlycanSampler::set_rounds(unsigned long) –> void

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

Set the ScoreFunction

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

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

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

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

set_taskfactory(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanSampler, 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::GlycanSampler::set_taskfactory(class std::shared_ptr<const class core::pack::task::TaskFactory>) –> void

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

Set the ‘type’ string

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

set_use_gaussian_sampling(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanSampler, use_gaussian_sampling: bool) → None¶

Set whether if we are sampling torsions uniformly within an SD for the LinkageConformerMover (false): or sampling the gaussian (true). Default false

C++: protocols::carbohydrates::GlycanSampler::set_use_gaussian_sampling(bool) –> void

set_use_shear(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanSampler, use_shear: bool) → None¶

Set the protocol to use the refactored Shear Mover for glycan torsions at 10 % probability.: Default false.

C++: protocols::carbohydrates::GlycanSampler::set_use_shear(bool) –> void

show(*args, **kwargs)¶

Overloaded function.

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

C++: protocols::carbohydrates::GlycanSampler::show(std::ostream &) 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.

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

Set the ‘type’ string

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

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

Get the set ‘type’ string

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

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

Use Cartesian minimization instead of Dihedral minimization.: Default (for now) is dihedral.

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

class pyrosetta.rosetta.protocols.carbohydrates.GlycanSamplerCreator¶

Bases: MoverCreator

assign(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanSamplerCreator, : pyrosetta.rosetta.protocols.carbohydrates.GlycanSamplerCreator) → pyrosetta.rosetta.protocols.carbohydrates.GlycanSamplerCreator¶: C++: protocols::carbohydrates::GlycanSamplerCreator::operator=(const class protocols::carbohydrates::GlycanSamplerCreator &) –> class protocols::carbohydrates::GlycanSamplerCreator &

create_mover(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanSamplerCreator) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::carbohydrates::GlycanSamplerCreator::create_mover() const –> class std::shared_ptr<class protocols::moves::Mover>

keyname(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanSamplerCreator) → str¶: C++: protocols::carbohydrates::GlycanSamplerCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanSamplerCreator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::carbohydrates::GlycanSamplerCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.protocols.carbohydrates.GlycanSequon¶

Bases: pybind11_object

Members:

n_linked_typical

n_linked_basic_enhanced

n_linked_best_enhanced

c_linked_NxC

c_linked_WxxW

c_linked_WSTxC

c_linked_NxC = <GlycanSequon.c_linked_NxC: 4>¶

c_linked_WSTxC = <GlycanSequon.c_linked_WSTxC: 6>¶

c_linked_WxxW = <GlycanSequon.c_linked_WxxW: 5>¶

n_linked_basic_enhanced = <GlycanSequon.n_linked_basic_enhanced: 2>¶

n_linked_best_enhanced = <GlycanSequon.n_linked_best_enhanced: 3>¶

n_linked_typical = <GlycanSequon.n_linked_typical: 1>¶

property name¶

property value¶

class pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeMinMover¶

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

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

Supported in JD2. Will attempt to grab additional poses until a nullptr is returned.

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

static 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) → None¶: C++: protocols::carbohydrates::GlycanTreeMinMover::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeMinMover, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide the citation.

C++: protocols::carbohydrates::GlycanTreeMinMover::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::carbohydrates::GlycanTreeMinMover::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

static 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¶: 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 std::string &) –> 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: 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¶

Set the ‘type’ string

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

show(*args, **kwargs)¶

Overloaded function.

show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None
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(std::ostream &) 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.

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

Set the ‘type’ string

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

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

Get the set ‘type’ string

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

class pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeMinMoverCreator¶

Bases: MoverCreator

assign(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeMinMoverCreator, : pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeMinMoverCreator) → pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeMinMoverCreator¶: C++: protocols::carbohydrates::GlycanTreeMinMoverCreator::operator=(const class protocols::carbohydrates::GlycanTreeMinMoverCreator &) –> class protocols::carbohydrates::GlycanTreeMinMoverCreator &

create_mover(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeMinMoverCreator) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::carbohydrates::GlycanTreeMinMoverCreator::create_mover() const –> class std::shared_ptr<class protocols::moves::Mover>

keyname(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeMinMoverCreator) → str¶: C++: protocols::carbohydrates::GlycanTreeMinMoverCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeMinMoverCreator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::carbohydrates::GlycanTreeMinMoverCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeModeler¶

Bases: Mover

A protocol for optimizing glycan trees using the GlycanSampler 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. the GlycanSampler 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.GlycanTreeModeler, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Apply the mover

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

assign(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeModeler, : pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeModeler) → pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeModeler¶: C++: protocols::carbohydrates::GlycanTreeModeler::operator=(const class protocols::carbohydrates::GlycanTreeModeler &) –> class protocols::carbohydrates::GlycanTreeModeler &

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

required in the context of the parser/scripting scheme

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

required in the context of the parser/scripting scheme

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

Supported in JD2. Will attempt to grab additional poses until a nullptr is returned.

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

static mover_name() → str¶: C++: protocols::carbohydrates::GlycanTreeModeler::mover_name() –> std::string

static name() → str¶: C++: protocols::moves::Mover::name() –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeModeler, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

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

C++: protocols::carbohydrates::GlycanTreeModeler::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeModeler, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide the citation.

C++: protocols::carbohydrates::GlycanTreeModeler::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::carbohydrates::GlycanTreeModeler::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

static 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¶: 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 std::string &) –> void

set_final_min_pack_min(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeModeler, 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::GlycanTreeModeler::set_final_min_pack_min(const bool) –> void

set_force_virts_for_refinement(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeModeler, force_virts: bool) → None¶

Refinement now models layers in the context of the full glycan tree.

Turn this option on to use non-scored residues (virtuals) at the ends of the tree that are not being modeled.: This is how the de-novo protocol works.

C++: protocols::carbohydrates::GlycanTreeModeler::set_force_virts_for_refinement(bool) –> void

set_glycan_sampler_kt(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeModeler, kT: float) → None¶

Override the GlycanSampler KT

C++: protocols::carbohydrates::GlycanTreeModeler::set_glycan_sampler_kt(double) –> void

set_glycan_sampler_rounds(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeModeler, glycan_sampler_rounds: int) → None¶

Override Glycan Relax rounds.

C++: protocols::carbohydrates::GlycanTreeModeler::set_glycan_sampler_rounds(unsigned long) –> void

set_hybrid_protocol(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeModeler, hybrid_protocol: bool) → None¶

Set to use an experimental protocol where we build out the glycans, but re-model the full tree during the building process: Default false

C++: protocols::carbohydrates::GlycanTreeModeler::set_hybrid_protocol(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_layer_size(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeModeler, 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 (downstream) 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::GlycanTreeModeler::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_protein_linkage_prob_sampling(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeModeler, root_probs: bool) → None¶

Set Conformer Sampling through probabilities at the linkage to the protein only

C++: protocols::carbohydrates::GlycanTreeModeler::set_protein_linkage_prob_sampling(bool) –> void

set_quench_mode(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeModeler, 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::GlycanTreeModeler::set_quench_mode(bool) –> void

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

Set a boolean that we will be refining instead of de-novo modeling.: This also makes it so that modeling is done in the context of the full glycan tree and no virtual residues are used.

If you would like to change this behavior, use the function set_force_virts_for_refinement.

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

set_rounds(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeModeler, rounds: int) → None¶: C++: protocols::carbohydrates::GlycanTreeModeler::set_rounds(const unsigned long) –> void

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

Set the scorefunction used for modeling.

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

set_selector(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeModeler, 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::GlycanTreeModeler::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¶

Set the ‘type’ string

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

set_use_conformer_probabilities(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeModeler, conformer_probs: bool) → None¶

Set the LinkageConformer to use probabilites.

C++: protocols::carbohydrates::GlycanTreeModeler::set_use_conformer_probabilities(bool) –> void

set_use_gaussian_sampling(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeModeler, gaussian_sampling: bool) → None¶

Set whether if we are sampling torsions uniformly within an SD for the LinkageConformerMover (false): or sampling the gaussian (true). Default false

C++: protocols::carbohydrates::GlycanTreeModeler::set_use_gaussian_sampling(bool) –> void

set_use_shear(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeModeler, use_shear: bool) → None¶: C++: protocols::carbohydrates::GlycanTreeModeler::set_use_shear(bool) –> void

set_window_size(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeModeler, 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::GlycanTreeModeler::set_window_size(const unsigned long) –> void

show(*args, **kwargs)¶

Overloaded function.

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

C++: protocols::carbohydrates::GlycanTreeModeler::show(std::ostream &) 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.

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

Set the ‘type’ string

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

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

Get the set ‘type’ string

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

class pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeModelerCreator¶

Bases: MoverCreator

assign(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeModelerCreator, : pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeModelerCreator) → pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeModelerCreator¶: C++: protocols::carbohydrates::GlycanTreeModelerCreator::operator=(const class protocols::carbohydrates::GlycanTreeModelerCreator &) –> class protocols::carbohydrates::GlycanTreeModelerCreator &

create_mover(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeModelerCreator) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::carbohydrates::GlycanTreeModelerCreator::create_mover() const –> class std::shared_ptr<class protocols::moves::Mover>

keyname(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeModelerCreator) → str¶: C++: protocols::carbohydrates::GlycanTreeModelerCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.carbohydrates.GlycanTreeModelerCreator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::carbohydrates::GlycanTreeModelerCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.protocols.carbohydrates.IdealizeAnomericHydrogens¶

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

Supported in JD2. Will attempt to grab additional poses until a nullptr is returned.

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

static mover_name() → str¶: C++: protocols::carbohydrates::IdealizeAnomericHydrogens::mover_name() –> std::string

static name() → str¶: C++: protocols::moves::Mover::name() –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.carbohydrates.IdealizeAnomericHydrogens, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::carbohydrates::IdealizeAnomericHydrogens::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.carbohydrates.IdealizeAnomericHydrogens, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide the citation.

C++: protocols::carbohydrates::IdealizeAnomericHydrogens::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::carbohydrates::IdealizeAnomericHydrogens::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

static 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¶: 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 std::string &) –> 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¶

Set the ‘type’ string

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

show(*args, **kwargs)¶

Overloaded function.

show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None
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(std::ostream &) 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.

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

Set the ‘type’ string

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

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

Get the set ‘type’ string

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

class pyrosetta.rosetta.protocols.carbohydrates.IdealizeAnomericHydrogensCreator¶

Bases: MoverCreator

assign(self: pyrosetta.rosetta.protocols.carbohydrates.IdealizeAnomericHydrogensCreator, : pyrosetta.rosetta.protocols.carbohydrates.IdealizeAnomericHydrogensCreator) → pyrosetta.rosetta.protocols.carbohydrates.IdealizeAnomericHydrogensCreator¶: C++: protocols::carbohydrates::IdealizeAnomericHydrogensCreator::operator=(const class protocols::carbohydrates::IdealizeAnomericHydrogensCreator &) –> class protocols::carbohydrates::IdealizeAnomericHydrogensCreator &

create_mover(self: pyrosetta.rosetta.protocols.carbohydrates.IdealizeAnomericHydrogensCreator) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::carbohydrates::IdealizeAnomericHydrogensCreator::create_mover() const –> class std::shared_ptr<class protocols::moves::Mover>

keyname(self: pyrosetta.rosetta.protocols.carbohydrates.IdealizeAnomericHydrogensCreator) → str¶: C++: protocols::carbohydrates::IdealizeAnomericHydrogensCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.carbohydrates.IdealizeAnomericHydrogensCreator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::carbohydrates::IdealizeAnomericHydrogensCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.protocols.carbohydrates.LinkageConformerMover¶

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

Supported in JD2. Will attempt to grab additional poses until a nullptr is returned.

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

static mover_name() → str¶: C++: protocols::carbohydrates::LinkageConformerMover::mover_name() –> std::string

static 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) → 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 &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.carbohydrates.LinkageConformerMover, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide the citation.

C++: protocols::carbohydrates::LinkageConformerMover::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::carbohydrates::LinkageConformerMover::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

static 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¶: 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 std::string &) –> 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_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_root_prob_sampling(self: pyrosetta.rosetta.protocols.carbohydrates.LinkageConformerMover, root_prob_sampling: bool) → None¶

Set the LCM to use probabilities for the ASN (or other residue) linkage.: Default False

C++: protocols::carbohydrates::LinkageConformerMover::set_root_prob_sampling(bool) –> 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¶

Set the ‘type’ string

C++: protocols::moves::Mover::set_type(const std::string &) –> 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_gaussian_sampling(self: pyrosetta.rosetta.protocols.carbohydrates.LinkageConformerMover, prob_sd_sample: bool) → None¶

Set whether if we are sampling uniformly within 1 SD or by sampling on the full gaussian directly.: Default FALSE

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

show(*args, **kwargs)¶

Overloaded function.

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

C++: protocols::carbohydrates::LinkageConformerMover::show(std::ostream &) 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.

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

Set the ‘type’ string

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

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

Get the set ‘type’ string

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

class pyrosetta.rosetta.protocols.carbohydrates.LinkageConformerMoverCreator¶

Bases: MoverCreator

assign(self: pyrosetta.rosetta.protocols.carbohydrates.LinkageConformerMoverCreator, : pyrosetta.rosetta.protocols.carbohydrates.LinkageConformerMoverCreator) → pyrosetta.rosetta.protocols.carbohydrates.LinkageConformerMoverCreator¶: C++: protocols::carbohydrates::LinkageConformerMoverCreator::operator=(const class protocols::carbohydrates::LinkageConformerMoverCreator &) –> class protocols::carbohydrates::LinkageConformerMoverCreator &

create_mover(self: pyrosetta.rosetta.protocols.carbohydrates.LinkageConformerMoverCreator) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::carbohydrates::LinkageConformerMoverCreator::create_mover() const –> class std::shared_ptr<class protocols::moves::Mover>

keyname(self: pyrosetta.rosetta.protocols.carbohydrates.LinkageConformerMoverCreator) → str¶: C++: protocols::carbohydrates::LinkageConformerMoverCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.carbohydrates.LinkageConformerMoverCreator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::carbohydrates::LinkageConformerMoverCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.protocols.carbohydrates.QuenchDirection¶

Bases: pybind11_object

Members:

forward

backward

backward = <QuenchDirection.backward: 2>¶

forward = <QuenchDirection.forward: 1>¶

property name¶

property value¶

class pyrosetta.rosetta.protocols.carbohydrates.RingPlaneFlipMover¶

Bases: Mover

A Mover class for flipping the plane of a carbohydrate pyranose ring 180 degrees about its anomeric bond.

Based on a given ResidueSelector and limited by a MoveMap, this mover selects applicable cyclic residues

and performs a 180-degree shearing move in which the anomeric bond and the main-chain bond on the opposite side of the ring are moved in opposite directions. An “applicable” residue is limited to 1,4-linked aldopyranoses or 2,5- linked ketopyranoses for which both the anomeric bond and the glycosidic linkage bond are equatorial.

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

Apply the corresponding move to <input_pose>.

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

assign(self: pyrosetta.rosetta.protocols.carbohydrates.RingPlaneFlipMover, object_to_copy: pyrosetta.rosetta.protocols.carbohydrates.RingPlaneFlipMover) → pyrosetta.rosetta.protocols.carbohydrates.RingPlaneFlipMover¶: C++: protocols::carbohydrates::RingPlaneFlipMover::operator=(const class protocols::carbohydrates::RingPlaneFlipMover &) –> class protocols::carbohydrates::RingPlaneFlipMover &

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

Supported in JD2. Will attempt to grab additional poses until a nullptr is returned.

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.RingPlaneFlipMover) → str¶

Return the name of the Mover.

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

movemap(*args, **kwargs)¶

Overloaded function.

movemap(self: pyrosetta.rosetta.protocols.carbohydrates.RingPlaneFlipMover, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.kinematics.MoveMap

Get the current MoveMap, creating it if needed.

C++: protocols::carbohydrates::RingPlaneFlipMover::movemap(const class core::pose::Pose &) const –> class std::shared_ptr<const class core::kinematics::MoveMap>

movemap(self: pyrosetta.rosetta.protocols.carbohydrates.RingPlaneFlipMover, new_movemap: pyrosetta.rosetta.core.kinematics.MoveMap) -> None

Set the MoveMap.

C++: protocols::carbohydrates::RingPlaneFlipMover::movemap(class std::shared_ptr<class core::kinematics::MoveMap>) –> void

movemap_factory(self: pyrosetta.rosetta.protocols.carbohydrates.RingPlaneFlipMover, new_movemap_factory: pyrosetta.rosetta.core.select.movemap.MoveMapFactory) → None¶

Set the MoveMapFactory.

C++: protocols::carbohydrates::RingPlaneFlipMover::movemap_factory(class std::shared_ptr<const class core::select::movemap::MoveMapFactory>) –> void

static mover_name() → str¶: C++: protocols::carbohydrates::RingPlaneFlipMover::mover_name() –> std::string

static name() → str¶: C++: protocols::moves::Mover::name() –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.carbohydrates.RingPlaneFlipMover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::carbohydrates::RingPlaneFlipMover::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.carbohydrates.RingPlaneFlipMover, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide the citation.

C++: protocols::carbohydrates::RingPlaneFlipMover::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::carbohydrates::RingPlaneFlipMover::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

static register_options() → None¶

Register options with the option system.

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

selector(*args, **kwargs)¶

Overloaded function.

selector(self: pyrosetta.rosetta.protocols.carbohydrates.RingPlaneFlipMover) -> pyrosetta.rosetta.core.select.residue_selector.ResidueSelector

Get the current ResidueSelector.

C++: protocols::carbohydrates::RingPlaneFlipMover::selector() const –> class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>

selector(self: pyrosetta.rosetta.protocols.carbohydrates.RingPlaneFlipMover, new_selector: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector) -> None

Set the ResidueSelector.

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

set_current_job(self: pyrosetta.rosetta.protocols.moves.Mover, job: protocols::jobdist::BasicJob) → None¶: 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 std::string &) –> 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¶

Set the ‘type’ string

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

show(*args, **kwargs)¶

Overloaded function.

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

Generate string representation of RingPlaneFlipMover for debugging purposes.

C++: protocols::carbohydrates::RingPlaneFlipMover::show(std::ostream &) 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.

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

Set the ‘type’ string

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

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

Get the set ‘type’ string

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

class pyrosetta.rosetta.protocols.carbohydrates.RingPlaneFlipMoverCreator¶

Bases: MoverCreator

MoverCreator allowing the MoverFactory to create a RingConformationMover

assign(self: pyrosetta.rosetta.protocols.carbohydrates.RingPlaneFlipMoverCreator, : pyrosetta.rosetta.protocols.carbohydrates.RingPlaneFlipMoverCreator) → pyrosetta.rosetta.protocols.carbohydrates.RingPlaneFlipMoverCreator¶: C++: protocols::carbohydrates::RingPlaneFlipMoverCreator::operator=(const class protocols::carbohydrates::RingPlaneFlipMoverCreator &) –> class protocols::carbohydrates::RingPlaneFlipMoverCreator &

create_mover(self: pyrosetta.rosetta.protocols.carbohydrates.RingPlaneFlipMoverCreator) → pyrosetta.rosetta.protocols.moves.Mover¶

Return an up-casted owning pointer (MoverOP) to the mover.

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

keyname(self: pyrosetta.rosetta.protocols.carbohydrates.RingPlaneFlipMoverCreator) → str¶

Return the key name for the associated Mover (RingPlaneFlipMoverCreator).

C++: protocols::carbohydrates::RingPlaneFlipMoverCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.carbohydrates.RingPlaneFlipMoverCreator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::carbohydrates::RingPlaneFlipMoverCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.protocols.carbohydrates.SimpleGlycosylateMover¶

Bases: Mover

A mover for glycosylation of biological glycosylations. Currently glysolylation is done based on string, not from PDB. Use the GlycanSampler 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:

If your name ends with .iupac or .gws (GlycoWorkBench), will try to load the file
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.

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.

Supported in JD2. Will attempt to grab additional poses until a nullptr is returned.

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

static mover_name() → str¶: C++: protocols::carbohydrates::SimpleGlycosylateMover::mover_name() –> std::string

static 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) → 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 &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.carbohydrates.SimpleGlycosylateMover, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide the citation.

C++: protocols::carbohydrates::SimpleGlycosylateMover::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::carbohydrates::SimpleGlycosylateMover::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

static 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¶: 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 std::string &) –> 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 std::string &) –> 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<std::string, class std::allocator<std::string > > &) –> 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¶

Set the ‘type’ string

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

show(*args, **kwargs)¶

Overloaded function.

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

C++: protocols::carbohydrates::SimpleGlycosylateMover::show(std::ostream &) 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.

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

Set the ‘type’ string

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

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

Get the set ‘type’ string

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

class pyrosetta.rosetta.protocols.carbohydrates.SimpleGlycosylateMoverCreator¶

Bases: MoverCreator

assign(self: pyrosetta.rosetta.protocols.carbohydrates.SimpleGlycosylateMoverCreator, : pyrosetta.rosetta.protocols.carbohydrates.SimpleGlycosylateMoverCreator) → pyrosetta.rosetta.protocols.carbohydrates.SimpleGlycosylateMoverCreator¶: C++: protocols::carbohydrates::SimpleGlycosylateMoverCreator::operator=(const class protocols::carbohydrates::SimpleGlycosylateMoverCreator &) –> class protocols::carbohydrates::SimpleGlycosylateMoverCreator &

create_mover(self: pyrosetta.rosetta.protocols.carbohydrates.SimpleGlycosylateMoverCreator) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::carbohydrates::SimpleGlycosylateMoverCreator::create_mover() const –> class std::shared_ptr<class protocols::moves::Mover>

keyname(self: pyrosetta.rosetta.protocols.carbohydrates.SimpleGlycosylateMoverCreator) → str¶: C++: protocols::carbohydrates::SimpleGlycosylateMoverCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.carbohydrates.SimpleGlycosylateMoverCreator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::carbohydrates::SimpleGlycosylateMoverCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.protocols.carbohydrates.TautomerizeAnomerMover¶

Bases: Mover

A Mover class for tautomerizing from one anomer to another at a reducing end.

This carbohydrate-specific Mover randomly selects a free reducing end (not a glycoside) and inverts the

stereochemistry, swapping alpha anomers for beta and beta for alpha. (This could be considered an extremely limited design case; however, reducing ends readily tautomerize in solution, in contrast to other cases, in which residues do not readily mutate into others!) It is generally not certain which form is preferred (if any) in sugar-binding proteins, and crystal structures sometimes arbitrarily assign one anomer over another when fitting density, so this Mover can assure that each anomer is sampled. If a ResidueSelector is set, the Mover will select from the subset at random; it will not guarantee tautomerization of every Residue in the subset.

This Mover assumes that, any time a new saccharide .params file is added to the Rosetta database, its

anomer is also added.

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

Apply the corresponding move to <input_pose>.

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

assign(self: pyrosetta.rosetta.protocols.carbohydrates.TautomerizeAnomerMover, object_to_copy: pyrosetta.rosetta.protocols.carbohydrates.TautomerizeAnomerMover) → pyrosetta.rosetta.protocols.carbohydrates.TautomerizeAnomerMover¶: C++: protocols::carbohydrates::TautomerizeAnomerMover::operator=(const class protocols::carbohydrates::TautomerizeAnomerMover &) –> class protocols::carbohydrates::TautomerizeAnomerMover &

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

Supported in JD2. Will attempt to grab additional poses until a nullptr is returned.

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.TautomerizeAnomerMover) → str¶

Return the name of the Mover.

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

static mover_name() → str¶: C++: protocols::carbohydrates::TautomerizeAnomerMover::mover_name() –> std::string

static name() → str¶: C++: protocols::moves::Mover::name() –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.carbohydrates.TautomerizeAnomerMover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::carbohydrates::TautomerizeAnomerMover::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.carbohydrates.TautomerizeAnomerMover, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide the citation.

C++: protocols::carbohydrates::TautomerizeAnomerMover::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::carbohydrates::TautomerizeAnomerMover::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

static register_options() → None¶

Register options with the option system.

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

selector(*args, **kwargs)¶

Overloaded function.

selector(self: pyrosetta.rosetta.protocols.carbohydrates.TautomerizeAnomerMover) -> pyrosetta.rosetta.core.select.residue_selector.ResidueSelector

Get the current ResidueSelector.

C++: protocols::carbohydrates::TautomerizeAnomerMover::selector() const –> class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>

selector(self: pyrosetta.rosetta.protocols.carbohydrates.TautomerizeAnomerMover, new_selector: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector) -> None

Set the ResidueSelector.

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

set_current_job(self: pyrosetta.rosetta.protocols.moves.Mover, job: protocols::jobdist::BasicJob) → None¶: 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 std::string &) –> 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¶

Set the ‘type’ string

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

show(*args, **kwargs)¶

Overloaded function.

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

Generate string representation of TautomerizeAnomerMover for debugging purposes.

C++: protocols::carbohydrates::TautomerizeAnomerMover::show(std::ostream &) 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.

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

Set the ‘type’ string

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

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

Get the set ‘type’ string

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

class pyrosetta.rosetta.protocols.carbohydrates.TautomerizeAnomerMoverCreator¶

Bases: MoverCreator

MoverCreator allowing the MoverFactory to create a TautomerizeAnomerMover.

assign(self: pyrosetta.rosetta.protocols.carbohydrates.TautomerizeAnomerMoverCreator, : pyrosetta.rosetta.protocols.carbohydrates.TautomerizeAnomerMoverCreator) → pyrosetta.rosetta.protocols.carbohydrates.TautomerizeAnomerMoverCreator¶: C++: protocols::carbohydrates::TautomerizeAnomerMoverCreator::operator=(const class protocols::carbohydrates::TautomerizeAnomerMoverCreator &) –> class protocols::carbohydrates::TautomerizeAnomerMoverCreator &

create_mover(self: pyrosetta.rosetta.protocols.carbohydrates.TautomerizeAnomerMoverCreator) → pyrosetta.rosetta.protocols.moves.Mover¶

Return an up-casted owning pointer (MoverOP) to the mover.

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

keyname(self: pyrosetta.rosetta.protocols.carbohydrates.TautomerizeAnomerMoverCreator) → str¶

Return the key name for the associated Mover (TautomerizeAnomerMoverCreator).

C++: protocols::carbohydrates::TautomerizeAnomerMoverCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.carbohydrates.TautomerizeAnomerMoverCreator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::carbohydrates::TautomerizeAnomerMoverCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> 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.

get_all_glycans_and_neighbor_res_task_factory(subset: pyrosetta.rosetta.utility.vector1_bool) -> pyrosetta.rosetta.core.pack.task.TaskFactory
get_all_glycans_and_neighbor_res_task_factory(subset: pyrosetta.rosetta.utility.vector1_bool, pack_distance: float) -> pyrosetta.rosetta.core.pack.task.TaskFactory
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>

pyrosetta.rosetta.protocols.carbohydrates.get_total_rounds_for_overlap_one_layer_two(pose: pyrosetta.rosetta.core.pose.Pose, residue_subset: pyrosetta.rosetta.utility.vector1_bool, sampler_rounds: int) → int¶

Used for benchmarking to test even sampling of different kinematic protocols: Get the total number of sampling rounds for the GlycanTreeModeler protocol with previous default settings.

C++: protocols::carbohydrates::get_total_rounds_for_overlap_one_layer_two(const class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &, unsigned long) –> unsigned long

pyrosetta.rosetta.protocols.carbohydrates.run_shear_min_pack(*args, **kwargs)¶

Overloaded function.

run_shear_min_pack(min_mover: protocols::minimization_packing::MinMover, packer: protocols::minimization_packing::PackRotamersMover, shear: protocols::simple_moves::ShearMover, mc: pyrosetta.rosetta.protocols.moves.MonteCarlo, n_glycan_residues: int, pose: pyrosetta.rosetta.core.pose.Pose) -> None
run_shear_min_pack(min_mover: protocols::minimization_packing::MinMover, packer: protocols::minimization_packing::PackRotamersMover, shear: protocols::simple_moves::ShearMover, mc: pyrosetta.rosetta.protocols.moves.MonteCarlo, n_glycan_residues: int, pose: pyrosetta.rosetta.core.pose.Pose, use_shear: bool) -> None

Run a shear/min/pack on all residues set to move.

C++: protocols::carbohydrates::run_shear_min_pack(class protocols::minimization_packing::MinMover &, class protocols::minimization_packing::PackRotamersMover &, class protocols::simple_moves::ShearMover &, class protocols::moves::MonteCarlo &, unsigned long, class core::pose::Pose &, bool) –> void