interaction_graph

Bindings for core::pack::interaction_graph namespace

class pyrosetta.rosetta.core.pack.interaction_graph.DotSphere

Bases: pybind11_builtins.pybind11_object

Represents the sphere of dots on the vdW surface of an atom, for use in the LeGrand and Merz method of calculating SASA.

For every atom in a protein, the vdW surface is patterned with dots. Each dot has to keep track of how many other residues are “covering” this dot. So, that’s 1 character for each dot. Each character is the count of the number of residues overlapping with this dot. An assumption we’re making here is that a single atom (or really, dot) will never be covered by more than 255 residues.

In this implementation of the LeGrand and Merz algorithm, we’re going to be using 162 dots per atom. Turns out that you can distribute 162 dots evenly on the surface of a sphere.

This class is extremely simple. The RotamerDots class below does all the work of tying a particular residues atoms to DotSpheres. As a matter of fact, DotSphere doesn’t even know what atom it’s representing. It just has the one C-style array for the coverage count and that’s it.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__iadd__(self: pyrosetta.rosetta.core.pack.interaction_graph.DotSphere, rhs: pyrosetta.rosetta.core.pack.interaction_graph.DotSphere) → pyrosetta.rosetta.core.pack.interaction_graph.DotSphere

C++: core::pack::interaction_graph::DotSphere::operator+=(const class core::pack::interaction_graph::DotSphere &) –> const class core::pack::interaction_graph::DotSphere &

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.pack.interaction_graph.DotSphere) -> None
2. __init__(self: pyrosetta.rosetta.core.pack.interaction_graph.DotSphere, arg0: pyrosetta.rosetta.core.pack.interaction_graph.DotSphere) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__isub__(self: pyrosetta.rosetta.core.pack.interaction_graph.DotSphere, rhs: pyrosetta.rosetta.core.pack.interaction_graph.DotSphere) → pyrosetta.rosetta.core.pack.interaction_graph.DotSphere

C++: core::pack::interaction_graph::DotSphere::operator-=(const class core::pack::interaction_graph::DotSphere &) –> const class core::pack::interaction_graph::DotSphere &

__le__

Return self<=value.

__lt__

Return self<value.

__ne__(self: pyrosetta.rosetta.core.pack.interaction_graph.DotSphere, rhs: pyrosetta.rosetta.core.pack.interaction_graph.DotSphere) → bool

C++: core::pack::interaction_graph::DotSphere::operator!=(const class core::pack::interaction_graph::DotSphere &) –> bool

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__(self: pyrosetta.rosetta.core.pack.interaction_graph.DotSphere) → str

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

assign(self: pyrosetta.rosetta.core.pack.interaction_graph.DotSphere, rhs: pyrosetta.rosetta.core.pack.interaction_graph.DotSphere) → pyrosetta.rosetta.core.pack.interaction_graph.DotSphere

C++: core::pack::interaction_graph::DotSphere::operator=(const class core::pack::interaction_graph::DotSphere &) –> class core::pack::interaction_graph::DotSphere &

count_num_covered(self: pyrosetta.rosetta.core.pack.interaction_graph.DotSphere) → None

C++: core::pack::interaction_graph::DotSphere::count_num_covered() const –> void

get_dot_covered(self: pyrosetta.rosetta.core.pack.interaction_graph.DotSphere, dot_index: int) → bool

C++: core::pack::interaction_graph::DotSphere::get_dot_covered(unsigned long) const –> bool

get_num_covered(self: pyrosetta.rosetta.core.pack.interaction_graph.DotSphere) → int

C++: core::pack::interaction_graph::DotSphere::get_num_covered() const –> unsigned long

get_num_uncovered(self: pyrosetta.rosetta.core.pack.interaction_graph.DotSphere) → int

C++: core::pack::interaction_graph::DotSphere::get_num_uncovered() const –> unsigned long

get_total_dots(self: pyrosetta.rosetta.core.pack.interaction_graph.DotSphere) → int

C++: core::pack::interaction_graph::DotSphere::get_total_dots() const –> unsigned long

print(self: pyrosetta.rosetta.core.pack.interaction_graph.DotSphere, os: pyrosetta.rosetta.std.ostream) → None

C++: core::pack::interaction_graph::DotSphere::print(class std::basic_ostream<char> &) const –> void

zero(self: pyrosetta.rosetta.core.pack.interaction_graph.DotSphere) → None

C++: core::pack::interaction_graph::DotSphere::zero() –> void

class pyrosetta.rosetta.core.pack.interaction_graph.DoubleLazyInteractionGraph

Bases: pyrosetta.rosetta.core.pack.interaction_graph.OnTheFlyInteractionGraph

The double lazy interaction graph is primarily useful for multistate design where one is interested in knowing at particular edge, all of the rotamer pair energies for a particular amino acid assignment. The double lazy interaction graph is lazy in two ways: first, in delaying the computation of rotamer pair energies until they are needed, and second, in delaying the allocation of memory for rotamer pair energies until that memory is needed. The DLIG will do one of two things once it allocates space for a block of rotamer pairs: 1) In its standard operating behavior, it will leave that space allocated until the graph is destroyed, which means that the energies it stores in that block will never be computed more than once; or 2) In its alternate operating behavior, the LMIG will deallocate some of those blocks to make sure that it never uses more than some maximum amount of memory on RPEs.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.core.pack.interaction_graph.DoubleLazyInteractionGraph, numNodes: int) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

aa_submatrix_energies_retrievable(self: pyrosetta.rosetta.core.pack.interaction_graph.DoubleLazyInteractionGraph) → bool

Override the FixedBBInteractionGraph class’s implementation of this function

to return ‘true’.

C++: core::pack::interaction_graph::DoubleLazyInteractionGraph::aa_submatrix_energies_retrievable() const –> bool

aatype_for_node_state(self: pyrosetta.rosetta.core.pack.interaction_graph.DoubleLazyInteractionGraph, node_ind: int, node_state: int) → int

C++: core::pack::interaction_graph::DoubleLazyInteractionGraph::aatype_for_node_state(int, int) const –> int

add_edge(self: pyrosetta.rosetta.core.pack.interaction_graph.InteractionGraphBase, node1: int, node2: int) → None

C++: core::pack::interaction_graph::InteractionGraphBase::add_edge(int, int) –> void

add_to_nodes_one_body_energy(*args, **kwargs)

Overloaded function.

1. add_to_nodes_one_body_energy(self: pyrosetta.rosetta.core.pack.interaction_graph.InteractionGraphBase, node_ind: int, one_body_energies: pyrosetta.rosetta.utility.vector1_float) -> None

C++: core::pack::interaction_graph::InteractionGraphBase::add_to_nodes_one_body_energy(int, const class utility::vector1<float, class std::allocator<float> > &) –> void

2. add_to_nodes_one_body_energy(self: pyrosetta.rosetta.core.pack.interaction_graph.InteractionGraphBase, node_ind: int, one_body_energies: ObjexxFCL::FArray1<float>) -> None

C++: core::pack::interaction_graph::InteractionGraphBase::add_to_nodes_one_body_energy(int, const class ObjexxFCL::FArray1<float> &) –> void

3. add_to_nodes_one_body_energy(self: pyrosetta.rosetta.core.pack.interaction_graph.InteractionGraphBase, node_ind: int, state_id: int, one_body_energy: float) -> None

interface to PrecomputedPairEnergiesNode::add_to_nodes_one_body_energy

C++: core::pack::interaction_graph::InteractionGraphBase::add_to_nodes_one_body_energy(int, int, const float) –> void

add_to_one_body_energies(self: pyrosetta.rosetta.core.pack.interaction_graph.InteractionGraphBase, one_body_energies: ObjexxFCL::FArray1<float>) → None

C++: core::pack::interaction_graph::InteractionGraphBase::add_to_one_body_energies(class ObjexxFCL::FArray1<float> &) –> void

add_to_one_body_energy_for_node_state(self: pyrosetta.rosetta.core.pack.interaction_graph.OnTheFlyInteractionGraph, node_ind: int, state: int, one_body_energy: float) → None

C++: core::pack::interaction_graph::OnTheFlyInteractionGraph::add_to_one_body_energy_for_node_state(int, int, float) –> void

any_vertex_state_unassigned(self: pyrosetta.rosetta.core.pack.interaction_graph.InteractionGraphBase) → bool

C++: core::pack::interaction_graph::InteractionGraphBase::any_vertex_state_unassigned() const –> bool

assign(self: pyrosetta.rosetta.core.pack.interaction_graph.AnnealableGraphBase, : pyrosetta.rosetta.core.pack.interaction_graph.AnnealableGraphBase) → pyrosetta.rosetta.core.pack.interaction_graph.AnnealableGraphBase

C++: core::pack::interaction_graph::AnnealableGraphBase::operator=(const class core::pack::interaction_graph::AnnealableGraphBase &) –> class core::pack::interaction_graph::AnnealableGraphBase &

blanket_assign_state_0(self: pyrosetta.rosetta.core.pack.interaction_graph.DoubleLazyInteractionGraph) → None

C++: core::pack::interaction_graph::DoubleLazyInteractionGraph::blanket_assign_state_0() –> void

commit_considered_substitution(self: pyrosetta.rosetta.core.pack.interaction_graph.DoubleLazyInteractionGraph) → float

C++: core::pack::interaction_graph::DoubleLazyInteractionGraph::commit_considered_substitution() –> float

consider_substitution(self: pyrosetta.rosetta.core.pack.interaction_graph.DoubleLazyInteractionGraph, node_ind: int, new_state: int, delta_energy: float, prev_energy_for_node: float) → None

C++: core::pack::interaction_graph::DoubleLazyInteractionGraph::consider_substitution(int, int, float &, float &) –> void

count_connected_components_and_initialize_vertex_groups(self: pyrosetta.rosetta.core.pack.interaction_graph.InteractionGraphBase) → int

C++: core::pack::interaction_graph::InteractionGraphBase::count_connected_components_and_initialize_vertex_groups() –> int

count_dynamic_memory(self: pyrosetta.rosetta.core.pack.interaction_graph.DoubleLazyInteractionGraph) → int

C++: core::pack::interaction_graph::DoubleLazyInteractionGraph::count_dynamic_memory() const –> unsigned int

count_static_memory(self: pyrosetta.rosetta.core.pack.interaction_graph.DoubleLazyInteractionGraph) → int

C++: core::pack::interaction_graph::DoubleLazyInteractionGraph::count_static_memory() const –> unsigned int

create_new_edge(self: pyrosetta.rosetta.core.pack.interaction_graph.InteractionGraphBase, index1: int, index2: int) → pyrosetta.rosetta.core.pack.interaction_graph.EdgeBase

C++: core::pack::interaction_graph::InteractionGraphBase::create_new_edge(int, int) –> class core::pack::interaction_graph::EdgeBase *

create_new_node(self: pyrosetta.rosetta.core.pack.interaction_graph.InteractionGraphBase, node_index: int, num_states: int) → pyrosetta.rosetta.core.pack.interaction_graph.NodeBase

C++: core::pack::interaction_graph::InteractionGraphBase::create_new_node(int, int) –> class core::pack::interaction_graph::NodeBase *

distinguish_backbone_and_sidechain_for_node(*args, **kwargs)

Overloaded function.

1. distinguish_backbone_and_sidechain_for_node(self: pyrosetta.rosetta.core.pack.interaction_graph.OnTheFlyInteractionGraph, node: int) -> bool

C++: core::pack::interaction_graph::OnTheFlyInteractionGraph::distinguish_backbone_and_sidechain_for_node(int) const –> bool

2. distinguish_backbone_and_sidechain_for_node(self: pyrosetta.rosetta.core.pack.interaction_graph.OnTheFlyInteractionGraph, node: int, setting: bool) -> None

C++: core::pack::interaction_graph::OnTheFlyInteractionGraph::distinguish_backbone_and_sidechain_for_node(int, bool) –> void

drop_all_edges_for_node(self: pyrosetta.rosetta.core.pack.interaction_graph.InteractionGraphBase, node: int) → None

C++: core::pack::interaction_graph::InteractionGraphBase::drop_all_edges_for_node(int) –> void

edge_list_iterator_at_end(self: pyrosetta.rosetta.core.pack.interaction_graph.InteractionGraphBase) → bool

test: have we arrived at the edge list end?

C++: core::pack::interaction_graph::InteractionGraphBase::edge_list_iterator_at_end() const –> bool

find_edge(self: pyrosetta.rosetta.core.pack.interaction_graph.InteractionGraphBase, node1: int, node2: int) → pyrosetta.rosetta.core.pack.interaction_graph.EdgeBase

C++: core::pack::interaction_graph::InteractionGraphBase::find_edge(int, int) –> class core::pack::interaction_graph::EdgeBase *

force_aa_neighbors_for_edge(self: pyrosetta.rosetta.core.pack.interaction_graph.FixedBBInteractionGraph, node1: int, node2: int, node1aa: int, node2aa: int) → None

interface to FixedBBEdge::force_aa_neighbors

C++: core::pack::interaction_graph::FixedBBInteractionGraph::force_aa_neighbors_for_edge(int, int, int, int) –> void

force_all_aa_neighbors_for_edge(self: pyrosetta.rosetta.core.pack.interaction_graph.FixedBBInteractionGraph, node1: int, node2: int) → None

interface to PDEdge::force_aa_neighbors

C++: core::pack::interaction_graph::FixedBBInteractionGraph::force_all_aa_neighbors_for_edge(int, int) –> void

getTotalMemoryUsage(self: pyrosetta.rosetta.core.pack.interaction_graph.InteractionGraphBase) → int

C++: core::pack::interaction_graph::InteractionGraphBase::getTotalMemoryUsage() const –> unsigned int

get_aa_submatrix_energies_for_edge(self: pyrosetta.rosetta.core.pack.interaction_graph.DoubleLazyInteractionGraph, node1: int, node2: int, node1aa: int, node2aa: int) → ObjexxFCL::FArray2D<float>

C++: core::pack::interaction_graph::DoubleLazyInteractionGraph::get_aa_submatrix_energies_for_edge(int, int, int, int) const –> class ObjexxFCL::FArray2D<float>

get_edge(self: pyrosetta.rosetta.core.pack.interaction_graph.InteractionGraphBase) → pyrosetta.rosetta.core.pack.interaction_graph.EdgeBase

return a const reference to an edge pointed at by the list iterator

C++: core::pack::interaction_graph::InteractionGraphBase::get_edge() const –> const class core::pack::interaction_graph::EdgeBase &

get_edge_exists(self: pyrosetta.rosetta.core.pack.interaction_graph.InteractionGraphBase, node1: int, node2: int) → bool

C++: core::pack::interaction_graph::InteractionGraphBase::get_edge_exists(int, int) –> bool

get_edge_list_begin(self: pyrosetta.rosetta.core.pack.interaction_graph.InteractionGraphBase) → std::_List_iterator<core::pack::interaction_graph::EdgeBase*>

C++: core::pack::interaction_graph::InteractionGraphBase::get_edge_list_begin() –> struct std::_List_iterator<class core::pack::interaction_graph::EdgeBase *>

get_edge_list_end(self: pyrosetta.rosetta.core.pack.interaction_graph.InteractionGraphBase) → std::_List_const_iterator<core::pack::interaction_graph::EdgeBase*>

C++: core::pack::interaction_graph::InteractionGraphBase::get_edge_list_end() const –> struct std::_List_const_iterator<class core::pack::interaction_graph::EdgeBase *>

get_edge_memory_usage(self: pyrosetta.rosetta.core.pack.interaction_graph.DoubleLazyInteractionGraph) → int

C++: core::pack::interaction_graph::DoubleLazyInteractionGraph::get_edge_memory_usage() const –> int

