denovo_design

Bindings for protocols::denovo_design namespace

class pyrosetta.rosetta.protocols.denovo_design.DisulfidizeMover

Bases: MultiplePoseMover

apply(self: pyrosetta.rosetta.protocols.rosetta_scripts.MultiplePoseMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::rosetta_scripts::MultiplePoseMover::apply(class core::pose::Pose &) –> void

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

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

build_and_score_disulfide(self: pyrosetta.rosetta.protocols.denovo_design.DisulfidizeMover, blank_pose: pyrosetta.rosetta.core.pose.Pose, sfxn_disulfonly: pyrosetta.rosetta.core.scoring.ScoreFunction, sfxn_full: pyrosetta.rosetta.core.scoring.ScoreFunction, relax_bb: bool, res1: int, res2: int) → float

temporarily tries building a disulfide between the given positions, scores, and restores the pose

C++: protocols::denovo_design::DisulfidizeMover::build_and_score_disulfide(class core::pose::Pose &, class std::shared_ptr<class core::scoring::ScoreFunction>, class std::shared_ptr<class core::scoring::ScoreFunction>, const bool, const unsigned long, const unsigned long) const –> double

check_disulfide_cb_distance(self: pyrosetta.rosetta.protocols.denovo_design.DisulfidizeMover, pose: pyrosetta.rosetta.core.pose.Pose, res1: int, res2: int) → bool

checks disulfide CB-CB distance

C++: protocols::denovo_design::DisulfidizeMover::check_disulfide_cb_distance(const class core::pose::Pose &, const unsigned long, const unsigned long) const –> bool

check_disulfide_match_rt(self: pyrosetta.rosetta.protocols.denovo_design.DisulfidizeMover, pose: pyrosetta.rosetta.core.pose.Pose, res1: int, res2: int, disulfPot: pyrosetta.rosetta.core.scoring.disulfides.DisulfideMatchingPotential, mirror: bool) → bool

checks disulfide match rt

C++: protocols::denovo_design::DisulfidizeMover::check_disulfide_match_rt(const class core::pose::Pose &, const unsigned long, const unsigned long, const class core::scoring::disulfides::DisulfideMatchingPotential &, const bool) const –> bool

check_disulfide_score(self: pyrosetta.rosetta.protocols.denovo_design.DisulfidizeMover, pose: pyrosetta.rosetta.core.pose.Pose, res1: int, res2: int, sfxn_disulfonly: pyrosetta.rosetta.core.scoring.ScoreFunction, sfxn_full: pyrosetta.rosetta.core.scoring.ScoreFunction) → bool

checks disulfide rosetta score

C++: protocols::denovo_design::DisulfidizeMover::check_disulfide_score(class core::pose::Pose &, const unsigned long, const unsigned long, class std::shared_ptr<class core::scoring::ScoreFunction>, class std::shared_ptr<class core::scoring::ScoreFunction>) const –> bool

check_disulfide_seqpos(self: pyrosetta.rosetta.protocols.denovo_design.DisulfidizeMover, res1: int, res2: int) → bool

checks seqpos to ensure that min_loop is satisfied

C++: protocols::denovo_design::DisulfidizeMover::check_disulfide_seqpos(const unsigned long, const unsigned long) const –> bool

check_residue_type(self: pyrosetta.rosetta.protocols.denovo_design.DisulfidizeMover, pose: pyrosetta.rosetta.core.pose.Pose, res: int) → bool

checks seqpos to ensure that min_loop is satisfied

C++: protocols::denovo_design::DisulfidizeMover::check_residue_type(const class core::pose::Pose &, const unsigned long) const –> bool

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

return a fresh instance of this class in an owning pointer

C++: protocols::denovo_design::DisulfidizeMover::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>

find_current_disulfides(self: pyrosetta.rosetta.protocols.denovo_design.DisulfidizeMover, pose: pyrosetta.rosetta.core.pose.Pose, subset1: pyrosetta.rosetta.utility.vector1_bool, subset2: pyrosetta.rosetta.utility.vector1_bool) → pyrosetta.rosetta.utility.vector1_std_pair_unsigned_long_unsigned_long_t

finds disulfides within a pose subset

C++: protocols::denovo_design::DisulfidizeMover::find_current_disulfides(const class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &, const class utility::vector1<bool, class std::allocator<bool> > &) const –> class utility::vector1<struct std::pair<unsigned long, unsigned long>, class std::allocator<struct std::pair<unsigned long, unsigned long> > >

find_possible_disulfides(*args, **kwargs)

Overloaded function.

  1. find_possible_disulfides(self: pyrosetta.rosetta.protocols.denovo_design.DisulfidizeMover, pose: pyrosetta.rosetta.core.pose.Pose, residueset1: pyrosetta.rosetta.utility.vector1_bool, residueset2: pyrosetta.rosetta.utility.vector1_bool, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction) -> pyrosetta.rosetta.utility.vector1_std_pair_unsigned_long_unsigned_long_t

find disulfides in the given neighborhood

C++: protocols::denovo_design::DisulfidizeMover::find_possible_disulfides(const class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &, const class utility::vector1<bool, class std::allocator<bool> > &, class std::shared_ptr<class core::scoring::ScoreFunction>) const –> class utility::vector1<struct std::pair<unsigned long, unsigned long>, class std::allocator<struct std::pair<unsigned long, unsigned long> > >

  1. find_possible_disulfides(self: pyrosetta.rosetta.protocols.denovo_design.DisulfidizeMover, pose: pyrosetta.rosetta.core.pose.Pose, set1: pyrosetta.rosetta.std.set_unsigned_long_t, set2: pyrosetta.rosetta.std.set_unsigned_long_t, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction) -> pyrosetta.rosetta.utility.vector1_std_pair_unsigned_long_unsigned_long_t

find disulfides in the given neighborhood between residues in set 1 and residues in set 2

C++: protocols::denovo_design::DisulfidizeMover::find_possible_disulfides(const class core::pose::Pose &, const class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> > &, const class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> > &, class std::shared_ptr<class core::scoring::ScoreFunction>) const –> class utility::vector1<struct std::pair<unsigned long, unsigned long>, class std::allocator<struct std::pair<unsigned long, unsigned long> > >

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

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

get_additional_output(self: pyrosetta.rosetta.protocols.rosetta_scripts.MultiplePoseMover) → pyrosetta.rosetta.core.pose.Pose

C++: protocols::rosetta_scripts::MultiplePoseMover::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.denovo_design.DisulfidizeMover) → str

