hotspot_hashing¶

movers

Bindings for protocols::hotspot_hashing namespace

class pyrosetta.rosetta.protocols.hotspot_hashing.AddSearchPatternRotSetOp¶

Bases: TaskOperation

apply(self: pyrosetta.rosetta.protocols.hotspot_hashing.AddSearchPatternRotSetOp, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pack.task.PackerTask) → None¶: C++: protocols::hotspot_hashing::AddSearchPatternRotSetOp::apply(const class core::pose::Pose &, class core::pack::task::PackerTask &) const –> void

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

clone(self: pyrosetta.rosetta.protocols.hotspot_hashing.AddSearchPatternRotSetOp) → pyrosetta.rosetta.core.pack.task.operation.TaskOperation¶: C++: protocols::hotspot_hashing::AddSearchPatternRotSetOp::clone() const –> class std::shared_ptr<class core::pack::task::operation::TaskOperation>

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

provide_citation_info(self: pyrosetta.rosetta.core.pack.task.operation.TaskOperation, : 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 task operations wishing to provide citation information.

C++: core::pack::task::operation::TaskOperation::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

class pyrosetta.rosetta.protocols.hotspot_hashing.CartesianSearchPattern¶

Bases: SearchPattern

Searchpoints(self: pyrosetta.rosetta.protocols.hotspot_hashing.CartesianSearchPattern) → pyrosetta.rosetta.utility.vector1_core_kinematics_Stub¶: C++: protocols::hotspot_hashing::CartesianSearchPattern::Searchpoints() –> class utility::vector1<class core::kinematics::Stub, class std::allocator<class core::kinematics::Stub> >

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

generate_search_points(self: pyrosetta.rosetta.protocols.hotspot_hashing.CartesianSearchPattern) → pyrosetta.rosetta.utility.vector1_core_kinematics_Stub¶: C++: protocols::hotspot_hashing::CartesianSearchPattern::generate_search_points() –> class utility::vector1<class core::kinematics::Stub, class std::allocator<class core::kinematics::Stub> >

property searchpoints_¶

property x_max¶

property x_min¶

property x_sampling¶

property y_max¶

property y_min¶

property y_sampling¶

property z_max¶

property z_min¶

property z_sampling¶

class pyrosetta.rosetta.protocols.hotspot_hashing.ComposeSearchPatterns¶

Bases: SearchPattern

Searchpoints(self: pyrosetta.rosetta.protocols.hotspot_hashing.ComposeSearchPatterns) → pyrosetta.rosetta.utility.vector1_core_kinematics_Stub¶: C++: protocols::hotspot_hashing::ComposeSearchPatterns::Searchpoints() –> class utility::vector1<class core::kinematics::Stub, class std::allocator<class core::kinematics::Stub> >

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

class pyrosetta.rosetta.protocols.hotspot_hashing.ConstPattern¶

Bases: SearchPattern

Searchpoints(self: pyrosetta.rosetta.protocols.hotspot_hashing.ConstPattern) → pyrosetta.rosetta.utility.vector1_core_kinematics_Stub¶: C++: protocols::hotspot_hashing::ConstPattern::Searchpoints() –> class utility::vector1<class core::kinematics::Stub, class std::allocator<class core::kinematics::Stub> >

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

property target_stub¶

class pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStub¶

Bases: pybind11_object

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

bonus_value(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStub) → float¶

Return this potential hotspot’s bonus value

C++: protocols::hotspot_hashing::HotspotStub::bonus_value() const –> double

get_nearest_residue(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStub, pose: pyrosetta.rosetta.core.pose.Pose) → int¶

find the residue that’s closest to the stub on chain_to_design_

C++: protocols::hotspot_hashing::HotspotStub::get_nearest_residue(const class core::pose::Pose &) const –> unsigned long

get_scaffold_status(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStub, seqpos: int) → bool¶

Get status at position (setting status if not set)

C++: protocols::hotspot_hashing::HotspotStub::get_scaffold_status(const unsigned long) –> bool

residue(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStub) → pyrosetta.rosetta.core.conformation.Residue¶

Return the residue associated with this potential hotspot

C++: protocols::hotspot_hashing::HotspotStub::residue() const –> class std::shared_ptr<const class core::conformation::Residue>

set_filter(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStub, filter: pyrosetta.rosetta.protocols.filters.Filter) → None¶: C++: protocols::hotspot_hashing::HotspotStub::set_filter(class std::shared_ptr<const class protocols::filters::Filter>) –> void

set_scaffold_status(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStub, seqpos: int, status: pyrosetta.rosetta.protocols.hotspot_hashing.StubStatus) → None¶

Set status at position

C++: protocols::hotspot_hashing::HotspotStub::set_scaffold_status(const unsigned long, const enum protocols::hotspot_hashing::StubStatus) –> void

class pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet¶

Bases: pybind11_object

add_hotspot_constraints_to_pose(*args, **kwargs)¶

Overloaded function.

add_hotspot_constraints_to_pose(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, pose: pyrosetta.rosetta.core.pose.Pose, partner: int, hotspot_stub_set: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, CB_force_constant: float, worst_allowed_stub_bonus: float, apply_self_energies: bool, bump_cutoff: float) -> None
add_hotspot_constraints_to_pose(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, pose: pyrosetta.rosetta.core.pose.Pose, partner: int, hotspot_stub_set: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, CB_force_constant: float, worst_allowed_stub_bonus: float, apply_self_energies: bool, bump_cutoff: float, apply_ambiguous_constraints: bool) -> None

Sets up constraints using a given partner (auto choose packer task and fixed reference atom)

C++: protocols::hotspot_hashing::HotspotStubSet::add_hotspot_constraints_to_pose(class core::pose::Pose &, const unsigned long, class std::shared_ptr<class protocols::hotspot_hashing::HotspotStubSet>, const double &, const double &, const bool, const double &, const bool) –> void

add_hotspot_constraints_to_pose(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, pose: pyrosetta.rosetta.core.pose.Pose, fixed_atom: pyrosetta.rosetta.core.id.AtomID, packer_task: pyrosetta.rosetta.core.pack.task.PackerTask, hotspot_stub_set: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, CB_force_constant: float, worst_allowed_stub_bonus: float, apply_self_energies: bool, bump_cutoff: float) -> None
add_hotspot_constraints_to_pose(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, pose: pyrosetta.rosetta.core.pose.Pose, fixed_atom: pyrosetta.rosetta.core.id.AtomID, packer_task: pyrosetta.rosetta.core.pack.task.PackerTask, hotspot_stub_set: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, CB_force_constant: float, worst_allowed_stub_bonus: float, apply_self_energies: bool, bump_cutoff: float, apply_ambiguous_constraints: bool) -> None

Sets up constraints with user-supplied packer task and fixed reference atom

C++: protocols::hotspot_hashing::HotspotStubSet::add_hotspot_constraints_to_pose(class core::pose::Pose &, const class core::id::AtomID &, const class std::shared_ptr<const class core::pack::task::PackerTask>, class std::shared_ptr<class protocols::hotspot_hashing::HotspotStubSet>, const double &, const double &, const bool, const double &, const bool) –> void

add_hotspot_constraints_to_wholepose(*args, **kwargs)¶

Overloaded function.

add_hotspot_constraints_to_wholepose(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, pose: pyrosetta.rosetta.core.pose.Pose, partner: int, hotspot_stub_set: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, CB_force_constant: float, worst_allowed_stub_bonus: float, apply_self_energies: bool, bump_cutoff: float) -> None
add_hotspot_constraints_to_wholepose(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, pose: pyrosetta.rosetta.core.pose.Pose, partner: int, hotspot_stub_set: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, CB_force_constant: float, worst_allowed_stub_bonus: float, apply_self_energies: bool, bump_cutoff: float, apply_ambiguous_constraints: bool) -> None

C++: protocols::hotspot_hashing::HotspotStubSet::add_hotspot_constraints_to_wholepose(class core::pose::Pose &, const unsigned long, class std::shared_ptr<class protocols::hotspot_hashing::HotspotStubSet>, const double &, const double &, const bool, const double &, const bool) –> void

add_hotspot_constraints_to_wholepose(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, pose: pyrosetta.rosetta.core.pose.Pose, fixed_atom: pyrosetta.rosetta.core.id.AtomID, packer_task: pyrosetta.rosetta.core.pack.task.PackerTask, hotspot_stub_set: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, CB_force_constant: float, worst_allowed_stub_bonus: float, apply_self_energies: bool, bump_cutoff: float) -> None
add_hotspot_constraints_to_wholepose(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, pose: pyrosetta.rosetta.core.pose.Pose, fixed_atom: pyrosetta.rosetta.core.id.AtomID, packer_task: pyrosetta.rosetta.core.pack.task.PackerTask, hotspot_stub_set: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, CB_force_constant: float, worst_allowed_stub_bonus: float, apply_self_energies: bool, bump_cutoff: float, apply_ambiguous_constraints: bool) -> None

Sets up constraints with user-supplied packer task and fixed reference atom

C++: protocols::hotspot_hashing::HotspotStubSet::add_hotspot_constraints_to_wholepose(class core::pose::Pose &, const class core::id::AtomID &, const class std::shared_ptr<const class core::pack::task::PackerTask>, class std::shared_ptr<class protocols::hotspot_hashing::HotspotStubSet>, const double &, const double &, const bool, const double &, const bool) –> void

add_stub_(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, stub: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStub) → None¶: C++: protocols::hotspot_hashing::HotspotStubSet::add_stub_(class std::shared_ptr<const class protocols::hotspot_hashing::HotspotStub>) –> void

add_stub_set(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, stubset: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet) → None¶: C++: protocols::hotspot_hashing::HotspotStubSet::add_stub_set(const class protocols::hotspot_hashing::HotspotStubSet &) –> void

assign(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, rhs: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet) → pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet¶

Assigment operator, needed as copy constructor is specified

C++: protocols::hotspot_hashing::HotspotStubSet::operator=(const class protocols::hotspot_hashing::HotspotStubSet &) –> class protocols::hotspot_hashing::HotspotStubSet &

autofill(*args, **kwargs)¶

Overloaded function.

autofill(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, pose: pyrosetta.rosetta.core.pose.Pose, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction, n_stubs: int) -> None

fill the stub set with n_stubs each of A, R, N, D, E, Q, H, I, L, K, M, P, F, S, T, W, Y, and V

C++: protocols::hotspot_hashing::HotspotStubSet::autofill(const class core::pose::Pose &, class std::shared_ptr<const class core::scoring::ScoreFunction>, const unsigned long) –> void

autofill(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, pose: pyrosetta.rosetta.core.pose.Pose, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction, target: int, distance: float, n_stubs: int) -> None

C++: protocols::hotspot_hashing::HotspotStubSet::autofill(const class core::pose::Pose &, class std::shared_ptr<const class core::scoring::ScoreFunction>, const unsigned long, const double, const unsigned long) –> void

clear(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet) → None¶: C++: protocols::hotspot_hashing::HotspotStubSet::clear() –> void

cluster(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet) → pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet¶

cluster stubs, returning a new stubset of cluster centers for each residue

C++: protocols::hotspot_hashing::HotspotStubSet::cluster() –> class std::shared_ptr<class protocols::hotspot_hashing::HotspotStubSet>

colonyE(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet) → pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet¶

returns a new stub_set with stub scores recalculated by colony energy (Xiang, Soto, and Honig PNAS 2002)

C++: protocols::hotspot_hashing::HotspotStubSet::colonyE() –> class std::shared_ptr<class protocols::hotspot_hashing::HotspotStubSet>

constraints(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet) → pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t¶

return bbcst’s associatied with this stub set

C++: protocols::hotspot_hashing::HotspotStubSet::constraints() const –> class utility::vector1<class std::shared_ptr<const class core::scoring::constraints::Constraint>, class std::allocator<class std::shared_ptr<const class core::scoring::constraints::Constraint> > >

fill(*args, **kwargs)¶

Overloaded function.

fill(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, reference_pose: pyrosetta.rosetta.core.pose.Pose, scorefxn_in: pyrosetta.rosetta.core.scoring.ScoreFunction, residue_name3: str, n_stubs: int) -> None

fill the stub set with n_stubs by Rosetta residue name

C++: protocols::hotspot_hashing::HotspotStubSet::fill(const class core::pose::Pose &, class std::shared_ptr<const class core::scoring::ScoreFunction>, const std::string &, const unsigned long) –> void

fill(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, reference_pose: pyrosetta.rosetta.core.pose.Pose, scorefxn_in: pyrosetta.rosetta.core.scoring.ScoreFunction, target: int, distance: float, residue_name3: str, n_stubs: int) -> None

only keep stubs within a certain distance of a residue on the target pose.

C++: protocols::hotspot_hashing::HotspotStubSet::fill(const class core::pose::Pose &, class std::shared_ptr<const class core::scoring::ScoreFunction>, const unsigned long, const double, const std::string &, const unsigned long) –> void

filter(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, filter: pyrosetta.rosetta.protocols.filters.Filter) → None¶

set the filter to use for scaffold matching within this set

C++: protocols::hotspot_hashing::HotspotStubSet::filter(class std::shared_ptr<const class protocols::filters::Filter>) –> void

get_best_energy_stub(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet) → pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStub¶

gets the best energy stub in the set

C++: protocols::hotspot_hashing::HotspotStubSet::get_best_energy_stub() const –> class std::shared_ptr<const class protocols::hotspot_hashing::HotspotStub>

get_nearest_stub(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, stub: pyrosetta.rosetta.core.conformation.Residue) → pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStub¶

get the stub that’s nearest to a residue

C++: protocols::hotspot_hashing::HotspotStubSet::get_nearest_stub(class std::shared_ptr<const class core::conformation::Residue>) const –> class std::shared_ptr<const class protocols::hotspot_hashing::HotspotStub>

hotspot_length(*args, **kwargs)¶

Overloaded function.

hotspot_length(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet) -> int

set length of hotspot peptide used for finding stubs. Default=1, Hotspot stored in set will always be only 1 residue

C++: protocols::hotspot_hashing::HotspotStubSet::hotspot_length() const –> unsigned long

hotspot_length(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, length: int) -> None

C++: protocols::hotspot_hashing::HotspotStubSet::hotspot_length(const unsigned long) –> void

pair_with_scaffold(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, pose: pyrosetta.rosetta.core.pose.Pose, partner: int, filter: pyrosetta.rosetta.protocols.filters.Filter) → None¶

associate all stubs in the set with a scaffold partner

C++: protocols::hotspot_hashing::HotspotStubSet::pair_with_scaffold(const class core::pose::Pose &, const unsigned long, class std::shared_ptr<const class protocols::filters::Filter>) –> void

prepare_hashing_packer_task_(*args, **kwargs)¶

Overloaded function.

prepare_hashing_packer_task_(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.pack.task.PackerTask
prepare_hashing_packer_task_(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, pose: pyrosetta.rosetta.core.pose.Pose, chain_to_redesign: int) -> pyrosetta.rosetta.core.pack.task.PackerTask

C++: protocols::hotspot_hashing::HotspotStubSet::prepare_hashing_packer_task_(const class core::pose::Pose &, const unsigned long) –> class std::shared_ptr<class core::pack::task::PackerTask>

random_stub(*args, **kwargs)¶

Overloaded function.

random_stub(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet) -> pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStub

returns a random stub either from the entire set or based on residue name

C++: protocols::hotspot_hashing::HotspotStubSet::random_stub() –> class std::shared_ptr<class protocols::hotspot_hashing::HotspotStub>

random_stub(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, resname: str) -> pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStub

C++: protocols::hotspot_hashing::HotspotStubSet::random_stub(const std::string &) –> class std::shared_ptr<class protocols::hotspot_hashing::HotspotStub>

read_data(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, filename: str) → None¶

add to stubset by reading from a file

C++: protocols::hotspot_hashing::HotspotStubSet::read_data(const std::string &) –> void

remove_all_hotspot_constraints(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, pose: pyrosetta.rosetta.core.pose.Pose) → bool¶

remove all ambiguous constraints that contain backbone_stub_constraints from the supplied pose

C++: protocols::hotspot_hashing::HotspotStubSet::remove_all_hotspot_constraints(class core::pose::Pose &) const –> bool

remove_random_stubs_from_set(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, num_to_remove: int) → None¶: C++: protocols::hotspot_hashing::HotspotStubSet::remove_random_stubs_from_set(const int) –> void

remove_stub(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, stub: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStub) → bool¶

removes a single stub. Reports false if stub is not found

C++: protocols::hotspot_hashing::HotspotStubSet::remove_stub(class std::shared_ptr<const class protocols::hotspot_hashing::HotspotStub>) –> bool

rescore(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, pose: pyrosetta.rosetta.core.pose.Pose, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet¶

rescore all stubs in this set based on current flags (eg - sc_only() )

C++: protocols::hotspot_hashing::HotspotStubSet::rescore(const class core::pose::Pose &, class std::shared_ptr<const class core::scoring::ScoreFunction>) –> class std::shared_ptr<class protocols::hotspot_hashing::HotspotStubSet>

retrieve(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, residue_name3: str) → pyrosetta.rosetta.std.multimap_double_std_shared_ptr_protocols_hotspot_hashing_HotspotStub_t¶

retrieve all stubs with a given residue name

C++: protocols::hotspot_hashing::HotspotStubSet::retrieve(const std::string &) –> class std::multimap<double, class std::shared_ptr<class protocols::hotspot_hashing::HotspotStub>, struct std::less<double>, class std::allocator<struct std::pair<const double, class std::shared_ptr<class protocols::hotspot_hashing::HotspotStub> > > >

sc_only(*args, **kwargs)¶

Overloaded function.

sc_only(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet) -> bool

true if these stubs are sidechain-only (defaults true)

C++: protocols::hotspot_hashing::HotspotStubSet::sc_only() const –> bool

sc_only(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, sc_switch: bool) -> None

set whether or not sidechains are included

C++: protocols::hotspot_hashing::HotspotStubSet::sc_only(bool) –> void

score_threshold(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, threshold: float) → None¶

only accept stubs that score better than this threshold (default is -1.0)

C++: protocols::hotspot_hashing::HotspotStubSet::score_threshold(const double) –> void

set_chain_to_design(*args, **kwargs)¶

Overloaded function.

set_chain_to_design(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet) -> None
set_chain_to_design(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, chain_to_design: int) -> None

C++: protocols::hotspot_hashing::HotspotStubSet::set_chain_to_design(const unsigned long) –> void

size(*args, **kwargs)¶

Overloaded function.

size(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet) -> int

how many total stubs are in the set (all residues)?

C++: protocols::hotspot_hashing::HotspotStubSet::size() const –> unsigned long

size(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, resname: str) -> int

how many stubs are in the set by residue?

C++: protocols::hotspot_hashing::HotspotStubSet::size(const std::string &) –> unsigned long

subset(*args, **kwargs)¶

Overloaded function.

subset(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, residue_name3: str, scorecut: float) -> pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet

C++: protocols::hotspot_hashing::HotspotStubSet::subset(const std::string &, const double) –> class std::shared_ptr<class protocols::hotspot_hashing::HotspotStubSet>

subset(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, scorecut: float) -> pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet

build a new stubset containing stubs that pass a score cutoff

C++: protocols::hotspot_hashing::HotspotStubSet::subset(const double) const –> class std::shared_ptr<class protocols::hotspot_hashing::HotspotStubSet>

write_all(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, filename: str) → None¶

write all stubs contained in this set to filename

C++: protocols::hotspot_hashing::HotspotStubSet::write_all(const std::string &) const –> void

write_stub(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet, outstream: pyrosetta.rosetta.utility.io.ozstream, stub: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStub, tag: str) → None¶

write one stub with a user-supplied tag

C++: protocols::hotspot_hashing::HotspotStubSet::write_stub(class utility::io::ozstream &, class std::shared_ptr<const class protocols::hotspot_hashing::HotspotStub>, const std::string &) const –> void

class pyrosetta.rosetta.protocols.hotspot_hashing.LSMSearchPattern¶

Bases: SearchPattern

Searchpoints(self: pyrosetta.rosetta.protocols.hotspot_hashing.LSMSearchPattern) → pyrosetta.rosetta.utility.vector1_core_kinematics_Stub¶: C++: protocols::hotspot_hashing::LSMSearchPattern::Searchpoints() –> class utility::vector1<class core::kinematics::Stub, class std::allocator<class core::kinematics::Stub> >

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

static parse_lsm_spec(lsmstring: str, lsmspec: pyrosetta.rosetta.protocols.hotspot_hashing.VectorPair) → bool¶: C++: protocols::hotspot_hashing::LSMSearchPattern::parse_lsm_spec(std::string, class protocols::hotspot_hashing::VectorPair &) –> bool

class pyrosetta.rosetta.protocols.hotspot_hashing.PartitionedSearchPattern¶

Bases: SearchPattern

Searchpoints(self: pyrosetta.rosetta.protocols.hotspot_hashing.PartitionedSearchPattern) → pyrosetta.rosetta.utility.vector1_core_kinematics_Stub¶: C++: protocols::hotspot_hashing::PartitionedSearchPattern::Searchpoints() –> class utility::vector1<class core::kinematics::Stub, class std::allocator<class core::kinematics::Stub> >

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

class pyrosetta.rosetta.protocols.hotspot_hashing.RotationSearchPattern¶

Bases: SearchPattern

Searchpoints(self: pyrosetta.rosetta.protocols.hotspot_hashing.RotationSearchPattern) → pyrosetta.rosetta.utility.vector1_core_kinematics_Stub¶: C++: protocols::hotspot_hashing::RotationSearchPattern::Searchpoints() –> class utility::vector1<class core::kinematics::Stub, class std::allocator<class core::kinematics::Stub> >

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

generate_search_points(self: pyrosetta.rosetta.protocols.hotspot_hashing.RotationSearchPattern) → pyrosetta.rosetta.utility.vector1_core_kinematics_Stub¶: C++: protocols::hotspot_hashing::RotationSearchPattern::generate_search_points() –> class utility::vector1<class core::kinematics::Stub, class std::allocator<class core::kinematics::Stub> >

property searchpoints_¶

property x_max¶

property x_min¶

property x_sampling¶

property y_max¶

property y_min¶

property y_sampling¶

class pyrosetta.rosetta.protocols.hotspot_hashing.SICPatternAtTransform¶

Bases: SearchPattern

Searchpoints(self: pyrosetta.rosetta.protocols.hotspot_hashing.SICPatternAtTransform) → pyrosetta.rosetta.utility.vector1_core_kinematics_Stub¶: C++: protocols::hotspot_hashing::SICPatternAtTransform::Searchpoints() –> class utility::vector1<class core::kinematics::Stub, class std::allocator<class core::kinematics::Stub> >

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

class pyrosetta.rosetta.protocols.hotspot_hashing.SearchPattern¶

Bases: pybind11_object

Searchpoints(self: pyrosetta.rosetta.protocols.hotspot_hashing.SearchPattern) → pyrosetta.rosetta.utility.vector1_core_kinematics_Stub¶: C++: protocols::hotspot_hashing::SearchPattern::Searchpoints() –> class utility::vector1<class core::kinematics::Stub, class std::allocator<class core::kinematics::Stub> >

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

class pyrosetta.rosetta.protocols.hotspot_hashing.SearchPatternExpansion¶

Bases: SearchPattern

Searchpoints(self: pyrosetta.rosetta.protocols.hotspot_hashing.SearchPatternExpansion) → pyrosetta.rosetta.utility.vector1_core_kinematics_Stub¶: C++: protocols::hotspot_hashing::SearchPatternExpansion::Searchpoints() –> class utility::vector1<class core::kinematics::Stub, class std::allocator<class core::kinematics::Stub> >

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

expand(self: pyrosetta.rosetta.protocols.hotspot_hashing.SearchPatternExpansion, source: pyrosetta.rosetta.core.kinematics.Stub) → pyrosetta.rosetta.utility.vector1_core_kinematics_Stub¶: C++: protocols::hotspot_hashing::SearchPatternExpansion::expand(class core::kinematics::Stub) –> class utility::vector1<class core::kinematics::Stub, class std::allocator<class core::kinematics::Stub> >

class pyrosetta.rosetta.protocols.hotspot_hashing.SearchPatternRotSetOp¶

Bases: RigidBodyMoveBaseRSO

alter_rotamer_set(self: pyrosetta.rosetta.protocols.toolbox.rotamer_set_operations.RigidBodyMoveBaseRSO, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, ptask: pyrosetta.rosetta.core.pack.task.PackerTask, packer_neighbor_graph: pyrosetta.rosetta.utility.graph.Graph, rotamer_set: pyrosetta.rosetta.core.pack.rotamer_set.RotamerSet) → None¶

Adds additional rotamers at each rb conf.

fairly simple: iterate over the rotamers in the rotamer_set, superimpose each of them onto all the internally stored rigid body confs, and then add the newly generated rotamers to the rotamer_set

Recalculates chi-angle expansion via call to RotamerSet::extra_chi_samples and then generate candidate rotamers from each rb conf via SingleResidueRotamerLibrary::fill_rotamer_vector if rotamer library is available for the residue type, else just adds the alternate confs.

Does not have full safety checks to make sure all the rotamers in the set are of the same residue type as the internally stored ones, i.e. that no user sets this position to designing in the task

C++: protocols::toolbox::rotamer_set_operations::RigidBodyMoveBaseRSO::alter_rotamer_set(const class core::pose::Pose &, const class core::scoring::ScoreFunction &, const class core::pack::task::PackerTask &, class std::shared_ptr<const class utility::graph::Graph>, class core::pack::rotamer_set::RotamerSet &) –> void

assign(self: pyrosetta.rosetta.core.pack.rotamer_set.RotamerSetOperation, : pyrosetta.rosetta.core.pack.rotamer_set.RotamerSetOperation) → pyrosetta.rosetta.core.pack.rotamer_set.RotamerSetOperation¶: C++: core::pack::rotamer_set::RotamerSetOperation::operator=(const class core::pack::rotamer_set::RotamerSetOperation &) –> class core::pack::rotamer_set::RotamerSetOperation &

clone(self: pyrosetta.rosetta.protocols.hotspot_hashing.SearchPatternRotSetOp) → pyrosetta.rosetta.core.pack.rotamer_set.RotamerSetOperation¶: C++: protocols::hotspot_hashing::SearchPatternRotSetOp::clone() const –> class std::shared_ptr<class core::pack::rotamer_set::RotamerSetOperation>

static determine_largest_nbr_atom_distance(target_res: pyrosetta.rosetta.core.conformation.Residue, alternate_confs: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_conformation_Residue_t) → float¶

returns the largest observed distance between the nbr atom: in the target res and the nbr atom in any of the candidate rb confs

C++: protocols::toolbox::rotamer_set_operations::RigidBodyMoveBaseRSO::determine_largest_nbr_atom_distance(const class core::conformation::Residue &, class utility::vector1<class std::shared_ptr<const class core::conformation::Residue>, class std::allocator<class std::shared_ptr<const class core::conformation::Residue> > >) –> double

get_rigid_body_confs(self: pyrosetta.rosetta.protocols.hotspot_hashing.SearchPatternRotSetOp, pose: pyrosetta.rosetta.core.pose.Pose, ptask: pyrosetta.rosetta.core.pack.task.PackerTask, residue_index: int) → pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_conformation_Residue_t¶: C++: protocols::hotspot_hashing::SearchPatternRotSetOp::get_rigid_body_confs(const class core::pose::Pose &, const class core::pack::task::PackerTask &, unsigned long) –> class utility::vector1<class std::shared_ptr<const class core::conformation::Residue>, class std::allocator<class std::shared_ptr<const class core::conformation::Residue> > >

increase_packer_residue_radius(self: pyrosetta.rosetta.protocols.hotspot_hashing.SearchPatternRotSetOp, pose: pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pack.task.PackerTask, residue_index: int) → float¶: C++: protocols::hotspot_hashing::SearchPatternRotSetOp::increase_packer_residue_radius(const class core::pose::Pose &, class std::shared_ptr<const class core::pack::task::PackerTask>, unsigned long) –> double

class pyrosetta.rosetta.protocols.hotspot_hashing.SearchPatternTransform¶

Bases: SearchPattern

Searchpoints(self: pyrosetta.rosetta.protocols.hotspot_hashing.SearchPatternTransform) → pyrosetta.rosetta.utility.vector1_core_kinematics_Stub¶: C++: protocols::hotspot_hashing::SearchPatternTransform::Searchpoints() –> class utility::vector1<class core::kinematics::Stub, class std::allocator<class core::kinematics::Stub> >

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

transform(self: pyrosetta.rosetta.protocols.hotspot_hashing.SearchPatternTransform, source: pyrosetta.rosetta.core.kinematics.Stub) → pyrosetta.rosetta.core.kinematics.Stub¶: C++: protocols::hotspot_hashing::SearchPatternTransform::transform(class core::kinematics::Stub) –> class core::kinematics::Stub

class pyrosetta.rosetta.protocols.hotspot_hashing.SphericalRotationSearchPattern¶

Bases: SearchPattern

Searchpoints(self: pyrosetta.rosetta.protocols.hotspot_hashing.SphericalRotationSearchPattern) → pyrosetta.rosetta.utility.vector1_core_kinematics_Stub¶: C++: protocols::hotspot_hashing::SphericalRotationSearchPattern::Searchpoints() –> class utility::vector1<class core::kinematics::Stub, class std::allocator<class core::kinematics::Stub> >

property altitude_max¶

property altitude_min¶

property altitude_rotation_sampling¶

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

property azmiuth_max¶

property azmiuth_min¶

property azmiuth_rotation_sampling¶

generate_search_points(self: pyrosetta.rosetta.protocols.hotspot_hashing.SphericalRotationSearchPattern) → pyrosetta.rosetta.utility.vector1_core_kinematics_Stub¶: C++: protocols::hotspot_hashing::SphericalRotationSearchPattern::generate_search_points() –> class utility::vector1<class core::kinematics::Stub, class std::allocator<class core::kinematics::Stub> >

property polar_max¶

property polar_min¶

property polar_rotation_sampling¶

property searchpoints_¶

class pyrosetta.rosetta.protocols.hotspot_hashing.StubGenerator¶

Bases: pybind11_object

static getStubByName(name: str) → pyrosetta.rosetta.core.conformation.Residue¶: C++: protocols::hotspot_hashing::StubGenerator::getStubByName(std::string) –> class std::shared_ptr<class core::conformation::Residue>

static moveFromStubFrame(residue: pyrosetta.rosetta.core.conformation.Residue, transform: pyrosetta.rosetta.core.kinematics.Stub) → None¶: C++: protocols::hotspot_hashing::StubGenerator::moveFromStubFrame(class std::shared_ptr<class core::conformation::Residue>, class core::kinematics::Stub) –> void

static moveIntoStubFrame(residue: pyrosetta.rosetta.core.conformation.Residue, transform: pyrosetta.rosetta.core.kinematics.Stub) → None¶: C++: protocols::hotspot_hashing::StubGenerator::moveIntoStubFrame(class std::shared_ptr<class core::conformation::Residue>, class core::kinematics::Stub) –> void

static placeResidueAtTransform(pose: pyrosetta.rosetta.core.pose.Pose, sourceResidue: pyrosetta.rosetta.core.conformation.Residue, transform: pyrosetta.rosetta.core.kinematics.Stub, residuejumpindex: int, residueindex: int) → None¶: C++: protocols::hotspot_hashing::StubGenerator::placeResidueAtTransform(class core::pose::Pose &, class std::shared_ptr<const class core::conformation::Residue>, class core::kinematics::Stub, unsigned long &, unsigned long &) –> void

static placeResidueOnPose(pose: pyrosetta.rosetta.core.pose.Pose, residue: pyrosetta.rosetta.core.conformation.Residue) → None¶: C++: protocols::hotspot_hashing::StubGenerator::placeResidueOnPose(class core::pose::Pose &, class std::shared_ptr<const class core::conformation::Residue>) –> void

static residueStubCentroid(residue: pyrosetta.rosetta.core.conformation.Residue) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: protocols::hotspot_hashing::StubGenerator::residueStubCentroid(const class std::shared_ptr<const class core::conformation::Residue>) –> class numeric::xyzVector<double>

static residueStubCentroidFrame(residue: pyrosetta.rosetta.core.conformation.Residue) → pyrosetta.rosetta.core.kinematics.Stub¶: C++: protocols::hotspot_hashing::StubGenerator::residueStubCentroidFrame(const class std::shared_ptr<const class core::conformation::Residue>) –> class core::kinematics::Stub

static residueStubOrientFrame(residue: pyrosetta.rosetta.core.conformation.Residue) → pyrosetta.rosetta.core.kinematics.Stub¶: C++: protocols::hotspot_hashing::StubGenerator::residueStubOrientFrame(const class std::shared_ptr<const class core::conformation::Residue>) –> class core::kinematics::Stub

class pyrosetta.rosetta.protocols.hotspot_hashing.StubStatus¶

Bases: pybind11_object

Members:

reject

accept

unchecked

accept = <StubStatus.accept: 2>¶

property name¶

reject = <StubStatus.reject: 1>¶

unchecked = <StubStatus.unchecked: 3>¶

property value¶

class pyrosetta.rosetta.protocols.hotspot_hashing.SurfaceSearchPattern¶

Bases: SearchPattern

Searchpoints(self: pyrosetta.rosetta.protocols.hotspot_hashing.SurfaceSearchPattern) → pyrosetta.rosetta.utility.vector1_core_kinematics_Stub¶: C++: protocols::hotspot_hashing::SurfaceSearchPattern::Searchpoints() –> class utility::vector1<class core::kinematics::Stub, class std::allocator<class core::kinematics::Stub> >

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

surface_vectors(self: pyrosetta.rosetta.protocols.hotspot_hashing.SurfaceSearchPattern) → pyrosetta.rosetta.utility.vector1_protocols_hotspot_hashing_VectorPair¶: C++: protocols::hotspot_hashing::SurfaceSearchPattern::surface_vectors() –> class utility::vector1<class protocols::hotspot_hashing::VectorPair, class std::allocator<class protocols::hotspot_hashing::VectorPair> >

class pyrosetta.rosetta.protocols.hotspot_hashing.TestPattern¶

Bases: SearchPattern

Searchpoints(self: pyrosetta.rosetta.protocols.hotspot_hashing.TestPattern) → pyrosetta.rosetta.utility.vector1_core_kinematics_Stub¶: C++: protocols::hotspot_hashing::TestPattern::Searchpoints() –> class utility::vector1<class core::kinematics::Stub, class std::allocator<class core::kinematics::Stub> >

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

class pyrosetta.rosetta.protocols.hotspot_hashing.VectorPair¶

Bases: pybind11_object

assign(self: pyrosetta.rosetta.protocols.hotspot_hashing.VectorPair, : pyrosetta.rosetta.protocols.hotspot_hashing.VectorPair) → pyrosetta.rosetta.protocols.hotspot_hashing.VectorPair¶

Assignment operator.

C++: protocols::hotspot_hashing::VectorPair::operator=(const class protocols::hotspot_hashing::VectorPair &) –> class protocols::hotspot_hashing::VectorPair &

property direction¶

property position¶

pyrosetta.rosetta.protocols.hotspot_hashing.remove_hotspot_constraints_from_pose(: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t¶

utility function for deleting all backbone stub constraints from a pose.: Returns the removed constraints (ambiguous).

C++: protocols::hotspot_hashing::remove_hotspot_constraints_from_pose(class core::pose::Pose &) –> class utility::vector1<class std::shared_ptr<const class core::scoring::constraints::Constraint>, class std::allocator<class std::shared_ptr<const class core::scoring::constraints::Constraint> > >

pyrosetta.rosetta.protocols.hotspot_hashing.residue_sc_rmsd_no_super(*args, **kwargs)¶

Overloaded function.

residue_sc_rmsd_no_super(res1: pyrosetta.rosetta.core.conformation.Residue, res2: pyrosetta.rosetta.core.conformation.Residue) -> float
residue_sc_rmsd_no_super(res1: pyrosetta.rosetta.core.conformation.Residue, res2: pyrosetta.rosetta.core.conformation.Residue, fxnal_group_only: bool) -> float

utility function to calculate per-residue sidechain rmsd without superposition

C++: protocols::hotspot_hashing::residue_sc_rmsd_no_super(class std::shared_ptr<const class core::conformation::Residue>, class std::shared_ptr<const class core::conformation::Residue>, const bool) –> double

pyrosetta.rosetta.protocols.hotspot_hashing.stub_from_points(stream: pyrosetta.rosetta.std.istream, stub: pyrosetta.rosetta.core.kinematics.Stub) → pyrosetta.rosetta.std.istream¶: C++: protocols::hotspot_hashing::stub_from_points(std::istream &, class core::kinematics::Stub &) –> std::istream &

pyrosetta.rosetta.protocols.hotspot_hashing.stub_tgt_angle(pose: pyrosetta.rosetta.core.pose.Pose, stub: pyrosetta.rosetta.core.conformation.Residue, target_res: int) → float¶

utility function to make sure stub’s Cbeta is not pointed away from the target.

C++: protocols::hotspot_hashing::stub_tgt_angle(const class core::pose::Pose &, class std::shared_ptr<const class core::conformation::Residue>, const unsigned long) –> double

pyrosetta.rosetta.protocols.hotspot_hashing.stub_to_points(stream: pyrosetta.rosetta.std.ostream, stub: pyrosetta.rosetta.core.kinematics.Stub) → pyrosetta.rosetta.std.ostream¶: C++: protocols::hotspot_hashing::stub_to_points(std::ostream &, const class core::kinematics::Stub &) –> std::ostream &