get_edge_weight(self: pyrosetta.rosetta.core.pack.interaction_graph.InteractionGraphBase, node1: int, node2: int) → float

C++: core::pack::interaction_graph::InteractionGraphBase::get_edge_weight(int, int) const –> double

get_energy_current_state_assignment(self: pyrosetta.rosetta.core.pack.interaction_graph.DoubleLazyInteractionGraph) → float

C++: core::pack::interaction_graph::DoubleLazyInteractionGraph::get_energy_current_state_assignment() –> float

get_energy_sum_for_vertex_group(self: pyrosetta.rosetta.core.pack.interaction_graph.DoubleLazyInteractionGraph, group_id: int) → float

C++: core::pack::interaction_graph::DoubleLazyInteractionGraph::get_energy_sum_for_vertex_group(int) –> float

get_node(self: pyrosetta.rosetta.core.pack.interaction_graph.InteractionGraphBase, index: int) → pyrosetta.rosetta.core.pack.interaction_graph.NodeBase

C++: core::pack::interaction_graph::InteractionGraphBase::get_node(int) const –> class core::pack::interaction_graph::NodeBase *

get_num_aatypes(self: pyrosetta.rosetta.core.pack.interaction_graph.OnTheFlyInteractionGraph) → int

C++: core::pack::interaction_graph::OnTheFlyInteractionGraph::get_num_aatypes() const –> int

get_num_edges(self: pyrosetta.rosetta.core.pack.interaction_graph.InteractionGraphBase) → int

C++: core::pack::interaction_graph::InteractionGraphBase::get_num_edges() const –> int

get_num_nodes(self: pyrosetta.rosetta.core.pack.interaction_graph.InteractionGraphBase) → int

C++: core::pack::interaction_graph::InteractionGraphBase::get_num_nodes() const –> int

get_num_rpe_calculations_count(self: pyrosetta.rosetta.core.pack.interaction_graph.OnTheFlyInteractionGraph) → int

C++: core::pack::interaction_graph::OnTheFlyInteractionGraph::get_num_rpe_calculations_count() const –> unsigned long

get_num_states_for_node(self: pyrosetta.rosetta.core.pack.interaction_graph.InteractionGraphBase, node: int) → int

C++: core::pack::interaction_graph::InteractionGraphBase::get_num_states_for_node(int) const –> int

get_num_total_states(self: pyrosetta.rosetta.core.pack.interaction_graph.InteractionGraphBase) → int

C++: core::pack::interaction_graph::InteractionGraphBase::get_num_total_states() const –> int

get_one_body_energy_for_node_state(self: pyrosetta.rosetta.core.pack.interaction_graph.OnTheFlyInteractionGraph, node: int, state: int) → float

C++: core::pack::interaction_graph::OnTheFlyInteractionGraph::get_one_body_energy_for_node_state(int, int) –> float

get_sparse_aa_info_for_edge(self: pyrosetta.rosetta.core.pack.interaction_graph.FixedBBInteractionGraph, node1: int, node2: int, node1aa: int, node2aa: int) → bool

returns true if node1aa and node2aa are amino acid neighbors

C++: core::pack::interaction_graph::FixedBBInteractionGraph::get_sparse_aa_info_for_edge(int, int, int, int) –> bool

get_two_body_energy_for_edge(self: pyrosetta.rosetta.core.pack.interaction_graph.FixedBBInteractionGraph, node1: int, node2: int, state_node1: int, state_node2: int) → float

interface to FixedBBEdge::get_two_body_energy

• returns the state pair energy

C++: core::pack::interaction_graph::FixedBBInteractionGraph::get_two_body_energy_for_edge(int, int, int, int) const –> float

get_vertex_member_of_energy_sum_group(self: pyrosetta.rosetta.core.pack.interaction_graph.InteractionGraphBase, node_index: int, group_id: int) → bool

C++: core::pack::interaction_graph::InteractionGraphBase::get_vertex_member_of_energy_sum_group(int, int) –> bool

increment_edge_list_iterator(self: pyrosetta.rosetta.core.pack.interaction_graph.InteractionGraphBase) → None

increment the (single) edge list iterator to the next element

C++: core::pack::interaction_graph::InteractionGraphBase::increment_edge_list_iterator() const –> void

initialize(self: pyrosetta.rosetta.core.pack.interaction_graph.DoubleLazyInteractionGraph, rot_sets: pyrosetta.rosetta.core.pack.rotamer_set.RotamerSetsBase) → None

C++: core::pack::interaction_graph::DoubleLazyInteractionGraph::initialize(const class core::pack::rotamer_set::RotamerSetsBase &) –> void

non_const_pose(self: pyrosetta.rosetta.core.pack.interaction_graph.OnTheFlyInteractionGraph) → pyrosetta.rosetta.core.pose.Pose

debugging only – modify the pose during simulated annealing, if you’re so inclined

C++: core::pack::interaction_graph::OnTheFlyInteractionGraph::non_const_pose() –> class core::pose::Pose &

note_long_range_interactions_exist_for_edge(self: pyrosetta.rosetta.core.pack.interaction_graph.OnTheFlyInteractionGraph, node1: int, node2: int) → None

C++: core::pack::interaction_graph::OnTheFlyInteractionGraph::note_long_range_interactions_exist_for_edge(int, int) –> void

note_rpe_calculated(self: pyrosetta.rosetta.core.pack.interaction_graph.OnTheFlyInteractionGraph) → None

to be called by owned OTF node only

C++: core::pack::interaction_graph::OnTheFlyInteractionGraph::note_rpe_calculated() const –> void

note_short_range_interactions_exist_for_edge(self: pyrosetta.rosetta.core.pack.interaction_graph.OnTheFlyInteractionGraph, node1: int, node2: int) → None

C++: core::pack::interaction_graph::OnTheFlyInteractionGraph::note_short_range_interactions_exist_for_edge(int, int) –> void

note_submatrix_accessed(self: pyrosetta.rosetta.core.pack.interaction_graph.DoubleLazyInteractionGraph, edge_index: int, submatrix_index: int) → None

For use only from the DoubleLazyEdge; the DLE will

report to the DLIG after it a rotamer pair energy submatrix has been read from. The DLIG keeps track of how recently each submatrix has been accessed to ensure that, when it does ask an edge to drop a submatrix, the submatrix being dropped is the one that was accessed most distantly in the past.

C++: core::pack::interaction_graph::DoubleLazyInteractionGraph::note_submatrix_accessed(int, int) const –> void

note_submatrix_added(self: pyrosetta.rosetta.core.pack.interaction_graph.DoubleLazyInteractionGraph, edge_index: int, submatrix_index: int, submatrix_size: int) → None

For use only from the DoubleLazyEdge; the DLE will report

to the DLIG after it adds a submatrix of rotamer pair energies (that is, all the RPEs for a particular pair of amino acids) that it has done so; the DLIG monitors the access and the memory usage of the various submatrices in the graph, and may, during this function call, request that various edges (possibly the one invoking this function!) drop some of their submatrices.

C++: core::pack::interaction_graph::DoubleLazyInteractionGraph::note_submatrix_added(int, int, int) const –> void

note_vertex_reached(self: pyrosetta.rosetta.core.pack.interaction_graph.InteractionGraphBase, node_index: int) → None

C++: core::pack::interaction_graph::InteractionGraphBase::note_vertex_reached(int) –> void

output_connectivity(self: pyrosetta.rosetta.core.pack.interaction_graph.InteractionGraphBase, os: pyrosetta.rosetta.std.ostream) → None

C++: core::pack::interaction_graph::InteractionGraphBase::output_connectivity(class std::basic_ostream<char> &) const –> void

output_dimacs(self: pyrosetta.rosetta.core.pack.interaction_graph.InteractionGraphBase, os: pyrosetta.rosetta.std.ostream) → None

C++: core::pack::interaction_graph::InteractionGraphBase::output_dimacs(class std::basic_ostream<char> &) const –> void

pose(self: pyrosetta.rosetta.core.pack.interaction_graph.OnTheFlyInteractionGraph) → pyrosetta.rosetta.core.pose.Pose

C++: core::pack::interaction_graph::OnTheFlyInteractionGraph::pose() const –> const class core::pose::Pose &

prepare_for_simulated_annealing(self: pyrosetta.rosetta.core.pack.interaction_graph.DoubleLazyInteractionGraph) → None

C++: core::pack::interaction_graph::DoubleLazyInteractionGraph::prepare_for_simulated_annealing() –> void

print(self: pyrosetta.rosetta.core.pack.interaction_graph.InteractionGraphBase) → None

C++: core::pack::interaction_graph::InteractionGraphBase::print() const –> void

print_current_state_assignment(self: pyrosetta.rosetta.core.pack.interaction_graph.DoubleLazyInteractionGraph) → None

C++: core::pack::interaction_graph::DoubleLazyInteractionGraph::print_current_state_assignment() const –> void

print_vertex_groups(self: pyrosetta.rosetta.core.pack.interaction_graph.InteractionGraphBase) → None

C++: core::pack::interaction_graph::InteractionGraphBase::print_vertex_groups() –> void

print_vertices(self: pyrosetta.rosetta.core.pack.interaction_graph.InteractionGraphBase) → None

C++: core::pack::interaction_graph::InteractionGraphBase::print_vertices() const –> void

reset_edge_list_iterator_for_node(self: pyrosetta.rosetta.core.pack.interaction_graph.InteractionGraphBase, node_index: int) → None

set the Graph’s (single) edge list iterator to the beginning of the edge list

for a particular node

C++: core::pack::interaction_graph::InteractionGraphBase::reset_edge_list_iterator_for_node(int) const –> void

reset_rpe_calculations_count(self: pyrosetta.rosetta.core.pack.interaction_graph.OnTheFlyInteractionGraph) → None

C++: core::pack::interaction_graph::OnTheFlyInteractionGraph::reset_rpe_calculations_count() –> void

score_function(self: pyrosetta.rosetta.core.pack.interaction_graph.OnTheFlyInteractionGraph) → pyrosetta.rosetta.core.scoring.ScoreFunction

C++: core::pack::interaction_graph::OnTheFlyInteractionGraph::score_function() const –> const class core::scoring::ScoreFunction &

set_GlyCorrection_values_for_edge(self: pyrosetta.rosetta.core.pack.interaction_graph.OnTheFlyInteractionGraph, node1: int, node2: int, node_not_neccessarily_glycine: int, state: int, bb_regbb_E: float, bb_glybb_E: float, sc_regbb_E: float, sc_glybb_E: float) → None

C++: core::pack::interaction_graph::OnTheFlyInteractionGraph::set_GlyCorrection_values_for_edge(int, int, int, int, float, float, float, float) –> void

set_ProCorrection_values_for_edge(self: pyrosetta.rosetta.core.pack.interaction_graph.OnTheFlyInteractionGraph, node1: int, node2: int, node_not_neccessarily_proline: int, state: int, bb_regbb_E: float, bb_probb_E: float, sc_regbb_E: float, sc_probb_E: float) → None

C++: core::pack::interaction_graph::OnTheFlyInteractionGraph::set_ProCorrection_values_for_edge(int, int, int, int, float, float, float, float) –> void

set_edge_weight(self: pyrosetta.rosetta.core.pack.interaction_graph.InteractionGraphBase, node1: int, node2: int, edge_weight: float) → None

C++: core::pack::interaction_graph::InteractionGraphBase::set_edge_weight(int, int, double) –> void

set_errorfull_deltaE_threshold(self: pyrosetta.rosetta.core.pack.interaction_graph.DoubleLazyInteractionGraph, deltaE: float) → None

C++: core::pack::interaction_graph::DoubleLazyInteractionGraph::set_errorfull_deltaE_threshold(float) –> void

set_memory_max_for_rpes(self: pyrosetta.rosetta.core.pack.interaction_graph.DoubleLazyInteractionGraph, setting: int) → None

C++: core::pack::interaction_graph::DoubleLazyInteractionGraph::set_memory_max_for_rpes(int) –> void

set_network_state(self: pyrosetta.rosetta.core.pack.interaction_graph.DoubleLazyInteractionGraph, node_states: ObjexxFCL::FArray1<int>) → float

C++: core::pack::interaction_graph::DoubleLazyInteractionGraph::set_network_state(class ObjexxFCL::FArray1<int> &) –> float

set_num_states_for_node(self: pyrosetta.rosetta.core.pack.interaction_graph.InteractionGraphBase, node: int, num_states: int) → None

C++: core::pack::interaction_graph::InteractionGraphBase::set_num_states_for_node(int, int) –> void

set_number_of_energy_sum_vertex_groups(self: pyrosetta.rosetta.core.pack.interaction_graph.InteractionGraphBase, num_groups: int) → None

C++: core::pack::interaction_graph::InteractionGraphBase::set_number_of_energy_sum_vertex_groups(int) –> void

set_one_body_energy_for_node_state(self: pyrosetta.rosetta.core.pack.interaction_graph.OnTheFlyInteractionGraph, node_ind: int, state: int, one_body_energy: float) → None

C++: core::pack::interaction_graph::OnTheFlyInteractionGraph::set_one_body_energy_for_node_state(int, int, float) –> void

set_pose(self: pyrosetta.rosetta.core.pack.interaction_graph.OnTheFlyInteractionGraph, : pyrosetta.rosetta.core.pose.Pose) → None

C++: core::pack::interaction_graph::OnTheFlyInteractionGraph::set_pose(const class core::pose::Pose &) –> void

set_score_function(self: pyrosetta.rosetta.core.pack.interaction_graph.OnTheFlyInteractionGraph, : pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: core::pack::interaction_graph::OnTheFlyInteractionGraph::set_score_function(const class core::scoring::ScoreFunction &) –> void

set_sparse_aa_info_for_edge(self: pyrosetta.rosetta.core.pack.interaction_graph.OnTheFlyInteractionGraph, node1: int, node2: int, sparse_conn_info: ObjexxFCL::FArray2<bool>) → None

C++: core::pack::interaction_graph::OnTheFlyInteractionGraph::set_sparse_aa_info_for_edge(int, int, const class ObjexxFCL::FArray2<bool> &) –> void

set_state_for_node(self: pyrosetta.rosetta.core.pack.interaction_graph.DoubleLazyInteractionGraph, node_ind: int, new_state: int) → float

C++: core::pack::interaction_graph::DoubleLazyInteractionGraph::set_state_for_node(int, int) –> float

set_vertex_member_of_group(self: pyrosetta.rosetta.core.pack.interaction_graph.InteractionGraphBase, vertex: int, group: int) → None

C++: core::pack::interaction_graph::InteractionGraphBase::set_vertex_member_of_group(int, int) –> void

update_one_body_energies(self: pyrosetta.rosetta.core.pack.interaction_graph.InteractionGraphBase, old_energy1b: ObjexxFCL::FArray1<float>, new_energy1b: ObjexxFCL::FArray1<float>) → None

C++: core::pack::interaction_graph::InteractionGraphBase::update_one_body_energies(class ObjexxFCL::FArray1<float> &, class ObjexxFCL::FArray1<float> &) –> void

vertex_already_reached(self: pyrosetta.rosetta.core.pack.interaction_graph.InteractionGraphBase, node_index: int) → bool

C++: core::pack::interaction_graph::InteractionGraphBase::vertex_already_reached(int) –> bool

zero_one_body_energies_for_node(self: pyrosetta.rosetta.core.pack.interaction_graph.InteractionGraphBase, node: int) → None

C++: core::pack::interaction_graph::InteractionGraphBase::zero_one_body_energies_for_node(int) –> void

zero_one_body_energy_for_node_state(self: pyrosetta.rosetta.core.pack.interaction_graph.OnTheFlyInteractionGraph, node_ind: int, state: int) → None

C++: core::pack::interaction_graph::OnTheFlyInteractionGraph::zero_one_body_energy_for_node_state(int, int) –> void

class pyrosetta.rosetta.core.pack.interaction_graph.HPatchEnergy

Bases: pyrosetta.rosetta.core.scoring.methods.ContextDependentOneBodyEnergy

Defines a (pseudo) context-dependent one-body surface energy. Really, this class is only being used as a hack for the optE protocol so that the non-PD surface energy can be optimized together with the other PD-terms. The difference from this energy method from the plain SurfaceEnergy method is that it calculates the patch area using methods in sasa.cc instead of using average values. This new method also uses a new approach for finding which residues to include in a patch, not just all residues within 10A.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.core.pack.interaction_graph.HPatchEnergy) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

