hotspot_hashing

Bindings for protocols::hotspot_hashing namespace

class pyrosetta.rosetta.protocols.hotspot_hashing.AddSearchPatternRotSetOp

Bases: pyrosetta.rosetta.core.pack.task.operation.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: pyrosetta.rosetta.protocols.hotspot_hashing.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: pyrosetta.rosetta.protocols.hotspot_hashing.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: pyrosetta.rosetta.protocols.hotspot_hashing.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_builtins.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_builtins.pybind11_object

add_hotspot_constraints_to_pose(*args, **kwargs)

Overloaded function.

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

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

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

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

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

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

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

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

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

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

begin(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet) __gnu_cxx::__normal_iterator<std::pair<std::string, std::pair<double, std::shared_ptr<protocols::hotspot_hashing::HotspotStub> > >*, std::vector<std::pair<std::string, std::pair<double, std::shared_ptr<protocols::hotspot_hashing::HotspotStub> > >, std::allocator<std::pair<std::string, std::pair<double, std::shared_ptr<protocols::hotspot_hashing::HotspotStub> > > > > >

C++: protocols::hotspot_hashing::HotspotStubSet::begin() –> class __gnu_cxx::__normal_iterator<struct std::pair<std::string, struct std::pair<double, class std::shared_ptr<class protocols::hotspot_hashing::HotspotStub> > > *, class std::vector<struct std::pair<std::string, struct std::pair<double, class std::shared_ptr<class protocols::hotspot_hashing::HotspotStub> > >, class std::allocator<struct std::pair<std::string, struct std::pair<double, class std::shared_ptr<class protocols::hotspot_hashing::HotspotStub> > > > > >

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

end(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet) __gnu_cxx::__normal_iterator<std::pair<std::string, std::pair<double, std::shared_ptr<protocols::hotspot_hashing::HotspotStub> > >*, std::vector<std::pair<std::string, std::pair<double, std::shared_ptr<protocols::hotspot_hashing::HotspotStub> > >, std::allocator<std::pair<std::string, std::pair<double, std::shared_ptr<protocols::hotspot_hashing::HotspotStub> > > > > >

C++: protocols::hotspot_hashing::HotspotStubSet::end() –> class __gnu_cxx::__normal_iterator<struct std::pair<std::string, struct std::pair<double, class std::shared_ptr<class protocols::hotspot_hashing::HotspotStub> > > *, class std::vector<struct std::pair<std::string, struct std::pair<double, class std::shared_ptr<class protocols::hotspot_hashing::HotspotStub> > >, class std::allocator<struct std::pair<std::string, struct std::pair<double, class std::shared_ptr<class protocols::hotspot_hashing::HotspotStub> > > > > >

fill(*args, **kwargs)

Overloaded function.

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

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

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

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

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

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

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

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

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

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

  1. set_chain_to_design(self: pyrosetta.rosetta.protocols.hotspot_hashing.HotspotStubSet) -> None

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

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

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

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

  1. 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: pyrosetta.rosetta.protocols.hotspot_hashing.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: pyrosetta.rosetta.protocols.hotspot_hashing.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: pyrosetta.rosetta.protocols.hotspot_hashing.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: pyrosetta.rosetta.protocols.hotspot_hashing.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_builtins.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: pyrosetta.rosetta.protocols.hotspot_hashing.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: pyrosetta.rosetta.protocols.toolbox.rotamer_set_operations.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: pyrosetta.rosetta.protocols.hotspot_hashing.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: pyrosetta.rosetta.protocols.hotspot_hashing.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_builtins.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_builtins.pybind11_object

Members:

reject

accept

unchecked

accept = <StubStatus.accept: 2>
property name
reject = <StubStatus.reject: 1>
unchecked = <StubStatus.unchecked: 3>
class pyrosetta.rosetta.protocols.hotspot_hashing.SurfaceSearchPattern

Bases: pyrosetta.rosetta.protocols.hotspot_hashing.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: pyrosetta.rosetta.protocols.hotspot_hashing.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_builtins.pybind11_object

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

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.

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

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