C++: protocols::denovo_design::DisulfidizeMover::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

make_disulfide(self: pyrosetta.rosetta.protocols.denovo_design.DisulfidizeMover, pose: pyrosetta.rosetta.core.pose.Pose, res1: int, res2: int, relax_bb: bool, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

forms a disulfide between res1 and res2, optionally allowing backbone movement

C++: protocols::denovo_design::DisulfidizeMover::make_disulfide(class core::pose::Pose &, const unsigned long, const unsigned long, const bool, class std::shared_ptr<class core::scoring::ScoreFunction>) const –> void

make_disulfides(self: pyrosetta.rosetta.protocols.denovo_design.DisulfidizeMover, pose: pyrosetta.rosetta.core.pose.Pose, disulf: pyrosetta.rosetta.utility.vector1_std_pair_unsigned_long_unsigned_long_t, relax_bb: bool, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

creates disulfides given the list of pairs given

C++: protocols::denovo_design::DisulfidizeMover::make_disulfides(class core::pose::Pose &, const class utility::vector1<struct std::pair<unsigned long, unsigned long>, class std::allocator<struct std::pair<unsigned long, unsigned long> > > &, const bool, class std::shared_ptr<class core::scoring::ScoreFunction>) const –> void

mixed_disulfide(self: pyrosetta.rosetta.protocols.denovo_design.DisulfidizeMover, pose: pyrosetta.rosetta.core.pose.Pose, res1: int, res2: int) → bool

Returns true if this is a mixed D/L disulfide, false otherwise.

C++: protocols::denovo_design::DisulfidizeMover::mixed_disulfide(const class core::pose::Pose &, const unsigned long, const unsigned long) const –> bool

static mover_name() → str

C++: protocols::denovo_design::DisulfidizeMover::mover_name() –> std::string

mutate_disulfides_to_ala(self: pyrosetta.rosetta.protocols.denovo_design.DisulfidizeMover, pose: pyrosetta.rosetta.core.pose.Pose, current_ds: pyrosetta.rosetta.utility.vector1_std_pair_unsigned_long_unsigned_long_t) → None

mutates the given disulfides to ALA

C++: protocols::denovo_design::DisulfidizeMover::mutate_disulfides_to_ala(class core::pose::Pose &, const class utility::vector1<struct std::pair<unsigned long, unsigned long>, class std::allocator<struct std::pair<unsigned long, unsigned long> > > &) const –> void

static name() → str

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

noncanonical_disulfide(self: pyrosetta.rosetta.protocols.denovo_design.DisulfidizeMover, pose: pyrosetta.rosetta.core.pose.Pose, res1: int, res2: int) → bool
Returns true if at least one of the partners in this disulfide is NOT

D-cysteine or L-cysteine. Returns false otherwise.

C++: protocols::denovo_design::DisulfidizeMover::noncanonical_disulfide(const class core::pose::Pose &, const unsigned long, const unsigned long) const –> bool

parse_my_tag(self: pyrosetta.rosetta.protocols.denovo_design.DisulfidizeMover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None

Parses the DisulfidizerMoverTags

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

provide_citation_info(self: pyrosetta.rosetta.protocols.moves.Mover, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None
Provide citations to the passed CitationCollectionList

Subclasses should add the info for themselves and any other classes they use.

The default implementation of this function does nothing. It may be overriden by movers wishing to provide citation information.

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

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None

C++: protocols::denovo_design::DisulfidizeMover::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

recursive_multiple_disulfide_former(self: pyrosetta.rosetta.protocols.denovo_design.DisulfidizeMover, disulfides_formed: pyrosetta.rosetta.utility.vector1_std_pair_unsigned_long_unsigned_long_t, disulfides_possible: pyrosetta.rosetta.utility.vector1_std_pair_unsigned_long_unsigned_long_t) → pyrosetta.rosetta.utility.vector1_utility_vector1_std_pair_unsigned_long_unsigned_long_std_allocator_std_pair_unsigned_long_unsigned_long_t

Function for recursively creating multiple disulfides

C++: protocols::denovo_design::DisulfidizeMover::recursive_multiple_disulfide_former(const class utility::vector1<struct std::pair<unsigned long, unsigned long>, class std::allocator<struct std::pair<unsigned long, unsigned long> > > &, const class utility::vector1<struct std::pair<unsigned long, unsigned long>, class std::allocator<struct std::pair<unsigned long, unsigned long> > > &) const –> class utility::vector1<class utility::vector1<struct std::pair<unsigned long, unsigned long>, class std::allocator<struct std::pair<unsigned long, unsigned long> > >, class std::allocator<class utility::vector1<struct std::pair<unsigned long, unsigned long>, class std::allocator<struct std::pair<unsigned long, unsigned long> > > > >

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_cys_types(self: pyrosetta.rosetta.protocols.denovo_design.DisulfidizeMover, lcys: bool, dcys: bool, beta_cys: bool) → None

Set the types of cysteines that we design with:

By default, we use only L-cysteine (not D-cysteine or beta-3-cysteine).

C++: protocols::denovo_design::DisulfidizeMover::set_cys_types(const bool, const bool, const bool) –> void

set_include_current_ds(self: pyrosetta.rosetta.protocols.denovo_design.DisulfidizeMover, include_current: bool) → None

If set, the current disulfides in the pose will be included in the set of possible disulfide configurations that are returned

C++: protocols::denovo_design::DisulfidizeMover::set_include_current_ds(const 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_keep_current_ds(self: pyrosetta.rosetta.protocols.denovo_design.DisulfidizeMover, keep_current: bool) → None

If set, the current disulfides in the pose will be kept as-is

C++: protocols::denovo_design::DisulfidizeMover::set_keep_current_ds(const bool) –> void

set_match_rt_limit(self: pyrosetta.rosetta.protocols.denovo_design.DisulfidizeMover, matchrtval: float) → None

sets the maximum allowed “match-rt-limit” (default=1.0)

Changed from default=2.0 by VKM on 19 Aug 2015 after fixing major bug in DisulfideMatchPotential.

C++: protocols::denovo_design::DisulfidizeMover::set_match_rt_limit(const double) –> void

set_max_dist(self: pyrosetta.rosetta.protocols.denovo_design.DisulfidizeMover, dist: float) → None

sets the maximum distance to have an allowed disulfide

C++: protocols::denovo_design::DisulfidizeMover::set_max_dist(const double) –> void

set_max_disulf_score(self: pyrosetta.rosetta.protocols.denovo_design.DisulfidizeMover, maxscoreval: float) → None

sets the maximum allowed per-disulfide dslf_fa13 score (default=0.0)

C++: protocols::denovo_design::DisulfidizeMover::set_max_disulf_score(const double) –> void

set_max_disulfides(self: pyrosetta.rosetta.protocols.denovo_design.DisulfidizeMover, max_disulf: int) → None

sets maximum number of disulfides

C++: protocols::denovo_design::DisulfidizeMover::set_max_disulfides(const unsigned long) –> void

set_min_disulfides(self: pyrosetta.rosetta.protocols.denovo_design.DisulfidizeMover, min_disulf: int) → None

sets minimum number of disulfides

C++: protocols::denovo_design::DisulfidizeMover::set_min_disulfides(const unsigned long) –> void

set_min_loop(self: pyrosetta.rosetta.protocols.denovo_design.DisulfidizeMover, minloopval: int) → None

sets the min_loop value (number of residues between disulfide-joined residues) (default=8)

C++: protocols::denovo_design::DisulfidizeMover::set_min_loop(const unsigned long) –> void

set_mutate_gly(self: pyrosetta.rosetta.protocols.denovo_design.DisulfidizeMover, mutate_gly: bool) → None

If true, GLY –> CYS mutations will be allowed. Default=false

C++: protocols::denovo_design::DisulfidizeMover::set_mutate_gly(const bool) –> void

set_mutate_pro(self: pyrosetta.rosetta.protocols.denovo_design.DisulfidizeMover, mutate_pro: bool) → None

If true, PRO –> CYS mutations will be allowed. Default=false

C++: protocols::denovo_design::DisulfidizeMover::set_mutate_pro(const 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_previous_mover(self: pyrosetta.rosetta.protocols.rosetta_scripts.MultiplePoseMover, m: pyrosetta.rosetta.protocols.moves.Mover) → None

Used by RosettaScripts to set the previous mover to pull poses from

C++: protocols::rosetta_scripts::MultiplePoseMover::set_previous_mover(const class std::shared_ptr<class protocols::moves::Mover>) –> void

set_rosetta_scripts_tag(self: pyrosetta.rosetta.protocols.rosetta_scripts.MultiplePoseMover, tag: pyrosetta.rosetta.utility.tag.Tag) → None

sets rosettascripts tag

C++: protocols::rosetta_scripts::MultiplePoseMover::set_rosetta_scripts_tag(class std::shared_ptr<const class utility::tag::Tag>) –> void

set_score_or_matchrt(self: pyrosetta.rosetta.protocols.denovo_design.DisulfidizeMover, score_or_match: bool) → None

If true, the disulfide score OR the match_rt score can indicate that a disulfide is reasonable. If false, both the disulfide score AND the match_rt score are needed

C++: protocols::denovo_design::DisulfidizeMover::set_score_or_matchrt(const bool) –> void

set_scorefxn(self: pyrosetta.rosetta.protocols.denovo_design.DisulfidizeMover, sfxn_in: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

Set the scorefunction to use for scoring disulfides, minimizing, and repacking.

Clones the input scorefunction; does not copy it.

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

set_set1_selector(self: pyrosetta.rosetta.protocols.denovo_design.DisulfidizeMover, selector: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector) → None

sets the selector for set 1 – disulfides will connect residues in set 1 to residues in set 2

C++: protocols::denovo_design::DisulfidizeMover::set_set1_selector(class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>) –> void

set_set2_selector(self: pyrosetta.rosetta.protocols.denovo_design.DisulfidizeMover, selector: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector) → None

sets the selector for set 2 – disulfides will connect residues in set 1 to residues in set 2

C++: protocols::denovo_design::DisulfidizeMover::set_set2_selector(class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>) –> void

set_sort_scorefxn(self: pyrosetta.rosetta.protocols.denovo_design.DisulfidizeMover, sort_scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

Set the scorefunction to use for sorting the final results.

Clones the input scorefunction; does not copy it.

C++: protocols::denovo_design::DisulfidizeMover::set_sort_scorefxn(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

show(*args, **kwargs)

Overloaded function.

  1. show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None

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

Outputs details about the Mover, including current settings.

C++: protocols::moves::Mover::show(std::ostream &) const –> void

tag_disulfide(self: pyrosetta.rosetta.protocols.denovo_design.DisulfidizeMover, pose: pyrosetta.rosetta.core.pose.Pose, res1: int, res2: int) → None

creates a residue tags on disulfides to inform users that this disulfide was created by disulfidize

C++: protocols::denovo_design::DisulfidizeMover::tag_disulfide(class core::pose::Pose &, const unsigned long, const unsigned long) const –> void

tag_disulfides(self: pyrosetta.rosetta.protocols.denovo_design.DisulfidizeMover, pose: pyrosetta.rosetta.core.pose.Pose, disulf: pyrosetta.rosetta.utility.vector1_std_pair_unsigned_long_unsigned_long_t) → None

creates a residue tags on disulfides to inform users that this disulfide was created by disulfidize

C++: protocols::denovo_design::DisulfidizeMover::tag_disulfides(class core::pose::Pose &, const class utility::vector1<struct std::pair<unsigned long, unsigned long>, class std::allocator<struct std::pair<unsigned long, unsigned long> > > &) const –> void

test_move(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None
: Unit test support function. Apply one move to a given pose.

Allows extra test specific functions to be called before applying

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

type(*args, **kwargs)

Overloaded function.

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

Set the ‘type’ string

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

  1. 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.denovo_design.DisulfidizeMoverCreator

Bases: MoverCreator

assign(self: pyrosetta.rosetta.protocols.denovo_design.DisulfidizeMoverCreator, : pyrosetta.rosetta.protocols.denovo_design.DisulfidizeMoverCreator) → pyrosetta.rosetta.protocols.denovo_design.DisulfidizeMoverCreator

C++: protocols::denovo_design::DisulfidizeMoverCreator::operator=(const class protocols::denovo_design::DisulfidizeMoverCreator &) –> class protocols::denovo_design::DisulfidizeMoverCreator &

create_mover(self: pyrosetta.rosetta.protocols.denovo_design.DisulfidizeMoverCreator) → pyrosetta.rosetta.protocols.moves.Mover

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

keyname(self: pyrosetta.rosetta.protocols.denovo_design.DisulfidizeMoverCreator) → str

C++: protocols::denovo_design::DisulfidizeMoverCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.denovo_design.DisulfidizeMoverCreator, xsd: utility::tag::XMLSchemaDefinition) → None

C++: protocols::denovo_design::DisulfidizeMoverCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

pyrosetta.rosetta.protocols.denovo_design.abego_str(abego: pyrosetta.rosetta.utility.vector1_std_string) → str

C++: protocols::denovo_design::abego_str(const class utility::vector1<std::string, class std::allocator<std::string > > &) –> std::string

pyrosetta.rosetta.protocols.denovo_design.abego_vector(ab: str) → pyrosetta.rosetta.utility.vector1_std_string

C++: protocols::denovo_design::abego_vector(const std::string &) –> class utility::vector1<std::string, class std::allocator<std::string > >

pyrosetta.rosetta.protocols.denovo_design.add_chain_from_pose(to_add: pyrosetta.rosetta.core.pose.Pose, combined: pyrosetta.rosetta.core.pose.Pose) → None

dumps a pose into another pose as a new chain

C++: protocols::denovo_design::add_chain_from_pose(class std::shared_ptr<const class core::pose::Pose>, class std::shared_ptr<class core::pose::Pose>) –> void

pyrosetta.rosetta.protocols.denovo_design.add_cutpoints(pose: pyrosetta.rosetta.core.pose.Pose, sd: pyrosetta.rosetta.protocols.denovo_design.components.StructureData) → None

C++: protocols::denovo_design::add_cutpoints(class core::pose::Pose &, const class protocols::denovo_design::components::StructureData &) –> void

pyrosetta.rosetta.protocols.denovo_design.add_remark(remarks: pyrosetta.rosetta.core.io.Remarks, num: int, str_val: str) → None

adds a remark to a Remarks object, splitting it into multiple remarks if it is too long

C++: protocols::denovo_design::add_remark(class core::io::Remarks &, const unsigned long, const std::string &) –> void

pyrosetta.rosetta.protocols.denovo_design.add_residues_to_pose(pose: pyrosetta.rosetta.core.pose.Pose, template_pose: pyrosetta.rosetta.core.pose.Pose, new_chain: bool) → None

adds residues from template_pose to pose. If new_chain == true, creates covalent bond

C++: protocols::denovo_design::add_residues_to_pose(class core::pose::Pose &, const class core::pose::Pose &, const bool) –> void

pyrosetta.rosetta.protocols.denovo_design.construct_dummy_pose(*args, **kwargs)

Overloaded function.

  1. construct_dummy_pose(restype_name: str) -> pyrosetta.rosetta.core.pose.Pose

builds an extended-conformation poly-XXX pose

C++: protocols::denovo_design::construct_dummy_pose(const std::string &) –> class std::shared_ptr<class core::pose::Pose>

  1. construct_dummy_pose(restype_name: str, length: int) -> pyrosetta.rosetta.core.pose.Pose

C++: protocols::denovo_design::construct_dummy_pose(const std::string &, const unsigned long) –> class std::shared_ptr<class core::pose::Pose>

  1. construct_dummy_pose(restype: pyrosetta.rosetta.core.chemical.ResidueType) -> pyrosetta.rosetta.core.pose.Pose

C++: protocols::denovo_design::construct_dummy_pose(const class core::chemical::ResidueType &) –> class std::shared_ptr<class core::pose::Pose>

  1. construct_dummy_pose(restype: pyrosetta.rosetta.core.chemical.ResidueType, length: int) -> pyrosetta.rosetta.core.pose.Pose

C++: protocols::denovo_design::construct_dummy_pose(const class core::chemical::ResidueType &, const unsigned long) –> class std::shared_ptr<class core::pose::Pose>

pyrosetta.rosetta.protocols.denovo_design.construct_poly_ala_pose(*args, **kwargs)

Overloaded function.

  1. construct_poly_ala_pose(pose: pyrosetta.rosetta.core.pose.Pose, keep_disulf: bool, set1: pyrosetta.rosetta.utility.vector1_bool, set2: pyrosetta.rosetta.utility.vector1_bool) -> None

  2. construct_poly_ala_pose(pose: pyrosetta.rosetta.core.pose.Pose, keep_disulf: bool, set1: pyrosetta.rosetta.utility.vector1_bool, set2: pyrosetta.rosetta.utility.vector1_bool, keep_chirality: bool) -> None

creates a poly-ala pose where every non-gly, non-cyd, protein residue except those in the given set are converted to alanine

If keep_chirality is true, the D-amino acids are mutated to D-alanine.

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

  1. construct_poly_ala_pose(pose: pyrosetta.rosetta.core.pose.Pose, keep_disulf: bool, res_set: pyrosetta.rosetta.std.set_unsigned_long_t) -> None

  2. construct_poly_ala_pose(pose: pyrosetta.rosetta.core.pose.Pose, keep_disulf: bool, res_set: pyrosetta.rosetta.std.set_unsigned_long_t, keep_chirality: bool) -> None

creates a poly-ala pose where every non-gly, non-cyd, protein residue except those in the given set are converted to alanine

If keep_chirality is true, the D-amino acids are mutated to D-alanine.

C++: protocols::denovo_design::construct_poly_ala_pose(class core::pose::Pose &, const bool, const class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> > &, const bool) –> void

pyrosetta.rosetta.protocols.denovo_design.count_bulges(perm: pyrosetta.rosetta.protocols.denovo_design.components.StructureData, segment: str) → int

counts the beta-bulges in the given segment. This simply counts all abego A’s in the segment

C++: protocols::denovo_design::count_bulges(const class protocols::denovo_design::components::StructureData &, const std::string &) –> unsigned long

pyrosetta.rosetta.protocols.denovo_design.extract_int(num: float, m: int, n: int) → int
given a number 0 <= x < 1, calculate an integer M <= x <= N

NOTE THAT THIS FUNCTION MODIFIES THE PARAMETER

C++: protocols::denovo_design::extract_int(double &, const unsigned long, const unsigned long) –> unsigned long

pyrosetta.rosetta.protocols.denovo_design.find_jump_rec(ft: pyrosetta.rosetta.core.kinematics.FoldTree, residue: int) → int

helper function that looks for the given residue in a fold tree and returns the jump that controls its 6D-DoFs

C++: protocols::denovo_design::find_jump_rec(const class core::kinematics::FoldTree &, const unsigned long) –> int

pyrosetta.rosetta.protocols.denovo_design.get_resid(sd: pyrosetta.rosetta.protocols.denovo_design.components.StructureData, resid_str: str) → int

C++: protocols::denovo_design::get_resid(const class protocols::denovo_design::components::StructureData &, const std::string &) –> unsigned long

pyrosetta.rosetta.protocols.denovo_design.get_residue_selector(data: pyrosetta.rosetta.basic.datacache.DataMap, name: str) → pyrosetta.rosetta.core.select.residue_selector.ResidueSelector

C++: protocols::denovo_design::get_residue_selector(const class basic::datacache::DataMap &, const std::string &) –> class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>

pyrosetta.rosetta.protocols.denovo_design.insert_peptide_edges(ft: pyrosetta.rosetta.core.kinematics.FoldTree, jedge: pyrosetta.rosetta.core.kinematics.Edge) → None

inserts the peptide edges to accomodate the new jump edge given

C++: protocols::denovo_design::insert_peptide_edges(class core::kinematics::FoldTree &, const class core::kinematics::Edge &) –> void

pyrosetta.rosetta.protocols.denovo_design.linear_chainbreak(pose: pyrosetta.rosetta.core.pose.Pose, pos: int) → float

evaluate linear chainbreak at a position

If necessary, will evaluate using a copy of the Pose with a cut

fold tree. If cutpoint variants are present at chainbreak, will use existing variants and not modify them. If cutpoint variants are not found will add them and then remove them once calculation is finished. Eventually this should be merged into protocols/forge/methods/linear_chainbreak.cc However, the changes I needed to make to that file break certain parts of remodel

C++: protocols::denovo_design::linear_chainbreak(const class core::pose::Pose &, const unsigned long) –> double

pyrosetta.rosetta.protocols.denovo_design.loop_start_without_overlap(pose: pyrosetta.rosetta.core.pose.Pose, startres: int, overlap: int) → int

C++: protocols::denovo_design::loop_start_without_overlap(const class core::pose::Pose &, unsigned long, const unsigned long) –> unsigned long

pyrosetta.rosetta.protocols.denovo_design.loop_stop_without_overlap(pose: pyrosetta.rosetta.core.pose.Pose, stopres: int, overlap: int) → int

C++: protocols::denovo_design::loop_stop_without_overlap(const class core::pose::Pose &, unsigned long, const unsigned long) –> unsigned long

pyrosetta.rosetta.protocols.denovo_design.parse_motif_string(motif_str: str, secstruct: str, abego: str) → None

Computes secondary structure string from the given motifs

Motif string to be parsed (e.g. “5EB-2LG-5EB”)

Secondary structure string to be cleared and filled

ABEGO string to be cleared and filled

C++: protocols::denovo_design::parse_motif_string(const std::string &, std::string &, std::string &) –> void

pyrosetta.rosetta.protocols.denovo_design.rebuild_missing_atoms(pose: pyrosetta.rosetta.core.pose.Pose, resi: int) → None

given a residue, rebuilds all missing atoms

C++: protocols::denovo_design::rebuild_missing_atoms(class core::pose::Pose &, const unsigned long) –> void

pyrosetta.rosetta.protocols.denovo_design.remove_all_jump_atoms(orig: pyrosetta.rosetta.core.kinematics.FoldTree) → pyrosetta.rosetta.core.kinematics.FoldTree

C++: protocols::denovo_design::remove_all_jump_atoms(const class core::kinematics::FoldTree &) –> class core::kinematics::FoldTree

pyrosetta.rosetta.protocols.denovo_design.remove_missing_jump_atoms(pose: pyrosetta.rosetta.core.pose.Pose, orig: pyrosetta.rosetta.core.kinematics.FoldTree) → pyrosetta.rosetta.core.kinematics.FoldTree

C++: protocols::denovo_design::remove_missing_jump_atoms(const class core::pose::Pose &, const class core::kinematics::FoldTree &) –> class core::kinematics::FoldTree

pyrosetta.rosetta.protocols.denovo_design.same_pose(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose) → bool

Tells whether the two given poses are identical based on # resides and dihedrals

C++: protocols::denovo_design::same_pose(const class core::pose::Pose &, const class core::pose::Pose &) –> bool

pyrosetta.rosetta.protocols.denovo_design.slide_jump(ft_orig: pyrosetta.rosetta.core.kinematics.FoldTree, jump_idx: int, new_start: int, new_stop: int) → pyrosetta.rosetta.core.kinematics.FoldTree

C++: protocols::denovo_design::slide_jump(const class core::kinematics::FoldTree &, const unsigned long, const unsigned long, const unsigned long) –> class core::kinematics::FoldTree

pyrosetta.rosetta.protocols.denovo_design.symmetric_fold_tree(pose: pyrosetta.rosetta.core.pose.Pose, asymm_ft: pyrosetta.rosetta.core.kinematics.FoldTree) → pyrosetta.rosetta.core.kinematics.FoldTree
Given a symmetric pose, and a fold tree for the asymmetric unit, constructs and

returns a symmetric fold tree while preserving the topology of the aysmmetric unit’s fold tree

C++: protocols::denovo_design::symmetric_fold_tree(const class core::pose::Pose &, const class core::kinematics::FoldTree &) –> class core::kinematics::FoldTree

pyrosetta.rosetta.protocols.denovo_design.symmetric_residue_subset(pose: pyrosetta.rosetta.core.pose.Pose, subset: pyrosetta.rosetta.utility.vector1_bool) → pyrosetta.rosetta.utility.vector1_bool
Given a symmetric pose and a ResidueSubset for the asymmetric unit, constructs

and returns a residue subset compatible with the symmetric pose based on the given asymmetric unit residue subset

C++: protocols::denovo_design::symmetric_residue_subset(const class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &) –> class utility::vector1<bool, class std::allocator<bool> >

pyrosetta.rosetta.protocols.denovo_design.symmetric_secstruct(pose: pyrosetta.rosetta.core.pose.Pose, asymm_secstruct: str) → str
Given a symmetric pose and a secstruct for the asymmetric unit, constructs and

returns a secondary structure string compatible with the symmetric pose based on the secondary structure of the asymmetric unit

C++: protocols::denovo_design::symmetric_secstruct(const class core::pose::Pose &, const std::string &) –> std::string