assign(self: pyrosetta.rosetta.core.pack.interaction_graph.HPatchEnergy, : pyrosetta.rosetta.core.pack.interaction_graph.HPatchEnergy) → pyrosetta.rosetta.core.pack.interaction_graph.HPatchEnergy

C++: core::pack::interaction_graph::HPatchEnergy::operator=(const class core::pack::interaction_graph::HPatchEnergy &) –> class core::pack::interaction_graph::HPatchEnergy &

clone(self: pyrosetta.rosetta.core.pack.interaction_graph.HPatchEnergy) → pyrosetta.rosetta.core.scoring.methods.EnergyMethod

C++: core::pack::interaction_graph::HPatchEnergy::clone() const –> class std::shared_ptr<class core::scoring::methods::EnergyMethod>

defines_dof_derivatives(self: pyrosetta.rosetta.core.scoring.methods.OneBodyEnergy, p: pyrosetta.rosetta.core.pose.Pose) → bool

Use the dof_derivative interface for this energy method when

calculating derivatives? It is possible to define both dof_derivatives and atom-derivatives; they are not mutually exclusive.

C++: core::scoring::methods::OneBodyEnergy::defines_dof_derivatives(const class core::pose::Pose &) const –> bool

defines_high_order_terms(self: pyrosetta.rosetta.core.scoring.methods.EnergyMethod, : pyrosetta.rosetta.core.pose.Pose) → bool

Should this EnergyMethod have score and derivative evaluation

evaluated both in the context of the whole Pose and in the context of residue or residue-pairs? This covers scoring terms like env-smooth wherein the CBeta’s get derivatives for increasing the neighbor counts for surrounding residues, and terms like constraints, which are definable on arbitrary number of residues (e.g. more than 2); both of these terms could be used in RTMin, and both should use the residue and residue-pair evaluation scheme with the MinimizationGraph for the majority of the work they do. (Now, high-order constraints (3-body or above) will not be properly evaluated within RTMin.). The default implementation returns “false”.

C++: core::scoring::methods::EnergyMethod::defines_high_order_terms(const class core::pose::Pose &) const –> bool

defines_score_for_residue(self: pyrosetta.rosetta.core.scoring.methods.OneBodyEnergy, : pyrosetta.rosetta.core.conformation.Residue) → bool

During minimization, energy methods are allowed to decide that they say nothing

about a particular residue (e.g. no non-zero energy) and as a result they will not be queried for a derivative or an energy. The default behavior is to return “true” for all residues.

C++: core::scoring::methods::OneBodyEnergy::defines_score_for_residue(const class core::conformation::Residue &) const –> bool

eval_atom_derivative(self: pyrosetta.rosetta.core.scoring.methods.EnergyMethod, id: pyrosetta.rosetta.core.id.AtomID, pose: pyrosetta.rosetta.core.pose.Pose, domain_map: ObjexxFCL::FArray1D<int>, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, emap: pyrosetta.rosetta.core.scoring.EMapVector, F1: pyrosetta.rosetta.numeric.xyzVector_double_t, F2: pyrosetta.rosetta.numeric.xyzVector_double_t) → None

Evaluate the XYZ derivative for an atom in the pose.

Called during the atomtree derivative calculation, atom_tree_minimize.cc, through the ScoreFunction::eval_atom_derivative intermediary. F1 and F2 should not zeroed, rather, this class should accumulate its contribution from this atom’s XYZ derivative

The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984) “Rapid Calculation of First and Second Derivatives of Conformational Energy with Respect to Dihedral Angles for Proteins. General Recurrent Equations” Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga, respectively, of equations 7a & 7b in that paper.

C++: core::scoring::methods::EnergyMethod::eval_atom_derivative(const class core::id::AtomID &, const class core::pose::Pose &, const class ObjexxFCL::FArray1D<int> &, const class core::scoring::ScoreFunction &, const class core::scoring::EMapVector &, class numeric::xyzVector<double> &, class numeric::xyzVector<double> &) const –> void

eval_residue_derivatives(self: pyrosetta.rosetta.core.scoring.methods.OneBodyEnergy, rsd: pyrosetta.rosetta.core.conformation.Residue, min_data: core::scoring::ResSingleMinimizationData, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector, atom_derivs: pyrosetta.rosetta.utility.vector1_core_scoring_DerivVectorPair) → None

Evaluate the derivatives for all atoms on this residue and increment them

into the input atom_derivs vector1. The calling function must guarantee that setup for derivatives is called before this function is, and that the atom_derivs vector contains at least as many entries as there are atoms in the input Residue. This base class provides a default noop implementation of this function.

C++: core::scoring::methods::OneBodyEnergy::eval_residue_derivatives(const class core::conformation::Residue &, const class core::scoring::ResSingleMinimizationData &, const class core::pose::Pose &, const class core::scoring::EMapVector &, class utility::vector1<class core::scoring::DerivVectorPair, class std::allocator<class core::scoring::DerivVectorPair> > &) const –> void

eval_residue_dof_derivative(self: pyrosetta.rosetta.core.scoring.methods.OneBodyEnergy, rsd: pyrosetta.rosetta.core.conformation.Residue, min_data: core::scoring::ResSingleMinimizationData, dof_id: pyrosetta.rosetta.core.id.DOF_ID, torsion_id: pyrosetta.rosetta.core.id.TorsionID, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, weights: pyrosetta.rosetta.core.scoring.EMapVector) → float

Evaluate the DOF derivative for a particular residue. The Pose merely serves as context,

and the input residue is not required to be a member of the Pose.

C++: core::scoring::methods::OneBodyEnergy::eval_residue_dof_derivative(const class core::conformation::Residue &, const class core::scoring::ResSingleMinimizationData &, const class core::id::DOF_ID &, const class core::id::TorsionID &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, const class core::scoring::EMapVector &) const –> double

finalize_after_derivatives(self: pyrosetta.rosetta.core.scoring.methods.EnergyMethod, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.scoring.ScoreFunction) → None

called at the end of derivatives evaluation

C++: core::scoring::methods::EnergyMethod::finalize_after_derivatives(class core::pose::Pose &, const class core::scoring::ScoreFunction &) const –> void

finalize_total_energy(self: pyrosetta.rosetta.core.pack.interaction_graph.HPatchEnergy, pose: pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.scoring.ScoreFunction, totals: pyrosetta.rosetta.core.scoring.EMapVector) → None

C++: core::pack::interaction_graph::HPatchEnergy::finalize_total_energy(class core::pose::Pose &, const class core::scoring::ScoreFunction &, class core::scoring::EMapVector &) const –> void

indicate_required_context_graphs(self: pyrosetta.rosetta.core.pack.interaction_graph.HPatchEnergy, : pyrosetta.rosetta.utility.vector1_bool) → None

C++: core::pack::interaction_graph::HPatchEnergy::indicate_required_context_graphs(class utility::vector1<bool, class std::allocator<bool> > &) const –> void

method_type(self: pyrosetta.rosetta.core.scoring.methods.ContextDependentOneBodyEnergy) → pyrosetta.rosetta.core.scoring.methods.EnergyMethodType

Returns the cd_1b element of the EnergyMethodType enumeration; this method

should NOT be overridden by derived classes.

C++: core::scoring::methods::ContextDependentOneBodyEnergy::method_type() const –> enum core::scoring::methods::EnergyMethodType

minimize_in_whole_structure_context(self: pyrosetta.rosetta.core.scoring.methods.EnergyMethod, : pyrosetta.rosetta.core.pose.Pose) → bool

Should this EnergyMethod have score and derivative evaluation

evaluated only in the context of the whole Pose, or can it be included in a decomposed manner for a residue or a set of residue-pairs that are not part of the Pose that’s serving as their context? The default method implemented in the base class returns true in order to grandfather in EnergyMethods that have not had their derivatives changed to take advantage of the new derivative-evaluation machinery. Methods that return “true” will not have their residue-energy(-ext) / residue-pair-energy(-ext) methods invoked by the ScoreFunction during its traversal of the MinimizationGraph, and instead will be asked to perform all their work during finalize_total_energies(). Similarly, they will be expected to perform all their work during eval_atom_deriv() instead of during the ScoreFunction’s traversal of the MinimizationGraph for derivative evaluation. IMPORTANT: Methods that return “true” cannot be included in RTMin.

C++: core::scoring::methods::EnergyMethod::minimize_in_whole_structure_context(const class core::pose::Pose &) const –> bool

prepare_rotamers_for_packing(self: pyrosetta.rosetta.core.scoring.methods.EnergyMethod, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.conformation.RotamerSetBase) → None

If an energy method needs to cache data in a packing::RotamerSet object before

rotamer energies are calculated, it does so during this function. The packer must ensure this function is called. The default behavior is to do nothing.

C++: core::scoring::methods::EnergyMethod::prepare_rotamers_for_packing(const class core::pose::Pose &, class core::conformation::RotamerSetBase &) const –> void

requires_a_setup_for_derivatives_for_residue_opportunity(self: pyrosetta.rosetta.core.scoring.methods.OneBodyEnergy, pose: pyrosetta.rosetta.core.pose.Pose) → bool

Does this EnergyMethod require the opportunity to examine the residue before derivative evaluation begins? Not

all energy methods would. The ScoreFunction will not ask energy methods to examine residues that are uninterested in doing so.

C++: core::scoring::methods::OneBodyEnergy::requires_a_setup_for_derivatives_for_residue_opportunity(const class core::pose::Pose &) const –> bool

requires_a_setup_for_scoring_for_residue_opportunity_during_minimization(self: pyrosetta.rosetta.core.scoring.methods.OneBodyEnergy, pose: pyrosetta.rosetta.core.pose.Pose) → bool

Does this EnergyMethod require the opportunity to examine the residue before scoring begins? Not

all energy methods would. The ScoreFunction will not ask energy methods to examine residues that are uninterested in doing so.

C++: core::scoring::methods::OneBodyEnergy::requires_a_setup_for_scoring_for_residue_opportunity_during_minimization(const class core::pose::Pose &) const –> bool

requires_a_setup_for_scoring_for_residue_opportunity_during_regular_scoring(self: pyrosetta.rosetta.core.scoring.methods.EnergyMethod, pose: pyrosetta.rosetta.core.pose.Pose) → bool

Does this EnergyMethod require the opportunity to examine the residue before (regular) scoring begins? Not

all energy methods would. The ScoreFunction will not ask energy methods to examine residues that are uninterested in doing so. The default implmentation of this function returns false

C++: core::scoring::methods::EnergyMethod::requires_a_setup_for_scoring_for_residue_opportunity_during_regular_scoring(const class core::pose::Pose &) const –> bool

residue_energy(self: pyrosetta.rosetta.core.pack.interaction_graph.HPatchEnergy, rsd: pyrosetta.rosetta.core.conformation.Residue, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.scoring.EMapVector) → None

C++: core::pack::interaction_graph::HPatchEnergy::residue_energy(const class core::conformation::Residue &, const class core::pose::Pose &, class core::scoring::EMapVector &) const –> void

residue_energy_ext(self: pyrosetta.rosetta.core.scoring.methods.OneBodyEnergy, rsd: pyrosetta.rosetta.core.conformation.Residue, min_data: core::scoring::ResSingleMinimizationData, pose: pyrosetta.rosetta.core.pose.Pose, emap: pyrosetta.rosetta.core.scoring.EMapVector) → None

Evaluate the one-body energies for a particular residue, in the context of a

given Pose, and with the help of a piece of cached data for minimization, increment those one body energies into the input EnergyMap. The calling function must guarantee that this EnergyMethod has had the opportunity to update the input ResSingleMinimizationData object for the given residue in a call to setup_for_minimizing_for_residue before this function is invoked. This function should not be called unless the use_extended_residue_energy_interface() method returns “true”. Default implementation provided by this base class calls utility::exit(). The Pose merely serves as context, and the input residue is not required to be a member of the Pose.

C++: core::scoring::methods::OneBodyEnergy::residue_energy_ext(const class core::conformation::Residue &, const class core::scoring::ResSingleMinimizationData &, const class core::pose::Pose &, class core::scoring::EMapVector &) const –> void

score_types(self: pyrosetta.rosetta.core.scoring.methods.EnergyMethod) → pyrosetta.rosetta.utility.vector1_core_scoring_ScoreType

Returns the score types that this energy method computes.

C++: core::scoring::methods::EnergyMethod::score_types() const –> const class utility::vector1<enum core::scoring::ScoreType, class std::allocator<enum core::scoring::ScoreType> > &

setup_for_derivatives(self: pyrosetta.rosetta.core.scoring.methods.EnergyMethod, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

Called immediately before atom- and DOF-derivatives are calculated

allowing the derived class a chance to prepare for future calls.

C++: core::scoring::methods::EnergyMethod::setup_for_derivatives(class core::pose::Pose &, const class core::scoring::ScoreFunction &) const –> void

setup_for_derivatives_for_residue(self: pyrosetta.rosetta.core.scoring.methods.OneBodyEnergy, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, min_data: core::scoring::ResSingleMinimizationData, res_data_cache: pyrosetta.rosetta.basic.datacache.BasicDataCache) → None

Do any setup work necessary before evaluating the derivatives for this residue

C++: core::scoring::methods::OneBodyEnergy::setup_for_derivatives_for_residue(const class core::conformation::Residue &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, class core::scoring::ResSingleMinimizationData &, class basic::datacache::BasicDataCache &) const –> void

setup_for_minimizing(self: pyrosetta.rosetta.core.scoring.methods.EnergyMethod, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.scoring.ScoreFunction, : pyrosetta.rosetta.core.kinematics.MinimizerMapBase) → None

Called at the beginning of atom tree minimization, this method

allows the derived class the opportunity to initialize pertinent data that will be used during minimization. During minimzation, the chemical structure of the pose is constant, so assumptions on the number of atoms per residue and their identities are safe so long as the pose’s Energies object’s “use_nblist()” method returns true.

C++: core::scoring::methods::EnergyMethod::setup_for_minimizing(class core::pose::Pose &, const class core::scoring::ScoreFunction &, const class core::kinematics::MinimizerMapBase &) const –> void

setup_for_minimizing_for_residue(self: pyrosetta.rosetta.core.scoring.methods.OneBodyEnergy, rsd: pyrosetta.rosetta.core.conformation.Residue, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.scoring.ScoreFunction, : pyrosetta.rosetta.core.kinematics.MinimizerMapBase, : pyrosetta.rosetta.basic.datacache.BasicDataCache, : core::scoring::ResSingleMinimizationData) → None

Called at the beginning of minimization, allowing this energy method to cache data

pertinent for a single residue in the the ResSingleMinimizationData that is used for a particular residue in the context of a particular Pose. This base class provides a noop implementation for this function if there is nothing that the derived class needs to perform in this setup phase. The Pose merely serves as context, and the input residue is not required to be a member of the Pose.

C++: core::scoring::methods::OneBodyEnergy::setup_for_minimizing_for_residue(const class core::conformation::Residue &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, const class core::kinematics::MinimizerMapBase &, class basic::datacache::BasicDataCache &, class core::scoring::ResSingleMinimizationData &) const –> void

setup_for_packing(self: pyrosetta.rosetta.core.scoring.methods.EnergyMethod, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.utility.vector1_bool, : pyrosetta.rosetta.utility.vector1_bool) → None

if an energy method needs to cache data in the Energies object,

before packing begins, then it does so during this function. The packer must ensure this function is called. The default behavior is to do nothing.

C++: core::scoring::methods::EnergyMethod::setup_for_packing(class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &, const class utility::vector1<bool, class std::allocator<bool> > &) const –> void

setup_for_scoring(self: pyrosetta.rosetta.core.pack.interaction_graph.HPatchEnergy, pose: pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: core::pack::interaction_graph::HPatchEnergy::setup_for_scoring(class core::pose::Pose &, const class core::scoring::ScoreFunction &) const –> void

setup_for_scoring_for_residue(*args, **kwargs)

Overloaded function.

1. setup_for_scoring_for_residue(self: pyrosetta.rosetta.core.scoring.methods.OneBodyEnergy, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, residue_data_cache: pyrosetta.rosetta.basic.datacache.BasicDataCache) -> None
2. setup_for_scoring_for_residue(self: pyrosetta.rosetta.core.scoring.methods.OneBodyEnergy, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, min_data: core::scoring::ResSingleMinimizationData) -> None

Do any setup work should the coordinates of this residue, who is still guaranteed to be

of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically as to possibly require some amount of setup work before scoring should proceed

C++: core::scoring::methods::OneBodyEnergy::setup_for_scoring_for_residue(const class core::conformation::Residue &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, class core::scoring::ResSingleMinimizationData &) const –> void

show_additional_info(self: pyrosetta.rosetta.core.scoring.methods.EnergyMethod, : pyrosetta.rosetta.std.ostream, : pyrosetta.rosetta.core.pose.Pose, : bool) → None

show additional information of the energy method

C++: core::scoring::methods::EnergyMethod::show_additional_info(class std::basic_ostream<char> &, class core::pose::Pose &, bool) const –> void

update_residue_for_packing(self: pyrosetta.rosetta.core.scoring.methods.EnergyMethod, : pyrosetta.rosetta.core.pose.Pose, resid: int) → None

If the pose changes in the middle of a packing (as happens in rotamer trials) and if

an energy method needs to cache data in the pose that corresponds to its current state, then the method must update that data when this function is called. The packer must ensure this function gets called. The default behavior is to do nothing.

C++: core::scoring::methods::EnergyMethod::update_residue_for_packing(class core::pose::Pose &, unsigned long) const –> void

use_extended_residue_energy_interface(self: pyrosetta.rosetta.core.scoring.methods.OneBodyEnergy) → bool

Rely on the extended version of the residue_energy function during score-function

evaluation in minimization? The extended version (below) takes a ResSingleMinimizationData. Return ‘true’ for the extended version. The default method implemented in this class returns ‘false’

C++: core::scoring::methods::OneBodyEnergy::use_extended_residue_energy_interface() const –> bool

version(self: pyrosetta.rosetta.core.pack.interaction_graph.HPatchEnergy) → int

C++: core::pack::interaction_graph::HPatchEnergy::version() const –> unsigned long

class pyrosetta.rosetta.core.pack.interaction_graph.InvRotamerDots

Bases: pybind11_builtins.pybind11_object

Used to determine whether the overlap between two atoms is buried or exposed.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.pack.interaction_graph.InvRotamerDots) -> None
2. __init__(self: pyrosetta.rosetta.core.pack.interaction_graph.InvRotamerDots, arg0: pyrosetta.rosetta.core.pack.interaction_graph.InvRotamerDots) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

assign(self: pyrosetta.rosetta.core.pack.interaction_graph.InvRotamerDots, rhs: pyrosetta.rosetta.core.pack.interaction_graph.InvRotamerDots) → pyrosetta.rosetta.core.pack.interaction_graph.InvRotamerDots

C++: core::pack::interaction_graph::InvRotamerDots::operator=(const class core::pack::interaction_graph::InvRotamerDots &) –> class core::pack::interaction_graph::InvRotamerDots &

atom_overlap_is_exposed(*args, **kwargs)

Overloaded function.

1. atom_overlap_is_exposed(self: pyrosetta.rosetta.core.pack.interaction_graph.InvRotamerDots, at1: int, at2: int) -> bool

Is the intersection between two atoms on this inv-rotamer-dots object exposed?

C++: core::pack::interaction_graph::InvRotamerDots::atom_overlap_is_exposed(unsigned long, unsigned long) const –> bool

2. atom_overlap_is_exposed(self: pyrosetta.rosetta.core.pack.interaction_graph.InvRotamerDots, at_this: int, other: pyrosetta.rosetta.core.pack.interaction_graph.InvRotamerDots, at_other: int) -> bool

Is the intersection between one atom on this inv-rotamer-dots object,

and one atom on another inv-rotamer-dots object exposed?

C++: core::pack::interaction_graph::InvRotamerDots::atom_overlap_is_exposed(unsigned long, const class core::pack::interaction_graph::InvRotamerDots &, unsigned long) const –> bool

dot_exposed(self: pyrosetta.rosetta.core.pack.interaction_graph.InvRotamerDots, atomid: int, dot_index: int) → bool

C++: core::pack::interaction_graph::InvRotamerDots::dot_exposed(unsigned long, unsigned long) const –> bool

rotamer(self: pyrosetta.rosetta.core.pack.interaction_graph.InvRotamerDots) → pyrosetta.rosetta.core.conformation.Residue

C++: core::pack::interaction_graph::InvRotamerDots::rotamer() const –> class std::shared_ptr<const class core::conformation::Residue>

setup_from_rotamer_dots(*args, **kwargs)

Overloaded function.

1. setup_from_rotamer_dots(self: pyrosetta.rosetta.core.pack.interaction_graph.InvRotamerDots, rdots: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots) -> None

C++: core::pack::interaction_graph::InvRotamerDots::setup_from_rotamer_dots(const class core::pack::interaction_graph::RotamerDots &) –> void

2. setup_from_rotamer_dots(self: pyrosetta.rosetta.core.pack.interaction_graph.InvRotamerDots, rdots: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots, ats_to_update: pyrosetta.rosetta.utility.vector1_unsigned_long) -> None

C++: core::pack::interaction_graph::InvRotamerDots::setup_from_rotamer_dots(const class core::pack::interaction_graph::RotamerDots &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> void

write_circle_intersection_mask_to_kinemage(*args, **kwargs)

Overloaded function.

1. write_circle_intersection_mask_to_kinemage(self: pyrosetta.rosetta.core.pack.interaction_graph.InvRotamerDots, ostr: pyrosetta.rosetta.std.ostream, atom_this: int, invdots_other: pyrosetta.rosetta.core.pack.interaction_graph.InvRotamerDots, atom_other: int) -> None
2. write_circle_intersection_mask_to_kinemage(self: pyrosetta.rosetta.core.pack.interaction_graph.InvRotamerDots, ostr: pyrosetta.rosetta.std.ostream, atom_this: int, invdots_other: pyrosetta.rosetta.core.pack.interaction_graph.InvRotamerDots, atom_other: int, group: bool) -> None

C++: core::pack::interaction_graph::InvRotamerDots::write_circle_intersection_mask_to_kinemage(class std::basic_ostream<char> &, const unsigned long, const class core::pack::interaction_graph::InvRotamerDots &, const unsigned long, bool) const –> void

write_exposed_dots_to_kinemage(*args, **kwargs)

Overloaded function.

1. write_exposed_dots_to_kinemage(self: pyrosetta.rosetta.core.pack.interaction_graph.InvRotamerDots, ostr: pyrosetta.rosetta.std.ostream) -> None
2. write_exposed_dots_to_kinemage(self: pyrosetta.rosetta.core.pack.interaction_graph.InvRotamerDots, ostr: pyrosetta.rosetta.std.ostream, group: bool) -> None

C++: core::pack::interaction_graph::InvRotamerDots::write_exposed_dots_to_kinemage(class std::basic_ostream<char> &, bool) const –> void

class pyrosetta.rosetta.core.pack.interaction_graph.NPDHBSimpleInteractionGraph

Bases: pyrosetta.rosetta.core.pack.interaction_graph.SimpleInteractionGraph

A simple graph class for calculating pairwise decomposable energies as sidechains are moving on a fixed backbone. This class is responsible for calculating energy changes, but is passive about how the sidechains are changing. There are two main ways to drive the graph: one where the graph ACTIVELY takes charge of updating pointers to the sidechains, where, each external change of one pointer triggers an update to the energies; and a second, where the graph is PASSIVE wrt the pointers, and they must be maintained by an external driver.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.pack.interaction_graph.NPDHBSimpleInteractionGraph) -> None
2. __init__(self: pyrosetta.rosetta.core.pack.interaction_graph.NPDHBSimpleInteractionGraph, arg0: pyrosetta.rosetta.core.pack.interaction_graph.NPDHBSimpleInteractionGraph) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

add_edge(*args, **kwargs)

Overloaded function.

1. add_edge(self: pyrosetta.rosetta.utility.graph.Graph, node1: int, node2: int) -> pyrosetta.rosetta.utility.graph.Edge

add an edge between two vertices. Invokes “create_edge” from the derived class.

Returns a pointer to the edge after its been added, allowing the calling function to immediately set data for this edge.

C++: utility::graph::Graph::add_edge(unsigned long, unsigned long) –> class utility::graph::Edge *

2. add_edge(self: pyrosetta.rosetta.utility.graph.Graph, example_edge: pyrosetta.rosetta.utility.graph.Edge) -> pyrosetta.rosetta.utility.graph.Edge

add an edge to this graph copying the data from an edge in another graph.

Returns a pointer to the edge after its been added, allowing the calling function to immediately set data for this edge.

C++: utility::graph::Graph::add_edge(const class utility::graph::Edge *) –> class utility::graph::Edge *

all_pairs_shortest_paths(self: pyrosetta.rosetta.utility.graph.Graph) → ObjexxFCL::FArray2D<int>

O(V^3). Computes all pairs shortest paths using Warshall’s algorithm

and writes all the path distances to the two-dimensional table.

C++: utility::graph::Graph::all_pairs_shortest_paths() const –> class ObjexxFCL::FArray2D<int>

assign(self: pyrosetta.rosetta.core.pack.interaction_graph.NPDHBSimpleInteractionGraph, : pyrosetta.rosetta.core.pack.interaction_graph.NPDHBSimpleInteractionGraph) → pyrosetta.rosetta.core.pack.interaction_graph.NPDHBSimpleInteractionGraph

C++: core::pack::interaction_graph::NPDHBSimpleInteractionGraph::operator=(const class core::pack::interaction_graph::NPDHBSimpleInteractionGraph &) –> class core::pack::interaction_graph::NPDHBSimpleInteractionGraph &

commit_change(self: pyrosetta.rosetta.core.pack.interaction_graph.NPDHBSimpleInteractionGraph, node_id: int) → None

C++: core::pack::interaction_graph::NPDHBSimpleInteractionGraph::commit_change(unsigned long) –> void

consider_substitution(self: pyrosetta.rosetta.core.pack.interaction_graph.NPDHBSimpleInteractionGraph, node_id: int, new_state: pyrosetta.rosetta.core.conformation.Residue, residue_data_cache: pyrosetta.rosetta.basic.datacache.BasicDataCache) → float

C++: core::pack::interaction_graph::NPDHBSimpleInteractionGraph::consider_substitution(unsigned long, class std::shared_ptr<const class core::conformation::Residue>, class basic::datacache::BasicDataCache &) –> double

const_edge_list_begin(self: pyrosetta.rosetta.utility.graph.Graph) → pyrosetta.rosetta.utility.graph.EdgeListConstIterator

returns a const iterator to the beginning of the (unordered) edge list for the graph.

this edge list contains all the edges in the graph, not simply those for a particular vertex

C++: utility::graph::Graph::const_edge_list_begin() const –> class utility::graph::EdgeListConstIterator

const_edge_list_end(self: pyrosetta.rosetta.utility.graph.Graph) → pyrosetta.rosetta.utility.graph.EdgeListConstIterator

returns a const iterator to the end of the (unordered) edge list for the graph.

this edge list contains all the edges in the graph, not simply those for a particular vertex

C++: utility::graph::Graph::const_edge_list_end() const –> class utility::graph::EdgeListConstIterator

copy_connectivity(self: pyrosetta.rosetta.utility.graph.Graph, source: pyrosetta.rosetta.utility.graph.Graph) → None

copy the edge connectivity from a source graph with a potentially

unknown type.

C++: utility::graph::Graph::copy_connectivity(const class utility::graph::Graph &) –> void

count_dynamic_memory(self: pyrosetta.rosetta.core.pack.interaction_graph.NPDHBSimpleInteractionGraph) → int

C++: core::pack::interaction_graph::NPDHBSimpleInteractionGraph::count_dynamic_memory() const –> unsigned long

count_static_memory(self: pyrosetta.rosetta.core.pack.interaction_graph.NPDHBSimpleInteractionGraph) → int

C++: core::pack::interaction_graph::NPDHBSimpleInteractionGraph::count_static_memory() const –> unsigned long

delete_edge(self: pyrosetta.rosetta.core.pack.interaction_graph.NPDHBSimpleInteractionGraph, : pyrosetta.rosetta.utility.graph.Edge) → None

C++: core::pack::interaction_graph::NPDHBSimpleInteractionGraph::delete_edge(class utility::graph::Edge *) –> void

drop_all_edges(self: pyrosetta.rosetta.utility.graph.Graph) → None

delete all the edges present in the graph

C++: utility::graph::Graph::drop_all_edges() –> void

drop_all_edges_for_node(self: pyrosetta.rosetta.utility.graph.Graph, node: int) → None

delete all the edges for a single vertex in the graph

C++: utility::graph::Graph::drop_all_edges_for_node(unsigned long) –> void

edge_list_begin(self: pyrosetta.rosetta.utility.graph.Graph) → pyrosetta.rosetta.utility.graph.EdgeListIterator

returns a non-const iterator to the beginning of the (unordered) edge list for the graph.

this edge list contains all the edges in the graph, not simply those for a particular vertex

C++: utility::graph::Graph::edge_list_begin() –> class utility::graph::EdgeListIterator

edge_list_end(self: pyrosetta.rosetta.utility.graph.Graph) → pyrosetta.rosetta.utility.graph.EdgeListIterator

returns a non-const iterator to the end of the (unordered) edge list for the graph.

this edge list contains all the edges in the graph, not simply those for a particular vertex

C++: utility::graph::Graph::edge_list_end() –> class utility::graph::EdgeListIterator

find_edge(self: pyrosetta.rosetta.utility.graph.Graph, node1: int, node2: int) → pyrosetta.rosetta.utility.graph.Edge

returns a pointer to the edge connecting nodes node1 and node2, if that edge exists

in the graph, o.w. returns 0. Focuses the graph on this edge for fast subsequent retrieval.

C++: utility::graph::Graph::find_edge(unsigned long, unsigned long) –> class utility::graph::Edge *

focused_edge(self: pyrosetta.rosetta.utility.graph.Graph) → pyrosetta.rosetta.utility.graph.Edge

returns a pointer to the focused edge

C++: utility::graph::Graph::focused_edge() –> class utility::graph::Edge *

getTotalMemoryUsage(self: pyrosetta.rosetta.utility.graph.Graph) → int

returns a count of all the memory used by every vertex and edge in a graph

by invoking the polymorphic count_static_memory and count_dynamic_memory of each (possibly derived) node and edge object as well as for the (possibly derived) graph class.

C++: utility::graph::Graph::getTotalMemoryUsage() const –> unsigned long

get_alternate_for_node(self: pyrosetta.rosetta.core.pack.interaction_graph.SimpleInteractionGraph, id: int) → pyrosetta.rosetta.core.conformation.Residue

C++: core::pack::interaction_graph::SimpleInteractionGraph::get_alternate_for_node(unsigned long) const –> class std::shared_ptr<const class core::conformation::Residue>

get_current_for_node(self: pyrosetta.rosetta.core.pack.interaction_graph.SimpleInteractionGraph, id: int) → pyrosetta.rosetta.core.conformation.Residue

C++: core::pack::interaction_graph::SimpleInteractionGraph::get_current_for_node(unsigned long) const –> class std::shared_ptr<const class core::conformation::Residue>

get_edge_exists(self: pyrosetta.rosetta.utility.graph.Graph, node1: int, node2: int) → bool

is an edge already present in the graph? O(V) worst case. O(1) iff all vertices have O(1) edges

C++: utility::graph::Graph::get_edge_exists(unsigned long, unsigned long) const –> bool

get_node(self: pyrosetta.rosetta.utility.graph.Graph, index: int) → pyrosetta.rosetta.utility.graph.Node

C++: utility::graph::Graph::get_node(unsigned long) –> class utility::graph::Node *

get_npdhb_simple_node(self: pyrosetta.rosetta.core.pack.interaction_graph.NPDHBSimpleInteractionGraph, ind: int) → pyrosetta.rosetta.core.pack.interaction_graph.NPDHBSimpleNode

C++: core::pack::interaction_graph::NPDHBSimpleInteractionGraph::get_npdhb_simple_node(unsigned long) –> class core::pack::interaction_graph::NPDHBSimpleNode *

get_self_ptr(self: pyrosetta.rosetta.utility.graph.Graph) → pyrosetta.rosetta.utility.graph.Graph

C++: utility::graph::Graph::get_self_ptr() –> class std::shared_ptr<class utility::graph::Graph>

get_simple_node(self: pyrosetta.rosetta.core.pack.interaction_graph.SimpleInteractionGraph, ind: int) → pyrosetta.rosetta.core.pack.interaction_graph.SimpleNode

C++: core::pack::interaction_graph::SimpleInteractionGraph::get_simple_node(unsigned long) –> class core::pack::interaction_graph::SimpleNode *

hbond_database(self: pyrosetta.rosetta.core.pack.interaction_graph.NPDHBSimpleInteractionGraph) → core::scoring::hbonds::HBondDatabase

C++: core::pack::interaction_graph::NPDHBSimpleInteractionGraph::hbond_database() const –> const class core::scoring::hbonds::HBondDatabase &

hbond_options(self: pyrosetta.rosetta.core.pack.interaction_graph.NPDHBSimpleInteractionGraph) → core::scoring::hbonds::HBondOptions

C++: core::pack::interaction_graph::NPDHBSimpleInteractionGraph::hbond_options() const –> const class core::scoring::hbonds::HBondOptions &

hbonding_to_res(self: pyrosetta.rosetta.core.pack.interaction_graph.NPDHBSimpleInteractionGraph) → pyrosetta.rosetta.utility.vector1_char

C++: core::pack::interaction_graph::NPDHBSimpleInteractionGraph::hbonding_to_res() –> class utility::vector1<char, class std::allocator<char> > &

initialize(self: pyrosetta.rosetta.core.pack.interaction_graph.NPDHBSimpleInteractionGraph, pose: pyrosetta.rosetta.core.pose.Pose) → None

Initialization where the graph adds its own edges

C++: core::pack::interaction_graph::NPDHBSimpleInteractionGraph::initialize(const class core::pose::Pose &) –> void

npd_hb_weight(self: pyrosetta.rosetta.core.pack.interaction_graph.NPDHBSimpleInteractionGraph, eval_type: pyrosetta.rosetta.core.scoring.hbonds.HBEvalType, intra_res: bool) → float

C++: core::pack::interaction_graph::NPDHBSimpleInteractionGraph::npd_hb_weight(enum core::scoring::hbonds::HBEvalType, bool) –> double

npd_hbond_set(self: pyrosetta.rosetta.core.pack.interaction_graph.NPDHBSimpleInteractionGraph) → core::scoring::hbonds::NPDHBondSet

C++: core::pack::interaction_graph::NPDHBSimpleInteractionGraph::npd_hbond_set() const –> const class core::scoring::hbonds::NPDHBondSet &

num_edges(self: pyrosetta.rosetta.utility.graph.Graph) → int

C++: utility::graph::Graph::num_edges() const –> unsigned long

num_nodes(self: pyrosetta.rosetta.utility.graph.Graph) → int

the number of nodes in the graph

C++: utility::graph::Graph::num_nodes() const –> unsigned long

output_connectivity(self: pyrosetta.rosetta.utility.graph.Graph, os: pyrosetta.rosetta.std.ostream) → None

send an edge list to the stream os.

C++: utility::graph::Graph::output_connectivity(class std::basic_ostream<char> &) const –> void

output_dimacs(self: pyrosetta.rosetta.utility.graph.Graph, os: pyrosetta.rosetta.std.ostream) → None

describe this graph in dimacs form to the stream os.

C++: utility::graph::Graph::output_dimacs(class std::basic_ostream<char> &) const –> void

pose(self: pyrosetta.rosetta.core.pack.interaction_graph.SimpleInteractionGraph) → pyrosetta.rosetta.core.pose.Pose

C++: core::pack::interaction_graph::SimpleInteractionGraph::pose() const –> const class core::pose::Pose &

pose_cop(self: pyrosetta.rosetta.core.pack.interaction_graph.SimpleInteractionGraph) → pyrosetta.rosetta.core.pose.Pose

C++: core::pack::interaction_graph::SimpleInteractionGraph::pose_cop() const –> class std::shared_ptr<const class core::pose::Pose>

print_vertices(self: pyrosetta.rosetta.utility.graph.Graph) → None

send summary information to the screen for all vertices in the graph

C++: utility::graph::Graph::print_vertices() const –> void

reject_change(self: pyrosetta.rosetta.core.pack.interaction_graph.NPDHBSimpleInteractionGraph, node_id: int, res: pyrosetta.rosetta.core.conformation.Residue, residue_data_cache: pyrosetta.rosetta.basic.datacache.BasicDataCache) → None

C++: core::pack::interaction_graph::NPDHBSimpleInteractionGraph::reject_change(unsigned long, class std::shared_ptr<const class core::conformation::Residue>, class basic::datacache::BasicDataCache &) –> void

return_hbond_to_queue(self: pyrosetta.rosetta.core.pack.interaction_graph.NPDHBSimpleInteractionGraph, hbond: core::pack::interaction_graph::NPDHBond) → None

C++: core::pack::interaction_graph::NPDHBSimpleInteractionGraph::return_hbond_to_queue(const class std::shared_ptr<struct core::pack::interaction_graph::NPDHBond> &) –> void

scorefunction(self: pyrosetta.rosetta.core.pack.interaction_graph.SimpleInteractionGraph) → pyrosetta.rosetta.core.scoring.ScoreFunction

C++: core::pack::interaction_graph::SimpleInteractionGraph::scorefunction() const –> const class core::scoring::ScoreFunction &

set_num_nodes(self: pyrosetta.rosetta.utility.graph.Graph, num_nodes: int) → None

set the number of nodes in the graph – deletes any existing edges in the graph

C++: utility::graph::Graph::set_num_nodes(unsigned long) –> void

set_pose_no_initialize(self: pyrosetta.rosetta.core.pack.interaction_graph.NPDHBSimpleInteractionGraph, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: core::pack::interaction_graph::NPDHBSimpleInteractionGraph::set_pose_no_initialize(const class core::pose::Pose &) –> void

set_scorefunction(self: pyrosetta.rosetta.core.pack.interaction_graph.NPDHBSimpleInteractionGraph, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: core::pack::interaction_graph::NPDHBSimpleInteractionGraph::set_scorefunction(const class core::scoring::ScoreFunction &) –> void

setup_after_edge_addition(self: pyrosetta.rosetta.core.pack.interaction_graph.NPDHBSimpleInteractionGraph) → None

C++: core::pack::interaction_graph::NPDHBSimpleInteractionGraph::setup_after_edge_addition() –> void

setup_for_scoring_for_residue_energy_methods(self: pyrosetta.rosetta.core.pack.interaction_graph.SimpleInteractionGraph) → pyrosetta.rosetta.std.list_std_shared_ptr_const_core_scoring_methods_EnergyMethod_std_allocator_std_shared_ptr_const_core_scoring_methods_EnergyMethod_t

C++: core::pack::interaction_graph::SimpleInteractionGraph::setup_for_scoring_for_residue_energy_methods() –> const class std::list<class std::shared_ptr<const class core::scoring::methods::EnergyMethod>, class std::allocator<class std::shared_ptr<const class core::scoring::methods::EnergyMethod> > > &

total_energy(self: pyrosetta.rosetta.core.pack.interaction_graph.NPDHBSimpleInteractionGraph) → float

C++: core::pack::interaction_graph::NPDHBSimpleInteractionGraph::total_energy() –> double

unused_hbond(self: pyrosetta.rosetta.core.pack.interaction_graph.NPDHBSimpleInteractionGraph) → core::pack::interaction_graph::NPDHBond

C++: core::pack::interaction_graph::NPDHBSimpleInteractionGraph::unused_hbond() –> class std::shared_ptr<struct core::pack::interaction_graph::NPDHBond>

class pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots

Bases: pybind11_builtins.pybind11_object

Handles sphere-sphere overlap calculations for the HPatchInteractionGraph.

One big change from the r++ version of this class is that this class now includes all of the information that was previously stored in the RotamerCoords class. Since I’m not storing atoms in trie ordering (perhaps I’ll add this later), there is no need to have a separate class for the rotamer coordinates.

RotamerDots hold DotSphere objects for the atoms of a given Residue (or really, of the current state on some interaction graph Node). Default use of the class will result in RotamerDots objects keeping DotSpheres for every atom of a residue. For the hpatch interaction graph, though, we only care about the SASA of the heavy atoms. No need to include the hydrogens when looking for hydrophobic patches. By not keeping track of the hydrogens, we save a huge amount of time on computing updates to the SASA score because hydrogen atoms generally make up half of a protein. So I’m adding a boolean flag to the non-default constructor which toggles whether we’re tracking SASA of all atoms, or just the heavy atoms.

Two other big changes being made to this class are that 1) the class will now keep track of two kinds of SASA and 2) it will no longer keep score or score_is_current variables. The two kinds of SASA the class will keep track of are the standard SASA, and a SASA with polar atom radii extended. The expanded polar SASA will only be kept if a boolean flag is set at construct time. If not, it will just calculate standard SASA and that’s it. The second change is that this class is now only keeping track of SASA. RotamerDots objects will not be responsible for calculating a score.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots) -> None
2. __init__(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots, arg0: pyrosetta.rosetta.core.conformation.Residue) -> None

doc

3. __init__(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots, arg0: pyrosetta.rosetta.core.conformation.Residue, arg1: bool) -> None

doc

4. __init__(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots, rotamer: pyrosetta.rosetta.core.conformation.Residue, exclude_hydrogen_atoms: bool, use_expanded_polar_atom_radii: bool) -> None
5. __init__(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots, arg0: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots, rhs: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots) → bool

C++: core::pack::interaction_graph::RotamerDots::operator!=(const class core::pack::interaction_graph::RotamerDots &) –> bool

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots) → str

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

assign(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots, rhs: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots) → pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots

C++: core::pack::interaction_graph::RotamerDots::operator=(const class core::pack::interaction_graph::RotamerDots &) –> class core::pack::interaction_graph::RotamerDots &

copy(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots, rhs: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots) → None

C++: core::pack::interaction_graph::RotamerDots::copy(const class core::pack::interaction_graph::RotamerDots &) –> void

decrement_from_cached(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots, cached_dot_overlap: core::pack::interaction_graph::RotamerDotsCache) → None

C++: core::pack::interaction_graph::RotamerDots::decrement_from_cached(const class core::pack::interaction_graph::RotamerDotsCache &) –> void

dot_coord(index: int) → pyrosetta.rosetta.numeric.xyzVector_double_t

C++: core::pack::interaction_graph::RotamerDots::dot_coord(unsigned long) –> class numeric::xyzVector<double>

get_atom_coords_xyz(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots, atom_index: int) → pyrosetta.rosetta.numeric.xyzVector_double_t

C++: core::pack::interaction_graph::RotamerDots::get_atom_coords_xyz(unsigned long) const –> class numeric::xyzVector<double>

get_atom_counts(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots) → pyrosetta.rosetta.utility.vector1_core_pack_interaction_graph_DotSphere

C++: core::pack::interaction_graph::RotamerDots::get_atom_counts() –> const class utility::vector1<class core::pack::interaction_graph::DotSphere, class std::allocator<class core::pack::interaction_graph::DotSphere> > &

get_atom_radius(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots, atom_index: int) → float

C++: core::pack::interaction_graph::RotamerDots::get_atom_radius(unsigned long) const –> double

get_atom_sasa(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots, atom_index: int) → float

C++: core::pack::interaction_graph::RotamerDots::get_atom_sasa(unsigned long) const –> double

get_num_atoms(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots) → int

C++: core::pack::interaction_graph::RotamerDots::get_num_atoms() const –> unsigned long

get_num_covered_total(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots) → int

C++: core::pack::interaction_graph::RotamerDots::get_num_covered_total() const –> unsigned long

get_num_uncovered(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots, atom: int) → int

C++: core::pack::interaction_graph::RotamerDots::get_num_uncovered(unsigned long) const –> unsigned long

get_radii(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots) → pyrosetta.rosetta.utility.vector1_double

C++: core::pack::interaction_graph::RotamerDots::get_radii() const –> const class utility::vector1<double, class std::allocator<double> > *

get_sasa(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots) → float

C++: core::pack::interaction_graph::RotamerDots::get_sasa() const –> double

increment_both(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots, other: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots) → None

C++: core::pack::interaction_graph::RotamerDots::increment_both(class core::pack::interaction_graph::RotamerDots &) –> void

increment_both_and_cache(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots, other_rotamer: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots, others_dots_covered_by_this: core::pack::interaction_graph::RotamerDotsCache, this_dots_covered_by_other: core::pack::interaction_graph::RotamerDotsCache, atom_atom_overlaps_cache: pyrosetta.rosetta.utility.vector1_utility_vector1_bool_std_allocator_bool_t) → None

C++: core::pack::interaction_graph::RotamerDots::increment_both_and_cache(class core::pack::interaction_graph::RotamerDots &, class core::pack::interaction_graph::RotamerDotsCache &, class core::pack::interaction_graph::RotamerDotsCache &, class utility::vector1<class utility::vector1<bool, class std::allocator<bool> >, class std::allocator<class utility::vector1<bool, class std::allocator<bool> > > > &) –> void

increment_from_cached(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots, cached_dot_overlap: core::pack::interaction_graph::RotamerDotsCache) → None

C++: core::pack::interaction_graph::RotamerDots::increment_from_cached(const class core::pack::interaction_graph::RotamerDotsCache &) –> void

increment_self_overlap(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots) → None

C++: core::pack::interaction_graph::RotamerDots::increment_self_overlap() –> void

increment_this_and_cache(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots, other: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots, this_overlap_on_other: core::pack::interaction_graph::RotamerDotsCache, atom_atom_overlaps_cache: pyrosetta.rosetta.utility.vector1_utility_vector1_bool_std_allocator_bool_t) → None

C++: core::pack::interaction_graph::RotamerDots::increment_this_and_cache(const class core::pack::interaction_graph::RotamerDots &, class core::pack::interaction_graph::RotamerDotsCache &, class utility::vector1<class utility::vector1<bool, class std::allocator<bool> >, class std::allocator<class utility::vector1<bool, class std::allocator<bool> > > > &) –> void

max_atom_radius(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots) → float

C++: core::pack::interaction_graph::RotamerDots::max_atom_radius() –> double

name3(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots) → str

C++: core::pack::interaction_graph::RotamerDots::name3() const –> std::string

overlaps(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots, other: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots) → bool

C++: core::pack::interaction_graph::RotamerDots::overlaps(const class core::pack::interaction_graph::RotamerDots &) const –> bool

print(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots, os: pyrosetta.rosetta.std.ostream) → None

C++: core::pack::interaction_graph::RotamerDots::print(class std::basic_ostream<char> &) const –> void

radius_for_attype(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots, attype_index: int) → float

C++: core::pack::interaction_graph::RotamerDots::radius_for_attype(const unsigned long) –> double

rotamer(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots) → pyrosetta.rosetta.core.conformation.Residue

C++: core::pack::interaction_graph::RotamerDots::rotamer() const –> class std::shared_ptr<const class core::conformation::Residue>

seqpos(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots) → int

C++: core::pack::interaction_graph::RotamerDots::seqpos() const –> unsigned long

state_unassigned(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots) → bool

C++: core::pack::interaction_graph::RotamerDots::state_unassigned() const –> bool

zero(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDots) → None

C++: core::pack::interaction_graph::RotamerDots::zero() –> void

class pyrosetta.rosetta.core.pack.interaction_graph.RotamerDotsCache

Bases: pybind11_builtins.pybind11_object

A lightweight version of the RotamerDots class. Used to cache overlap between interaction graph Nodes and BGNodes.

During packing, when a first class node has to respond to another Node changing state, it’s faster to decrement the coverage the previous state produced and increment the coverage the new state produces than to completely recalculate how the new state overlaps the node. But instead of holding that coverage information in a RotamerDots object (which does alot of other things), hold it in this cache class instead.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDotsCache) -> None
2. __init__(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDotsCache, num_atoms: int) -> None
3. __init__(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDotsCache, arg0: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDotsCache) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

assign(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDotsCache, rhs: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDotsCache) → pyrosetta.rosetta.core.pack.interaction_graph.RotamerDotsCache

C++: core::pack::interaction_graph::RotamerDotsCache::operator=(const class core::pack::interaction_graph::RotamerDotsCache &) –> class core::pack::interaction_graph::RotamerDotsCache &

get_atom_counts(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDotsCache) → pyrosetta.rosetta.utility.vector1_core_pack_interaction_graph_DotSphere

C++: core::pack::interaction_graph::RotamerDotsCache::get_atom_counts() const –> const class utility::vector1<class core::pack::interaction_graph::DotSphere, class std::allocator<class core::pack::interaction_graph::DotSphere> > &

print(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDotsCache, os: pyrosetta.rosetta.std.ostream) → None

C++: core::pack::interaction_graph::RotamerDotsCache::print(class std::basic_ostream<char> &) const –> void

resize(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDotsCache, num_atoms: int) → None

C++: core::pack::interaction_graph::RotamerDotsCache::resize(unsigned long) –> void

zero(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDotsCache) → None

C++: core::pack::interaction_graph::RotamerDotsCache::zero() –> void

class pyrosetta.rosetta.core.pack.interaction_graph.RotamerDotsRadiusData

Bases: pyrosetta.rosetta.utility.SingletonBase_core_pack_interaction_graph_RotamerDotsRadiusData_t

A singleton class which reads in database SASA radii files and provides accessors for those values to the RotamerDots class.

The RotamerDots class keeps track of the SASA of some rotamer using DotSphere objects and lots of get overlap calls on atoms. The SASA of a given atom (or residue) depends on what radii are used for the atoms. Different program use different sets of radii, and for the hpatch score, the polar atom radii are expanded. Previously RotamerDots objects would have a static vector member variable that represented the particular set of radii being used. It would also have a second static vector member variable that represented the expanded polar version of the radii. So, no matter how many instances of RotamerDots objects we created, we only maintained two vectors for the radii. Now, we want to make the RotamerDots class only use one set of radii for the hpatch score: the expanded polar radii. The super easy solution would be to remove all the logic that keeps track of SASA when using the standard radii and make the RotamerDots class only calculate that kind of SASA. But, there will probably be more uses in the future for a RotamerDots class that can calculate SASA with a standard set of radii than with the expanded polar ones. So, that’s where this class comes in. It will read in database files, depending on which set of radii are requested and provide access to that data in some way.

Let’s say we have to create RotamerDots objects for two different sets of SASA radii. When those objects are constructed a pointer to the right set of radii will have to be set. Definitely don’t want to copy/store the radii to each instance. If I make it a pointer to this class, then it would only work for one set of radii. So at RotamerDots construct time we have to ask this class to give us a pointer to the set of radii that are requested. Then only one instance of this class exists, and all RotamerDots objects have pointers set to the radii they care about. What would this change in the RotamerDots API? The get_radius() function would dereference the pointer and index into the vector to get the right radius. This structure is similar to how the ChemicalManager works. But, in that class, the functions return AtomTypeSet objects.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__

Initialize self. See help(type(self)) for accurate signature.

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

get_NACCESS_SASA_radii(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDotsRadiusData) → pyrosetta.rosetta.utility.vector1_double

return a pointer to the SASA radii used by NACCESS

C++: core::pack::interaction_graph::RotamerDotsRadiusData::get_NACCESS_SASA_radii() const –> const class utility::vector1<double, class std::allocator<double> > *

get_NACCESS_SASA_radii_with_expanded_polars(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDotsRadiusData) → pyrosetta.rosetta.utility.vector1_double

return a pointer to the SASA radii used by NACCESS, with polar atom radii expanded

C++: core::pack::interaction_graph::RotamerDotsRadiusData::get_NACCESS_SASA_radii_with_expanded_polars() const –> const class utility::vector1<double, class std::allocator<double> > *

get_ROSETTA_SASA_radii(self: pyrosetta.rosetta.core.pack.interaction_graph.RotamerDotsRadiusData) → pyrosetta.rosetta.utility.vector1_double

return a pointer to the standard Rosetta SASA radii

C++: core::pack::interaction_graph::RotamerDotsRadiusData::get_ROSETTA_SASA_radii() const –> const class utility::vector1<double, class std::allocator<double> > *

get_instance() → core::pack::interaction_graph::RotamerDotsRadiusData

C++: utility::SingletonBase<core::pack::interaction_graph::RotamerDotsRadiusData>::get_instance() –> class core::pack::interaction_graph::RotamerDotsRadiusData *

class pyrosetta.rosetta.core.pack.interaction_graph.SimpleInteractionGraph

Bases: pyrosetta.rosetta.utility.graph.Graph

A simple graph class for calculating pairwise decomposable energies as sidechains are moving on a fixed backbone. This class is responsible for calculating energy changes, but is passive about how the sidechains are changing. There are two main ways to drive the graph: one where the graph ACTIVELY takes charge of updating pointers to the sidechains, where, each external change of one pointer triggers an update to the energies; and a second, where the graph is PASSIVE wrt the pointers, and they must be maintained by an external driver.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.pack.interaction_graph.SimpleInteractionGraph) -> None
2. __init__(self: pyrosetta.rosetta.core.pack.interaction_graph.SimpleInteractionGraph, arg0: pyrosetta.rosetta.core.pack.interaction_graph.SimpleInteractionGraph) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

add_edge(*args, **kwargs)

Overloaded function.

1. add_edge(self: pyrosetta.rosetta.utility.graph.Graph, node1: int, node2: int) -> pyrosetta.rosetta.utility.graph.Edge

add an edge between two vertices. Invokes “create_edge” from the derived class.

Returns a pointer to the edge after its been added, allowing the calling function to immediately set data for this edge.

C++: utility::graph::Graph::add_edge(unsigned long, unsigned long) –> class utility::graph::Edge *

2. add_edge(self: pyrosetta.rosetta.utility.graph.Graph, example_edge: pyrosetta.rosetta.utility.graph.Edge) -> pyrosetta.rosetta.utility.graph.Edge

add an edge to this graph copying the data from an edge in another graph.

Returns a pointer to the edge after its been added, allowing the calling function to immediately set data for this edge.

C++: utility::graph::Graph::add_edge(const class utility::graph::Edge *) –> class utility::graph::Edge *

all_pairs_shortest_paths(self: pyrosetta.rosetta.utility.graph.Graph) → ObjexxFCL::FArray2D<int>

O(V^3). Computes all pairs shortest paths using Warshall’s algorithm

and writes all the path distances to the two-dimensional table.

C++: utility::graph::Graph::all_pairs_shortest_paths() const –> class ObjexxFCL::FArray2D<int>

assign(self: pyrosetta.rosetta.core.pack.interaction_graph.SimpleInteractionGraph, : pyrosetta.rosetta.core.pack.interaction_graph.SimpleInteractionGraph) → pyrosetta.rosetta.core.pack.interaction_graph.SimpleInteractionGraph

C++: core::pack::interaction_graph::SimpleInteractionGraph::operator=(const class core::pack::interaction_graph::SimpleInteractionGraph &) –> class core::pack::interaction_graph::SimpleInteractionGraph &

commit_change(self: pyrosetta.rosetta.core.pack.interaction_graph.SimpleInteractionGraph, node_id: int) → None

C++: core::pack::interaction_graph::SimpleInteractionGraph::commit_change(unsigned long) –> void

consider_substitution(self: pyrosetta.rosetta.core.pack.interaction_graph.SimpleInteractionGraph, node_id: int, new_state: pyrosetta.rosetta.core.conformation.Residue, residue_data_cache: pyrosetta.rosetta.basic.datacache.BasicDataCache) → float

C++: core::pack::interaction_graph::SimpleInteractionGraph::consider_substitution(unsigned long, class std::shared_ptr<const class core::conformation::Residue>, class basic::datacache::BasicDataCache &) –> double

const_edge_list_begin(self: pyrosetta.rosetta.utility.graph.Graph) → pyrosetta.rosetta.utility.graph.EdgeListConstIterator

returns a const iterator to the beginning of the (unordered) edge list for the graph.

this edge list contains all the edges in the graph, not simply those for a particular vertex

C++: utility::graph::Graph::const_edge_list_begin() const –> class utility::graph::EdgeListConstIterator

const_edge_list_end(self: pyrosetta.rosetta.utility.graph.Graph) → pyrosetta.rosetta.utility.graph.EdgeListConstIterator

returns a const iterator to the end of the (unordered) edge list for the graph.

this edge list contains all the edges in the graph, not simply those for a particular vertex

C++: utility::graph::Graph::const_edge_list_end() const –> class utility::graph::EdgeListConstIterator

copy_connectivity(self: pyrosetta.rosetta.utility.graph.Graph, source: pyrosetta.rosetta.utility.graph.Graph) → None

copy the edge connectivity from a source graph with a potentially

unknown type.

C++: utility::graph::Graph::copy_connectivity(const class utility::graph::Graph &) –> void

count_dynamic_memory(self: pyrosetta.rosetta.core.pack.interaction_graph.SimpleInteractionGraph) → int

C++: core::pack::interaction_graph::SimpleInteractionGraph::count_dynamic_memory() const –> unsigned long

count_static_memory(self: pyrosetta.rosetta.core.pack.interaction_graph.SimpleInteractionGraph) → int

C++: core::pack::interaction_graph::SimpleInteractionGraph::count_static_memory() const –> unsigned long

delete_edge(self: pyrosetta.rosetta.core.pack.interaction_graph.SimpleInteractionGraph, : pyrosetta.rosetta.utility.graph.Edge) → None

C++: core::pack::interaction_graph::SimpleInteractionGraph::delete_edge(class utility::graph::Edge *) –> void

drop_all_edges(self: pyrosetta.rosetta.utility.graph.Graph) → None

delete all the edges present in the graph

C++: utility::graph::Graph::drop_all_edges() –> void

drop_all_edges_for_node(self: pyrosetta.rosetta.utility.graph.Graph, node: int) → None

delete all the edges for a single vertex in the graph

C++: utility::graph::Graph::drop_all_edges_for_node(unsigned long) –> void

edge_list_begin(self: pyrosetta.rosetta.utility.graph.Graph) → pyrosetta.rosetta.utility.graph.EdgeListIterator

returns a non-const iterator to the beginning of the (unordered) edge list for the graph.

this edge list contains all the edges in the graph, not simply those for a particular vertex

C++: utility::graph::Graph::edge_list_begin() –> class utility::graph::EdgeListIterator

edge_list_end(self: pyrosetta.rosetta.utility.graph.Graph) → pyrosetta.rosetta.utility.graph.EdgeListIterator

returns a non-const iterator to the end of the (unordered) edge list for the graph.

this edge list contains all the edges in the graph, not simply those for a particular vertex

C++: utility::graph::Graph::edge_list_end() –> class utility::graph::EdgeListIterator

find_edge(self: pyrosetta.rosetta.utility.graph.Graph, node1: int, node2: int) → pyrosetta.rosetta.utility.graph.Edge

returns a pointer to the edge connecting nodes node1 and node2, if that edge exists

in the graph, o.w. returns 0. Focuses the graph on this edge for fast subsequent retrieval.

C++: utility::graph::Graph::find_edge(unsigned long, unsigned long) –> class utility::graph::Edge *

focused_edge(self: pyrosetta.rosetta.utility.graph.Graph) → pyrosetta.rosetta.utility.graph.Edge

returns a pointer to the focused edge

C++: utility::graph::Graph::focused_edge() –> class utility::graph::Edge *

getTotalMemoryUsage(self: pyrosetta.rosetta.utility.graph.Graph) → int

returns a count of all the memory used by every vertex and edge in a graph

by invoking the polymorphic count_static_memory and count_dynamic_memory of each (possibly derived) node and edge object as well as for the (possibly derived) graph class.

C++: utility::graph::Graph::getTotalMemoryUsage() const –> unsigned long

get_alternate_for_node(self: pyrosetta.rosetta.core.pack.interaction_graph.SimpleInteractionGraph, id: int) → pyrosetta.rosetta.core.conformation.Residue

C++: core::pack::interaction_graph::SimpleInteractionGraph::get_alternate_for_node(unsigned long) const –> class std::shared_ptr<const class core::conformation::Residue>

get_current_for_node(self: pyrosetta.rosetta.core.pack.interaction_graph.SimpleInteractionGraph, id: int) → pyrosetta.rosetta.core.conformation.Residue

C++: core::pack::interaction_graph::SimpleInteractionGraph::get_current_for_node(unsigned long) const –> class std::shared_ptr<const class core::conformation::Residue>

get_edge_exists(self: pyrosetta.rosetta.utility.graph.Graph, node1: int, node2: int) → bool

is an edge already present in the graph? O(V) worst case. O(1) iff all vertices have O(1) edges

C++: utility::graph::Graph::get_edge_exists(unsigned long, unsigned long) const –> bool

get_node(self: pyrosetta.rosetta.utility.graph.Graph, index: int) → pyrosetta.rosetta.utility.graph.Node

C++: utility::graph::Graph::get_node(unsigned long) –> class utility::graph::Node *

get_self_ptr(self: pyrosetta.rosetta.utility.graph.Graph) → pyrosetta.rosetta.utility.graph.Graph

C++: utility::graph::Graph::get_self_ptr() –> class std::shared_ptr<class utility::graph::Graph>

get_simple_node(self: pyrosetta.rosetta.core.pack.interaction_graph.SimpleInteractionGraph, ind: int) → pyrosetta.rosetta.core.pack.interaction_graph.SimpleNode

C++: core::pack::interaction_graph::SimpleInteractionGraph::get_simple_node(unsigned long) –> class core::pack::interaction_graph::SimpleNode *

initialize(*args, **kwargs)

Overloaded function.

1. initialize(self: pyrosetta.rosetta.core.pack.interaction_graph.SimpleInteractionGraph, pose: pyrosetta.rosetta.core.pose.Pose) -> None

Initialization where the graph adds its own edges; use set_pose_no_initialize

if the edges should be added externally. Assumes that the pose does not change its sequence.

C++: core::pack::interaction_graph::SimpleInteractionGraph::initialize(const class core::pose::Pose &) –> void

2. initialize(self: pyrosetta.rosetta.core.pack.interaction_graph.SimpleInteractionGraph, pose: pyrosetta.rosetta.core.pose.Pose, task: pyrosetta.rosetta.core.pack.task.PackerTask) -> None

Initialization where the graph creates a packer-neighbor graph from the input

packer task so that edges between residues that might become larger than they are in the input Pose (e.g., GLY –> ARG mutation) can be added to the graph.

C++: core::pack::interaction_graph::SimpleInteractionGraph::initialize(const class core::pose::Pose &, class std::shared_ptr<const class core::pack::task::PackerTask>) –> void

num_edges(self: pyrosetta.rosetta.utility.graph.Graph) → int

C++: utility::graph::Graph::num_edges() const –> unsigned long

num_nodes(self: pyrosetta.rosetta.utility.graph.Graph) → int

the number of nodes in the graph

C++: utility::graph::Graph::num_nodes() const –> unsigned long

output_connectivity(self: pyrosetta.rosetta.utility.graph.Graph, os: pyrosetta.rosetta.std.ostream) → None

send an edge list to the stream os.

C++: utility::graph::Graph::output_connectivity(class std::basic_ostream<char> &) const –> void

output_dimacs(self: pyrosetta.rosetta.utility.graph.Graph, os: pyrosetta.rosetta.std.ostream) → None

describe this graph in dimacs form to the stream os.

C++: utility::graph::Graph::output_dimacs(class std::basic_ostream<char> &) const –> void

pose(self: pyrosetta.rosetta.core.pack.interaction_graph.SimpleInteractionGraph) → pyrosetta.rosetta.core.pose.Pose

C++: core::pack::interaction_graph::SimpleInteractionGraph::pose() const –> const class core::pose::Pose &

pose_cop(self: pyrosetta.rosetta.core.pack.interaction_graph.SimpleInteractionGraph) → pyrosetta.rosetta.core.pose.Pose

C++: core::pack::interaction_graph::SimpleInteractionGraph::pose_cop() const –> class std::shared_ptr<const class core::pose::Pose>

print_vertices(self: pyrosetta.rosetta.utility.graph.Graph) → None

send summary information to the screen for all vertices in the graph

C++: utility::graph::Graph::print_vertices() const –> void

reject_change(self: pyrosetta.rosetta.core.pack.interaction_graph.SimpleInteractionGraph, node_id: int, res: pyrosetta.rosetta.core.conformation.Residue, residue_data_cache: pyrosetta.rosetta.basic.datacache.BasicDataCache) → None

C++: core::pack::interaction_graph::SimpleInteractionGraph::reject_change(unsigned long, class std::shared_ptr<const class core::conformation::Residue>, class basic::datacache::BasicDataCache &) –> void

scorefunction(self: pyrosetta.rosetta.core.pack.interaction_graph.SimpleInteractionGraph) → pyrosetta.rosetta.core.scoring.ScoreFunction

C++: core::pack::interaction_graph::SimpleInteractionGraph::scorefunction() const –> const class core::scoring::ScoreFunction &

set_num_nodes(self: pyrosetta.rosetta.utility.graph.Graph, num_nodes: int) → None

set the number of nodes in the graph – deletes any existing edges in the graph

C++: utility::graph::Graph::set_num_nodes(unsigned long) –> void

set_pose_no_initialize(self: pyrosetta.rosetta.core.pack.interaction_graph.SimpleInteractionGraph, pose: pyrosetta.rosetta.core.pose.Pose) → None

Initialize the graph so that all nodes take their current state from the

input Pose – this does not add any edges to the graph.

C++: core::pack::interaction_graph::SimpleInteractionGraph::set_pose_no_initialize(const class core::pose::Pose &) –> void

set_scorefunction(self: pyrosetta.rosetta.core.pack.interaction_graph.SimpleInteractionGraph, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: core::pack::interaction_graph::SimpleInteractionGraph::set_scorefunction(const class core::scoring::ScoreFunction &) –> void

setup_after_edge_addition(self: pyrosetta.rosetta.core.pack.interaction_graph.SimpleInteractionGraph) → None

If set_pose_no_initialize was called, then after edges have been added. This

function will also do any bookkeeping necessary before the start of simulated annealing

C++: core::pack::interaction_graph::SimpleInteractionGraph::setup_after_edge_addition() –> void

setup_for_scoring_for_residue_energy_methods(self: pyrosetta.rosetta.core.pack.interaction_graph.SimpleInteractionGraph) → pyrosetta.rosetta.std.list_std_shared_ptr_const_core_scoring_methods_EnergyMethod_std_allocator_std_shared_ptr_const_core_scoring_methods_EnergyMethod_t

C++: core::pack::interaction_graph::SimpleInteractionGraph::setup_for_scoring_for_residue_energy_methods() –> const class std::list<class std::shared_ptr<const class core::scoring::methods::EnergyMethod>, class std::allocator<class std::shared_ptr<const class core::scoring::methods::EnergyMethod> > > &

total_energy(self: pyrosetta.rosetta.core.pack.interaction_graph.SimpleInteractionGraph) → float

C++: core::pack::interaction_graph::SimpleInteractionGraph::total_energy() –> double

class pyrosetta.rosetta.core.pack.interaction_graph.SurfaceEnergy

Bases: pyrosetta.rosetta.core.scoring.methods.ContextDependentOneBodyEnergy

Defines a (pseudo) context-dependent one-body surface energy. Really, this class is only being used as a hack for the optE protocol so that the non-PD surface energy can be optimized together with the other PD-terms.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.core.pack.interaction_graph.SurfaceEnergy) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

assign(self: pyrosetta.rosetta.core.pack.interaction_graph.SurfaceEnergy, : pyrosetta.rosetta.core.pack.interaction_graph.SurfaceEnergy) → pyrosetta.rosetta.core.pack.interaction_graph.SurfaceEnergy

C++: core::pack::interaction_graph::SurfaceEnergy::operator=(const class core::pack::interaction_graph::SurfaceEnergy &) –> class core::pack::interaction_graph::SurfaceEnergy &

clone(self: pyrosetta.rosetta.core.pack.interaction_graph.SurfaceEnergy) → pyrosetta.rosetta.core.scoring.methods.EnergyMethod

C++: core::pack::interaction_graph::SurfaceEnergy::clone() const –> class std::shared_ptr<class core::scoring::methods::EnergyMethod>

defines_dof_derivatives(self: pyrosetta.rosetta.core.scoring.methods.OneBodyEnergy, p: pyrosetta.rosetta.core.pose.Pose) → bool

Use the dof_derivative interface for this energy method when

calculating derivatives? It is possible to define both dof_derivatives and atom-derivatives; they are not mutually exclusive.

C++: core::scoring::methods::OneBodyEnergy::defines_dof_derivatives(const class core::pose::Pose &) const –> bool

defines_high_order_terms(self: pyrosetta.rosetta.core.scoring.methods.EnergyMethod, : pyrosetta.rosetta.core.pose.Pose) → bool

Should this EnergyMethod have score and derivative evaluation

evaluated both in the context of the whole Pose and in the context of residue or residue-pairs? This covers scoring terms like env-smooth wherein the CBeta’s get derivatives for increasing the neighbor counts for surrounding residues, and terms like constraints, which are definable on arbitrary number of residues (e.g. more than 2); both of these terms could be used in RTMin, and both should use the residue and residue-pair evaluation scheme with the MinimizationGraph for the majority of the work they do. (Now, high-order constraints (3-body or above) will not be properly evaluated within RTMin.). The default implementation returns “false”.

C++: core::scoring::methods::EnergyMethod::defines_high_order_terms(const class core::pose::Pose &) const –> bool

defines_score_for_residue(self: pyrosetta.rosetta.core.scoring.methods.OneBodyEnergy, : pyrosetta.rosetta.core.conformation.Residue) → bool

During minimization, energy methods are allowed to decide that they say nothing

about a particular residue (e.g. no non-zero energy) and as a result they will not be queried for a derivative or an energy. The default behavior is to return “true” for all residues.

C++: core::scoring::methods::OneBodyEnergy::defines_score_for_residue(const class core::conformation::Residue &) const –> bool

eval_atom_derivative(self: pyrosetta.rosetta.core.scoring.methods.EnergyMethod, id: pyrosetta.rosetta.core.id.AtomID, pose: pyrosetta.rosetta.core.pose.Pose, domain_map: ObjexxFCL::FArray1D<int>, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, emap: pyrosetta.rosetta.core.scoring.EMapVector, F1: pyrosetta.rosetta.numeric.xyzVector_double_t, F2: pyrosetta.rosetta.numeric.xyzVector_double_t) → None

Evaluate the XYZ derivative for an atom in the pose.

Called during the atomtree derivative calculation, atom_tree_minimize.cc, through the ScoreFunction::eval_atom_derivative intermediary. F1 and F2 should not zeroed, rather, this class should accumulate its contribution from this atom’s XYZ derivative

The derivative scheme is based on that of Abe, Braun, Noguti and Go (1984) “Rapid Calculation of First and Second Derivatives of Conformational Energy with Respect to Dihedral Angles for Proteins. General Recurrent Equations” Computers & Chemistry 8(4) pp. 239-247. F1 and F2 correspond roughly to Fa and Ga, respectively, of equations 7a & 7b in that paper.

C++: core::scoring::methods::EnergyMethod::eval_atom_derivative(const class core::id::AtomID &, const class core::pose::Pose &, const class ObjexxFCL::FArray1D<int> &, const class core::scoring::ScoreFunction &, const class core::scoring::EMapVector &, class numeric::xyzVector<double> &, class numeric::xyzVector<double> &) const –> void

eval_residue_derivatives(self: pyrosetta.rosetta.core.scoring.methods.OneBodyEnergy, rsd: pyrosetta.rosetta.core.conformation.Residue, min_data: core::scoring::ResSingleMinimizationData, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector, atom_derivs: pyrosetta.rosetta.utility.vector1_core_scoring_DerivVectorPair) → None

Evaluate the derivatives for all atoms on this residue and increment them

into the input atom_derivs vector1. The calling function must guarantee that setup for derivatives is called before this function is, and that the atom_derivs vector contains at least as many entries as there are atoms in the input Residue. This base class provides a default noop implementation of this function.

C++: core::scoring::methods::OneBodyEnergy::eval_residue_derivatives(const class core::conformation::Residue &, const class core::scoring::ResSingleMinimizationData &, const class core::pose::Pose &, const class core::scoring::EMapVector &, class utility::vector1<class core::scoring::DerivVectorPair, class std::allocator<class core::scoring::DerivVectorPair> > &) const –> void

eval_residue_dof_derivative(self: pyrosetta.rosetta.core.scoring.methods.OneBodyEnergy, rsd: pyrosetta.rosetta.core.conformation.Residue, min_data: core::scoring::ResSingleMinimizationData, dof_id: pyrosetta.rosetta.core.id.DOF_ID, torsion_id: pyrosetta.rosetta.core.id.TorsionID, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, weights: pyrosetta.rosetta.core.scoring.EMapVector) → float

Evaluate the DOF derivative for a particular residue. The Pose merely serves as context,

and the input residue is not required to be a member of the Pose.

C++: core::scoring::methods::OneBodyEnergy::eval_residue_dof_derivative(const class core::conformation::Residue &, const class core::scoring::ResSingleMinimizationData &, const class core::id::DOF_ID &, const class core::id::TorsionID &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, const class core::scoring::EMapVector &) const –> double

finalize_after_derivatives(self: pyrosetta.rosetta.core.scoring.methods.EnergyMethod, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.scoring.ScoreFunction) → None

called at the end of derivatives evaluation

C++: core::scoring::methods::EnergyMethod::finalize_after_derivatives(class core::pose::Pose &, const class core::scoring::ScoreFunction &) const –> void

finalize_total_energy(self: pyrosetta.rosetta.core.pack.interaction_graph.SurfaceEnergy, pose: pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.scoring.ScoreFunction, totals: pyrosetta.rosetta.core.scoring.EMapVector) → None

C++: core::pack::interaction_graph::SurfaceEnergy::finalize_total_energy(class core::pose::Pose &, const class core::scoring::ScoreFunction &, class core::scoring::EMapVector &) const –> void

indicate_required_context_graphs(self: pyrosetta.rosetta.core.pack.interaction_graph.SurfaceEnergy, : pyrosetta.rosetta.utility.vector1_bool) → None

C++: core::pack::interaction_graph::SurfaceEnergy::indicate_required_context_graphs(class utility::vector1<bool, class std::allocator<bool> > &) const –> void

method_type(self: pyrosetta.rosetta.core.scoring.methods.ContextDependentOneBodyEnergy) → pyrosetta.rosetta.core.scoring.methods.EnergyMethodType

Returns the cd_1b element of the EnergyMethodType enumeration; this method

should NOT be overridden by derived classes.

C++: core::scoring::methods::ContextDependentOneBodyEnergy::method_type() const –> enum core::scoring::methods::EnergyMethodType

minimize_in_whole_structure_context(self: pyrosetta.rosetta.core.scoring.methods.EnergyMethod, : pyrosetta.rosetta.core.pose.Pose) → bool

Should this EnergyMethod have score and derivative evaluation

evaluated only in the context of the whole Pose, or can it be included in a decomposed manner for a residue or a set of residue-pairs that are not part of the Pose that’s serving as their context? The default method implemented in the base class returns true in order to grandfather in EnergyMethods that have not had their derivatives changed to take advantage of the new derivative-evaluation machinery. Methods that return “true” will not have their residue-energy(-ext) / residue-pair-energy(-ext) methods invoked by the ScoreFunction during its traversal of the MinimizationGraph, and instead will be asked to perform all their work during finalize_total_energies(). Similarly, they will be expected to perform all their work during eval_atom_deriv() instead of during the ScoreFunction’s traversal of the MinimizationGraph for derivative evaluation. IMPORTANT: Methods that return “true” cannot be included in RTMin.

C++: core::scoring::methods::EnergyMethod::minimize_in_whole_structure_context(const class core::pose::Pose &) const –> bool

prepare_rotamers_for_packing(self: pyrosetta.rosetta.core.scoring.methods.EnergyMethod, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.conformation.RotamerSetBase) → None

If an energy method needs to cache data in a packing::RotamerSet object before

rotamer energies are calculated, it does so during this function. The packer must ensure this function is called. The default behavior is to do nothing.

C++: core::scoring::methods::EnergyMethod::prepare_rotamers_for_packing(const class core::pose::Pose &, class core::conformation::RotamerSetBase &) const –> void

requires_a_setup_for_derivatives_for_residue_opportunity(self: pyrosetta.rosetta.core.scoring.methods.OneBodyEnergy, pose: pyrosetta.rosetta.core.pose.Pose) → bool

Does this EnergyMethod require the opportunity to examine the residue before derivative evaluation begins? Not

all energy methods would. The ScoreFunction will not ask energy methods to examine residues that are uninterested in doing so.

C++: core::scoring::methods::OneBodyEnergy::requires_a_setup_for_derivatives_for_residue_opportunity(const class core::pose::Pose &) const –> bool

requires_a_setup_for_scoring_for_residue_opportunity_during_minimization(self: pyrosetta.rosetta.core.scoring.methods.OneBodyEnergy, pose: pyrosetta.rosetta.core.pose.Pose) → bool

Does this EnergyMethod require the opportunity to examine the residue before scoring begins? Not

all energy methods would. The ScoreFunction will not ask energy methods to examine residues that are uninterested in doing so.

C++: core::scoring::methods::OneBodyEnergy::requires_a_setup_for_scoring_for_residue_opportunity_during_minimization(const class core::pose::Pose &) const –> bool

requires_a_setup_for_scoring_for_residue_opportunity_during_regular_scoring(self: pyrosetta.rosetta.core.scoring.methods.EnergyMethod, pose: pyrosetta.rosetta.core.pose.Pose) → bool

Does this EnergyMethod require the opportunity to examine the residue before (regular) scoring begins? Not

all energy methods would. The ScoreFunction will not ask energy methods to examine residues that are uninterested in doing so. The default implmentation of this function returns false

C++: core::scoring::methods::EnergyMethod::requires_a_setup_for_scoring_for_residue_opportunity_during_regular_scoring(const class core::pose::Pose &) const –> bool

residue_energy(self: pyrosetta.rosetta.core.pack.interaction_graph.SurfaceEnergy, rsd: pyrosetta.rosetta.core.conformation.Residue, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.scoring.EMapVector) → None

C++: core::pack::interaction_graph::SurfaceEnergy::residue_energy(const class core::conformation::Residue &, const class core::pose::Pose &, class core::scoring::EMapVector &) const –> void

residue_energy_ext(self: pyrosetta.rosetta.core.scoring.methods.OneBodyEnergy, rsd: pyrosetta.rosetta.core.conformation.Residue, min_data: core::scoring::ResSingleMinimizationData, pose: pyrosetta.rosetta.core.pose.Pose, emap: pyrosetta.rosetta.core.scoring.EMapVector) → None

Evaluate the one-body energies for a particular residue, in the context of a

given Pose, and with the help of a piece of cached data for minimization, increment those one body energies into the input EnergyMap. The calling function must guarantee that this EnergyMethod has had the opportunity to update the input ResSingleMinimizationData object for the given residue in a call to setup_for_minimizing_for_residue before this function is invoked. This function should not be called unless the use_extended_residue_energy_interface() method returns “true”. Default implementation provided by this base class calls utility::exit(). The Pose merely serves as context, and the input residue is not required to be a member of the Pose.

C++: core::scoring::methods::OneBodyEnergy::residue_energy_ext(const class core::conformation::Residue &, const class core::scoring::ResSingleMinimizationData &, const class core::pose::Pose &, class core::scoring::EMapVector &) const –> void

score_types(self: pyrosetta.rosetta.core.scoring.methods.EnergyMethod) → pyrosetta.rosetta.utility.vector1_core_scoring_ScoreType

Returns the score types that this energy method computes.

C++: core::scoring::methods::EnergyMethod::score_types() const –> const class utility::vector1<enum core::scoring::ScoreType, class std::allocator<enum core::scoring::ScoreType> > &

setup_for_derivatives(self: pyrosetta.rosetta.core.scoring.methods.EnergyMethod, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

Called immediately before atom- and DOF-derivatives are calculated

allowing the derived class a chance to prepare for future calls.

C++: core::scoring::methods::EnergyMethod::setup_for_derivatives(class core::pose::Pose &, const class core::scoring::ScoreFunction &) const –> void

setup_for_derivatives_for_residue(self: pyrosetta.rosetta.core.scoring.methods.OneBodyEnergy, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, min_data: core::scoring::ResSingleMinimizationData, res_data_cache: pyrosetta.rosetta.basic.datacache.BasicDataCache) → None

Do any setup work necessary before evaluating the derivatives for this residue

C++: core::scoring::methods::OneBodyEnergy::setup_for_derivatives_for_residue(const class core::conformation::Residue &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, class core::scoring::ResSingleMinimizationData &, class basic::datacache::BasicDataCache &) const –> void

setup_for_minimizing(self: pyrosetta.rosetta.core.scoring.methods.EnergyMethod, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.scoring.ScoreFunction, : pyrosetta.rosetta.core.kinematics.MinimizerMapBase) → None

Called at the beginning of atom tree minimization, this method

allows the derived class the opportunity to initialize pertinent data that will be used during minimization. During minimzation, the chemical structure of the pose is constant, so assumptions on the number of atoms per residue and their identities are safe so long as the pose’s Energies object’s “use_nblist()” method returns true.

C++: core::scoring::methods::EnergyMethod::setup_for_minimizing(class core::pose::Pose &, const class core::scoring::ScoreFunction &, const class core::kinematics::MinimizerMapBase &) const –> void

setup_for_minimizing_for_residue(self: pyrosetta.rosetta.core.scoring.methods.OneBodyEnergy, rsd: pyrosetta.rosetta.core.conformation.Residue, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.scoring.ScoreFunction, : pyrosetta.rosetta.core.kinematics.MinimizerMapBase, : pyrosetta.rosetta.basic.datacache.BasicDataCache, : core::scoring::ResSingleMinimizationData) → None

Called at the beginning of minimization, allowing this energy method to cache data

pertinent for a single residue in the the ResSingleMinimizationData that is used for a particular residue in the context of a particular Pose. This base class provides a noop implementation for this function if there is nothing that the derived class needs to perform in this setup phase. The Pose merely serves as context, and the input residue is not required to be a member of the Pose.

C++: core::scoring::methods::OneBodyEnergy::setup_for_minimizing_for_residue(const class core::conformation::Residue &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, const class core::kinematics::MinimizerMapBase &, class basic::datacache::BasicDataCache &, class core::scoring::ResSingleMinimizationData &) const –> void

setup_for_packing(self: pyrosetta.rosetta.core.scoring.methods.EnergyMethod, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.utility.vector1_bool, : pyrosetta.rosetta.utility.vector1_bool) → None

if an energy method needs to cache data in the Energies object,

before packing begins, then it does so during this function. The packer must ensure this function is called. The default behavior is to do nothing.

C++: core::scoring::methods::EnergyMethod::setup_for_packing(class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &, const class utility::vector1<bool, class std::allocator<bool> > &) const –> void

setup_for_scoring(self: pyrosetta.rosetta.core.pack.interaction_graph.SurfaceEnergy, pose: pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: core::pack::interaction_graph::SurfaceEnergy::setup_for_scoring(class core::pose::Pose &, const class core::scoring::ScoreFunction &) const –> void

setup_for_scoring_for_residue(*args, **kwargs)

Overloaded function.

1. setup_for_scoring_for_residue(self: pyrosetta.rosetta.core.scoring.methods.OneBodyEnergy, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, residue_data_cache: pyrosetta.rosetta.basic.datacache.BasicDataCache) -> None
2. setup_for_scoring_for_residue(self: pyrosetta.rosetta.core.scoring.methods.OneBodyEnergy, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, min_data: core::scoring::ResSingleMinimizationData) -> None

Do any setup work should the coordinates of this residue, who is still guaranteed to be

of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically as to possibly require some amount of setup work before scoring should proceed

C++: core::scoring::methods::OneBodyEnergy::setup_for_scoring_for_residue(const class core::conformation::Residue &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, class core::scoring::ResSingleMinimizationData &) const –> void

show_additional_info(self: pyrosetta.rosetta.core.scoring.methods.EnergyMethod, : pyrosetta.rosetta.std.ostream, : pyrosetta.rosetta.core.pose.Pose, : bool) → None

show additional information of the energy method

C++: core::scoring::methods::EnergyMethod::show_additional_info(class std::basic_ostream<char> &, class core::pose::Pose &, bool) const –> void

update_residue_for_packing(self: pyrosetta.rosetta.core.scoring.methods.EnergyMethod, : pyrosetta.rosetta.core.pose.Pose, resid: int) → None

If the pose changes in the middle of a packing (as happens in rotamer trials) and if

an energy method needs to cache data in the pose that corresponds to its current state, then the method must update that data when this function is called. The packer must ensure this function gets called. The default behavior is to do nothing.

C++: core::scoring::methods::EnergyMethod::update_residue_for_packing(class core::pose::Pose &, unsigned long) const –> void

use_extended_residue_energy_interface(self: pyrosetta.rosetta.core.scoring.methods.OneBodyEnergy) → bool

Rely on the extended version of the residue_energy function during score-function

evaluation in minimization? The extended version (below) takes a ResSingleMinimizationData. Return ‘true’ for the extended version. The default method implemented in this class returns ‘false’

C++: core::scoring::methods::OneBodyEnergy::use_extended_residue_energy_interface() const –> bool

version(self: pyrosetta.rosetta.core.scoring.methods.EnergyMethod) → int

Return the version of the energy method

C++: core::scoring::methods::EnergyMethod::version() const –> unsigned long

class pyrosetta.rosetta.core.pack.interaction_graph.SurfacePotential

Bases: pyrosetta.rosetta.utility.SingletonBase_core_pack_interaction_graph_SurfacePotential_t

With the traditional scoring hierarchy, classes like this one are created and accessed via the ScoringManager, which is itself a Singleton class. These “potential” classes are only created and initialized when the use of the EnergyMethod these classes correspond is encountered. No point in reading database files for a term if that term is not being used in some score function. However, the surface energy is used when users specify they want to use it on the command line - NOT via a score function. The score/energy is done within an interaction graph. One might ask why I just don’t put the logic for reading in the database file to the interaction graph init methods. However, there will be cases where I will want to just score a protein (and not do any design) where I will want the database file to be read in. Scoring doesn’t use interaction graphs, so if the code for that was located there, these values would not be read in. Instead, I’ve decided to implement this as its own separate class. It uses the Singleton design pattern so the database will only get read in once during a run.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__

Initialize self. See help(type(self)) for accurate signature.

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

average_residue_hASA(self: pyrosetta.rosetta.core.pack.interaction_graph.SurfacePotential, aa_type: pyrosetta.rosetta.core.chemical.AA, num_nbs: int) → float

C++: core::pack::interaction_graph::SurfacePotential::average_residue_hASA(enum core::chemical::AA, unsigned long) –> double

compute_pose_hpatch_score(*args, **kwargs)

Overloaded function.

1. compute_pose_hpatch_score(self: pyrosetta.rosetta.core.pack.interaction_graph.SurfacePotential, pose: pyrosetta.rosetta.core.pose.Pose) -> float

return the hpatch score for an entire pose

C++: core::pack::interaction_graph::SurfacePotential::compute_pose_hpatch_score(const class core::pose::Pose &) –> double

2. compute_pose_hpatch_score(self: pyrosetta.rosetta.core.pack.interaction_graph.SurfacePotential, pose: pyrosetta.rosetta.core.pose.Pose, total_hpatch_energy_: float, patch_scores_: pyrosetta.rosetta.std.map_unsigned_long_std_pair_double_double_t, atoms_in_patches_: pyrosetta.rosetta.std.map_unsigned_long_utility_vector1_core_id_AtomID_std_allocator_core_id_AtomID_t) -> None

C++: core::pack::interaction_graph::SurfacePotential::compute_pose_hpatch_score(const class core::pose::Pose &, double &, class std::map<unsigned long, struct std::pair<double, double>, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, struct std::pair<double, double> > > > &, class std::map<unsigned long, class utility::vector1<class core::id::AtomID, class std::allocator<class core::id::AtomID> >, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class utility::vector1<class core::id::AtomID, class std::allocator<class core::id::AtomID> > > > > &) –> void

compute_pose_surface_energy(*args, **kwargs)

Overloaded function.

1. compute_pose_surface_energy(self: pyrosetta.rosetta.core.pack.interaction_graph.SurfacePotential, pose: pyrosetta.rosetta.core.pose.Pose, surface_energy_: float) -> None

C++: core::pack::interaction_graph::SurfacePotential::compute_pose_surface_energy(const class core::pose::Pose &, double &) –> void

2. compute_pose_surface_energy(self: pyrosetta.rosetta.core.pack.interaction_graph.SurfacePotential, pose: pyrosetta.rosetta.core.pose.Pose, total_surface_energy_: float, residue_surface_energy_: pyrosetta.rosetta.utility.vector1_double) -> None

C++: core::pack::interaction_graph::SurfacePotential::compute_pose_surface_energy(const class core::pose::Pose &, double &, class utility::vector1<double, class std::allocator<double> > &) –> void

compute_residue_surface_energy(self: pyrosetta.rosetta.core.pack.interaction_graph.SurfacePotential, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, emap: pyrosetta.rosetta.core.scoring.EMapVector, resid: int, num_neighbors_: pyrosetta.rosetta.utility.vector1_unsigned_long) → None

C++: core::pack::interaction_graph::SurfacePotential::compute_residue_surface_energy(const class core::conformation::Residue &, const class core::pose::Pose &, class core::scoring::EMapVector &, unsigned long, class utility::vector1<unsigned long, class std::allocator<unsigned long> >) –> void

get_instance() → core::pack::interaction_graph::SurfacePotential

C++: utility::SingletonBase<core::pack::interaction_graph::SurfacePotential>::get_instance() –> class core::pack::interaction_graph::SurfacePotential *

hASA_patch_energy(self: pyrosetta.rosetta.core.pack.interaction_graph.SurfacePotential, patch_area: float, num_nbs: int) → float

C++: core::pack::interaction_graph::SurfacePotential::hASA_patch_energy(double, unsigned long) –> double

hpatch_score(self: pyrosetta.rosetta.core.pack.interaction_graph.SurfacePotential, patch_area: float) → float

C++: core::pack::interaction_graph::SurfacePotential::hpatch_score(double) –> double

pyrosetta.rosetta.core.pack.interaction_graph.compute_alt_weights_for_npd_hbonds(res: pyrosetta.rosetta.core.conformation.Residue, atom_hbonds: pyrosetta.rosetta.utility.vector1_utility_vector1_std_shared_ptr_core_pack_interaction_graph_NPDHBond_std_allocator_std_shared_ptr_core_pack_interaction_graph_NPDHBond_t, tmp_energies: pyrosetta.rosetta.utility.vector1_double, temp_weights: pyrosetta.rosetta.utility.vector1_double) → None

Compute the don_wt_alt_s and the acc_wt_alt_s from the perspective of the

input residue given the (complete) arrays of NPDHBondOPs for each atom.

Used by both the NPDHBondNode and the NPDHBondBackgroundNode, and so defined in the .cc file.

C++: core::pack::interaction_graph::compute_alt_weights_for_npd_hbonds(const class core::conformation::Residue &, const class utility::vector1<class utility::vector1<class std::shared_ptr<struct core::pack::interaction_graph::NPDHBond>, class std::allocator<class std::shared_ptr<struct core::pack::interaction_graph::NPDHBond> > >, class std::allocator<class utility::vector1<class std::shared_ptr<struct core::pack::interaction_graph::NPDHBond>, class std::allocator<class std::shared_ptr<struct core::pack::interaction_graph::NPDHBond> > > > > &, class utility::vector1<double, class std::allocator<double> > &, class utility::vector1<double, class std::allocator<double> > &) –> void

class pyrosetta.rosetta.core.pack.interaction_graph.history_queue_struct

Bases: pybind11_builtins.pybind11_object

for storing three peices of associated data describing the recent history structure on a LinearMemNode.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.core.pack.interaction_graph.history_queue_struct) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).