hbonds

Bindings for core::pack::hbonds namespace

class pyrosetta.rosetta.core.pack.hbonds.BareMinimumPDEdge

Bases: PDEdge

acknowledge_state_change(self: pyrosetta.rosetta.core.pack.interaction_graph.PDEdge, node_ind: int, new_state: int, new_state_sparse_info: pyrosetta.rosetta.core.pack.interaction_graph.SparseMatrixIndex, new_energy: float) → None

C++: core::pack::interaction_graph::PDEdge::acknowledge_state_change(int, int, const class core::pack::interaction_graph::SparseMatrixIndex &, float &) –> void

acknowledge_state_zeroed(self: pyrosetta.rosetta.core.pack.interaction_graph.PDEdge, node_ind: int) → None

updates bookkeeping information when one of the two nodes enters its

“unassigned” state.

C++: core::pack::interaction_graph::PDEdge::acknowledge_state_zeroed(int) –> void

acknowledge_substitution(self: pyrosetta.rosetta.core.pack.interaction_graph.PDEdge, substituted_node_index: int, curr_state_energy: float, nodes_new_state: int, nodes_new_state_sparse_info: pyrosetta.rosetta.core.pack.interaction_graph.SparseMatrixIndex) → None

C++: core::pack::interaction_graph::PDEdge::acknowledge_substitution(int, const float, int, const class core::pack::interaction_graph::SparseMatrixIndex &) –> void

add_to_two_body_energies(self: pyrosetta.rosetta.core.pack.hbonds.BareMinimumPDEdge, res_res_energy_array: pyrosetta.rosetta.ObjexxFCL.FArray2_float_t) → None

look for hbonds and clashes

C++: core::pack::hbonds::BareMinimumPDEdge::add_to_two_body_energies(const class ObjexxFCL::FArray2<float> &) –> void

add_to_two_body_energy(self: pyrosetta.rosetta.core.pack.hbonds.BareMinimumPDEdge, : int, : int, : float) → None

look for hbonds and clashes

C++: core::pack::hbonds::BareMinimumPDEdge::add_to_two_body_energy(const int, const int, const float) –> void

clear_two_body_energy(self: pyrosetta.rosetta.core.pack.hbonds.BareMinimumPDEdge, : int, : int) → None

Does nothing in this implementation

C++: core::pack::hbonds::BareMinimumPDEdge::clear_two_body_energy(const int, const int) –> void

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

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

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

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

declare_energies_final(self: pyrosetta.rosetta.core.pack.hbonds.BareMinimumPDEdge) → None

Does nothing in this implementation

C++: core::pack::hbonds::BareMinimumPDEdge::declare_energies_final() –> void

edge_weight(self: pyrosetta.rosetta.core.pack.interaction_graph.EdgeBase) → float

C++: core::pack::interaction_graph::EdgeBase::edge_weight() const –> double

force_aa_neighbors(self: pyrosetta.rosetta.core.pack.interaction_graph.PDEdge, node1aa: int, node2aa: int) → None

C++: core::pack::interaction_graph::PDEdge::force_aa_neighbors(int, int) –> void

force_all_aa_neighbors(self: pyrosetta.rosetta.core.pack.interaction_graph.PDEdge) → None

C++: core::pack::interaction_graph::PDEdge::force_all_aa_neighbors() –> void

get_aa_submatrix_energies(self: pyrosetta.rosetta.core.pack.interaction_graph.PDEdge, node1aa: int, node2aa: int) → pyrosetta.rosetta.ObjexxFCL.FArray2D_float_t

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

static get_alternate_state_energy_first_node(first_node_alt_state: int, second_node_orig_state: int, second_node_orig_state_sparse_info: pyrosetta.rosetta.core.pack.interaction_graph.SparseMatrixIndex, first_node_state_offset_minus_1: int, second_node_curr_num_states_per_aatype: int, aa_neighbor_offset: int, edge_energy_table: pyrosetta.rosetta.ObjexxFCL.FArray1_float_t) → float

C++: core::pack::interaction_graph::PDEdge::get_alternate_state_energy_first_node(int, int, const class core::pack::interaction_graph::SparseMatrixIndex &, int, int, int, class ObjexxFCL::FArray1<float> &) –> float

static get_alternate_state_energy_second_node(first_node_orig_state: int, second_node_alt_state: int, first_node_orig_state_sparse_info: pyrosetta.rosetta.core.pack.interaction_graph.SparseMatrixIndex, second_node_alternate_state_sparse_info: pyrosetta.rosetta.core.pack.interaction_graph.SparseMatrixIndex, second_node_alt_state_num_states_per_aatype: int, aa_neighbor_offset: int, edge_energy_table: pyrosetta.rosetta.ObjexxFCL.FArray1_float_t) → float

C++: core::pack::interaction_graph::PDEdge::get_alternate_state_energy_second_node(int, int, const class core::pack::interaction_graph::SparseMatrixIndex &, const class core::pack::interaction_graph::SparseMatrixIndex &, int, int, class ObjexxFCL::FArray1<float> &) –> float

get_current_two_body_energy(self: pyrosetta.rosetta.core.pack.interaction_graph.PDEdge) → float

C++: core::pack::interaction_graph::PDEdge::get_current_two_body_energy() –> float

get_edge_table_ptr(self: pyrosetta.rosetta.core.pack.interaction_graph.PDEdge) → float

C++: core::pack::interaction_graph::PDEdge::get_edge_table_ptr() –> float &

get_first_node_ind(self: pyrosetta.rosetta.core.pack.interaction_graph.EdgeBase) → int

C++: core::pack::interaction_graph::EdgeBase::get_first_node_ind() const –> int

get_offsets_for_aatypes(self: pyrosetta.rosetta.core.pack.interaction_graph.PDEdge) → pyrosetta.rosetta.ObjexxFCL.FArray2D_int_t

Returns the array of offsets into the sparse two-body energy table

for amino-acid neighbors. Used in transferring information from edges onto nodes for cache efficiency.

C++: core::pack::interaction_graph::PDEdge::get_offsets_for_aatypes() –> const class ObjexxFCL::FArray2D<int> &

get_other_ind(self: pyrosetta.rosetta.core.pack.interaction_graph.EdgeBase, callers_index: int) → int

C++: core::pack::interaction_graph::EdgeBase::get_other_ind(int) const –> int

get_other_node(self: pyrosetta.rosetta.core.pack.interaction_graph.EdgeBase, callers_index: int) → pyrosetta.rosetta.core.pack.interaction_graph.NodeBase

C++: core::pack::interaction_graph::EdgeBase::get_other_node(int) const –> class core::pack::interaction_graph::NodeBase *

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

C++: core::pack::interaction_graph::EdgeBase::get_owner() –> class core::pack::interaction_graph::InteractionGraphBase *

get_second_node_ind(self: pyrosetta.rosetta.core.pack.interaction_graph.EdgeBase) → int

C++: core::pack::interaction_graph::EdgeBase::get_second_node_ind() const –> int

get_second_node_num_states_per_aa(self: pyrosetta.rosetta.core.pack.interaction_graph.PDEdge) → pyrosetta.rosetta.utility.vector1_int

returns an FArray of the number of states for each amino acid type for the

higher-indexed node

C++: core::pack::interaction_graph::PDEdge::get_second_node_num_states_per_aa() –> const class utility::vector1<int, class std::allocator<int> > &

get_sparse_aa_info(self: pyrosetta.rosetta.core.pack.interaction_graph.PDEdge, node1aa: int, node2aa: int) → bool

C++: core::pack::interaction_graph::PDEdge::get_sparse_aa_info(int, int) const –> bool

get_two_body_energy(self: pyrosetta.rosetta.core.pack.hbonds.BareMinimumPDEdge, : int, : int) → float

Exits if this is called.

C++: core::pack::hbonds::BareMinimumPDEdge::get_two_body_energy(const int, const int) const –> float

get_two_body_table_size(self: pyrosetta.rosetta.core.pack.interaction_graph.PDEdge) → int

C++: core::pack::interaction_graph::PDEdge::get_two_body_table_size() const –> int

marked_for_deletion(self: pyrosetta.rosetta.core.pack.interaction_graph.EdgeBase) → bool

Has this edge indicated that it can be deleted?

C++: core::pack::interaction_graph::EdgeBase::marked_for_deletion() const –> bool

prepare_for_simulated_annealing(self: pyrosetta.rosetta.core.pack.hbonds.BareMinimumPDEdge) → None

Does nothing in this implementation

C++: core::pack::hbonds::BareMinimumPDEdge::prepare_for_simulated_annealing() –> void

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

C++: core::pack::interaction_graph::EdgeBase::same_edge(int, int) const –> bool

set_edge_weight(self: pyrosetta.rosetta.core.pack.interaction_graph.PDEdge, weight: float) → None

C++: core::pack::interaction_graph::PDEdge::set_edge_weight(double) –> void

set_pos_in_node_edgevector(self: pyrosetta.rosetta.core.pack.interaction_graph.EdgeBase, callers_index: int, position: int) → None

C++: core::pack::interaction_graph::EdgeBase::set_pos_in_node_edgevector(int, int) –> void

set_sparse_aa_info(self: pyrosetta.rosetta.core.pack.interaction_graph.PDEdge, sparse_conn_info: pyrosetta.rosetta.ObjexxFCL.FArray2_bool_t) → None

C++: core::pack::interaction_graph::PDEdge::set_sparse_aa_info(const class ObjexxFCL::FArray2<bool> &) –> void

set_two_body_energy(self: pyrosetta.rosetta.core.pack.hbonds.BareMinimumPDEdge, rot1: int, rot2: int, twobody: float) → None

identical to add_to_two_body_energies()

C++: core::pack::hbonds::BareMinimumPDEdge::set_two_body_energy(const int, const int, const float) –> void

class pyrosetta.rosetta.core.pack.hbonds.HBondGraphInitializerIG

Bases: PDInteractionGraph

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

Override the InteractionGraphBase class’s implementation of this function

to return ‘true’.

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

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

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

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

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

add_longrange_twobody_energies_multithreaded(self: pyrosetta.rosetta.core.pack.interaction_graph.PrecomputedPairEnergiesInteractionGraph, nodes: Tuple[int, int], rotsets: Tuple[core::pack::rotamer_set::RotamerSet, core::pack::rotamer_set::RotamerSet], pose: pyrosetta.rosetta.core.pose.Pose, lr_energy: pyrosetta.rosetta.core.scoring.methods.LongRangeTwoBodyEnergy, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, thread_info: pyrosetta.rosetta.basic.thread_manager.RosettaThreadAssignmentInfo, finalize_edges: bool, symminfo: pyrosetta.rosetta.core.conformation.symmetry.SymmetryInfo, resids: Tuple[int, int], do_orient: bool, symmetric_swap: bool) → None

Given two nodes and a long-range energy, compute the long-range energy of all

interacting rotamers and add those energies to the edge between the nodes. This is suitable for use in a multithreaded context.

The edge must already exist. The “do_orient” and “symmetric_swap” inputs are only used in the symmetric case, and only control the generation of temporary, oriented rotamersets from rotsets.

If this is a symmetric packing case, symminfo must be provided. The resid1 and resid2 values need only be provided in the symmetric case.

Vikram K. Mulligan (vmulligan.org).

C++: core::pack::interaction_graph::PrecomputedPairEnergiesInteractionGraph::add_longrange_twobody_energies_multithreaded(const struct std::pair<unsigned long, unsigned long> &, struct std::pair<class std::shared_ptr<const class core::pack::rotamer_set::RotamerSet>, class std::shared_ptr<const class core::pack::rotamer_set::RotamerSet> >, const class core::pose::Pose &, class std::shared_ptr<const class core::scoring::methods::LongRangeTwoBodyEnergy>, const class core::scoring::ScoreFunction &, const class basic::thread_manager::RosettaThreadAssignmentInfo &, const bool, class std::shared_ptr<const class core::conformation::symmetry::SymmetryInfo>, const struct std::pair<unsigned long, unsigned long> &, const bool, const bool) –> 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: pyrosetta.rosetta.ObjexxFCL.FArray1_float_t) -> 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: pyrosetta.rosetta.ObjexxFCL.FArray1_float_t) → None

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

add_to_two_body_energies_for_edge(*args, **kwargs)

Overloaded function.

1. add_to_two_body_energies_for_edge(self: pyrosetta.rosetta.core.pack.interaction_graph.PrecomputedPairEnergiesInteractionGraph, node1: int, node2: int, res_res_energy_array: pyrosetta.rosetta.ObjexxFCL.FArray2_float_t) -> None

2. add_to_two_body_energies_for_edge(self: pyrosetta.rosetta.core.pack.interaction_graph.PrecomputedPairEnergiesInteractionGraph, node1: int, node2: int, res_res_energy_array: pyrosetta.rosetta.ObjexxFCL.FArray2_float_t, use_threadsafe_method: bool) -> None

interface for PrecomputedPairEnergiesEdge::add_to_two_body_energies

If use_threadsafe_method is true, we don’t cache the edge index for faster future lookups.

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

3. add_to_two_body_energies_for_edge(self: pyrosetta.rosetta.core.pack.interaction_graph.PrecomputedPairEnergiesInteractionGraph, node1: int, node2: int, state_node1: int, state_node2: int, two_body_energy: float) -> None

interface to PrecomputedPairEnergiesEdge::add_to_two_body_energies

C++: core::pack::interaction_graph::PrecomputedPairEnergiesInteractionGraph::add_to_two_body_energies_for_edge(int, int, int, int, const 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.PDInteractionGraph) → None

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

clean_up_after_packing(self: pyrosetta.rosetta.core.pack.interaction_graph.AnnealableGraphBase, pose: pyrosetta.rosetta.core.pose.Pose) → None

Provide the opportunity for an AnnealableGraph to clean up cached data in the pose or inside itself after packing.

Base class function does nothing; may be overridden in derived classes.

Vikram K. Mulligan (vmullig.edu).

C++: core::pack::interaction_graph::AnnealableGraphBase::clean_up_after_packing(class core::pose::Pose &) –> void

clear_two_body_energy_for_edge(self: pyrosetta.rosetta.core.pack.interaction_graph.PrecomputedPairEnergiesInteractionGraph, node1: int, node2: int, state_node1: int, state_node2: int) → None

interface to PDEdge::clear_two_body_energy

C++: core::pack::interaction_graph::PrecomputedPairEnergiesInteractionGraph::clear_two_body_energy_for_edge(int, int, int, int) –> void

commit_considered_substitution(*args, **kwargs)

Overloaded function.

1. commit_considered_substitution(self: pyrosetta.rosetta.core.pack.interaction_graph.PDInteractionGraph) -> float

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

2. commit_considered_substitution(self: pyrosetta.rosetta.core.pack.interaction_graph.PDInteractionGraph, weights: pyrosetta.rosetta.ObjexxFCL.FArray2D_float_t) -> float

C++: core::pack::interaction_graph::PDInteractionGraph::commit_considered_substitution(const class ObjexxFCL::FArray2D<float> &) –> float

consider_substitution(*args, **kwargs)

Overloaded function.

1. consider_substitution(self: pyrosetta.rosetta.core.pack.interaction_graph.PDInteractionGraph, node_ind: int, new_state: int, delta_energy: float, prev_energy_for_node: float) -> None

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

2. consider_substitution(self: pyrosetta.rosetta.core.pack.interaction_graph.PDInteractionGraph, node_ind: int, new_state: int, deltaE_unweighted: float, prevE_unweighted: float, deltaE_weighted: float, prevE_weighted: float, weights: pyrosetta.rosetta.ObjexxFCL.FArray2D_float_t) -> None

C++: core::pack::interaction_graph::PDInteractionGraph::consider_substitution(int, int, float &, float &, float &, float &, const class ObjexxFCL::FArray2D<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.PDInteractionGraph) → int

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

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

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

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

C++: core::pack::hbonds::HBondGraphInitializerIG::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 *

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

Iterates over all edges and calls declare_energies_final() on

all of them. Takes O(N) time, where N is the number of edges.

Vikram K. Mulligan (vmulligan.org).

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

declare_edge_energies_final(*args, **kwargs)

Overloaded function.

1. declare_edge_energies_final(self: pyrosetta.rosetta.core.pack.interaction_graph.PrecomputedPairEnergiesInteractionGraph, node1: int, node2: int) -> None

2. declare_edge_energies_final(self: pyrosetta.rosetta.core.pack.interaction_graph.PrecomputedPairEnergiesInteractionGraph, node1: int, node2: int, use_threadsafe_lookup: bool) -> None

call this if you’re done storing energies in an edge - it will reduce

the memory usage for that edge if possible

• [in] - the index of the smaller-indexed node

• [in] - the index of the larger-indexed node

• [in] - If true, we don’t cache the last edge

found for faster future lookups. False by default.

C++: core::pack::interaction_graph::PrecomputedPairEnergiesInteractionGraph::declare_edge_energies_final(int, int, const 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

eval_rot_pair(self: pyrosetta.rosetta.core.pack.hbonds.HBondGraphInitializerIG, global_rot1: int, global_rot2: int, two_body_energy: float) → None

look for hbonds and clashes

C++: core::pack::hbonds::HBondGraphInitializerIG::eval_rot_pair(const unsigned int, const unsigned int, const float) –> void

finalize_hbond_graph(self: pyrosetta.rosetta.core.pack.hbonds.HBondGraphInitializerIG) → None

C++: core::pack::hbonds::HBondGraphInitializerIG::finalize_hbond_graph() –> void

find_edge(*args, **kwargs)

Overloaded function.

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

2. find_edge(self: pyrosetta.rosetta.core.pack.interaction_graph.InteractionGraphBase, node1: int, node2: int, use_threadsafe_lookup: bool) -> pyrosetta.rosetta.core.pack.interaction_graph.EdgeBase

Find an edge and return a nonconst pointer to it.

By default, the last edge accessed is cached, for faster lookups. If use_threadsafe_lookup is true, we avoid the caching.

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

find_symmetric_hbonds(self: pyrosetta.rosetta.core.pack.hbonds.HBondGraphInitializerIG, symm_info: pyrosetta.rosetta.core.conformation.symmetry.SymmetryInfo, pose: pyrosetta.rosetta.core.pose.Pose, hb_threshold: float) → None

only twobody energies will get turned into edges. If you are running with symmetry, you need to call this to find edges between resids and their symmetric twins. Must be called after scoring.

C++: core::pack::hbonds::HBondGraphInitializerIG::find_symmetric_hbonds(const class core::conformation::symmetry::SymmetryInfo &, const class core::pose::Pose &, double) –> void

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.PDInteractionGraph, node1: int, node2: int, node1aa: int, node2aa: int) → pyrosetta.rosetta.ObjexxFCL.FArray2D_float_t

C++: core::pack::interaction_graph::PDInteractionGraph::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) const –> bool

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

older scheme for memory accounting – replace this asap

returns the number of floats used in all edge two-body energy tables

C++: core::pack::interaction_graph::PDInteractionGraph::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.PDInteractionGraph) → float

@ brief O(1) total energy report. Protected read access for derived classes.

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

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

a user may define subsets of the vertex set for which they would like to

know the internal energy sum.

C++: core::pack::interaction_graph::PDInteractionGraph::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.PDInteractionGraph) → int

C++: core::pack::interaction_graph::PDInteractionGraph::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_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.PDInteractionGraph, node: int, state: int) → float

C++: core::pack::interaction_graph::PDInteractionGraph::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.hbonds.HBondGraphInitializerIG, : int, : int, : int, : int) → float

Exits if this is called.

C++: core::pack::hbonds::HBondGraphInitializerIG::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

get_weighted_energy(self: pyrosetta.rosetta.core.pack.interaction_graph.PDInteractionGraph, weights: pyrosetta.rosetta.ObjexxFCL.FArray2D_float_t) → float

C++: core::pack::interaction_graph::PDInteractionGraph::get_weighted_energy(const class ObjexxFCL::FArray2D<float> &) const –> float

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.PDInteractionGraph, rot_sets: pyrosetta.rosetta.core.pack_basic.RotamerSetsBase) → None

C++: core::pack::interaction_graph::PDInteractionGraph::initialize(const class core::pack_basic::RotamerSetsBase &) –> 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(std::ostream &) 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(std::ostream &) const –> void

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

iterate across edges and nodes and allow them to prepare

for simulated annealing

C++: core::pack::interaction_graph::InteractionGraphBase::prepare_graph_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.PDInteractionGraph) → None

outputs the current state for each node, useful for debugging

C++: core::pack::interaction_graph::PDInteractionGraph::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

rotamer_sets(self: pyrosetta.rosetta.core.pack.hbonds.HBondGraphInitializerIG) → pyrosetta.rosetta.core.pack.rotamer_set.RotamerSets

C++: core::pack::hbonds::HBondGraphInitializerIG::rotamer_sets() –> class std::shared_ptr<const class core::pack::rotamer_set::RotamerSets>

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.PDInteractionGraph, : float) → None

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

set_network_state(*args, **kwargs)

Overloaded function.

1. set_network_state(self: pyrosetta.rosetta.core.pack.interaction_graph.PDInteractionGraph, node_states: pyrosetta.rosetta.ObjexxFCL.FArray1_int_t) -> float

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

2. set_network_state(self: pyrosetta.rosetta.core.pack.interaction_graph.PDInteractionGraph, node_states: pyrosetta.rosetta.ObjexxFCL.FArray1_int_t, weights: pyrosetta.rosetta.ObjexxFCL.FArray2D_float_t) -> float

C++: core::pack::interaction_graph::PDInteractionGraph::set_network_state(class ObjexxFCL::FArray1<int> &, const class ObjexxFCL::FArray2D<float> &) –> 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_onebody_energies_multithreaded(self: pyrosetta.rosetta.core.pack.interaction_graph.InteractionGraphBase, node_index: int, rotset: core::pack::rotamer_set::RotamerSet, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, task: pyrosetta.rosetta.core.pack.task.PackerTask, packer_neighbor_graph: pyrosetta.rosetta.utility.graph.Graph, thread_assignments: pyrosetta.rosetta.basic.thread_manager.RosettaThreadAssignmentInfo) → None

Compute and store the onebody energy for all rotamers at a position. Safe for

a multithreaded context.

Requires that the number of states was already set.

Vikram K. Mulligan (vmulligan.org).

C++: core::pack::interaction_graph::InteractionGraphBase::set_onebody_energies_multithreaded(const unsigned long, class std::shared_ptr<const class core::pack::rotamer_set::RotamerSet>, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, const class core::pack::task::PackerTask &, class std::shared_ptr<const class utility::graph::Graph>, const class basic::thread_manager::RosettaThreadAssignmentInfo &) –> void

set_sparse_aa_info_for_edge(self: pyrosetta.rosetta.core.pack.interaction_graph.FixedBBInteractionGraph, node1: int, node2: int, sparse_conn_info: pyrosetta.rosetta.ObjexxFCL.FArray2_bool_t) → None

interface to PDEdge::set_sparse_aa_info

C++: core::pack::interaction_graph::FixedBBInteractionGraph::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.PDInteractionGraph, node_ind: int, new_state: int) → float

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

set_two_body_energy_for_edge(self: pyrosetta.rosetta.core.pack.interaction_graph.PrecomputedPairEnergiesInteractionGraph, node1: int, node2: int, state_node1: int, state_node2: int, two_body_energy: float) → None

interface to PDEdge::set_two_body_energy

C++: core::pack::interaction_graph::PrecomputedPairEnergiesInteractionGraph::set_two_body_energy_for_edge(int, int, int, int, const float) –> void

set_twobody_energies_multithreaded(self: pyrosetta.rosetta.core.pack.interaction_graph.PrecomputedPairEnergiesInteractionGraph, nodes: Tuple[int, int], rotsets: Tuple[core::pack::rotamer_set::RotamerSet, core::pack::rotamer_set::RotamerSet], pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, thread_info: pyrosetta.rosetta.basic.thread_manager.RosettaThreadAssignmentInfo, finalize_edges: bool, symminfo: pyrosetta.rosetta.core.conformation.symmetry.SymmetryInfo, resids: Tuple[int, int], do_orient: bool, symmetric_swap: bool) → None

Given two nodes, compute the energy of all interacting rotamers and add those

energies to the edge between the nodes. This is suitable for use in a multithreaded context.

The edge must already exist. The “do_orient” and “symmetric_swap” inputs are only used in the symmetric case, and only control the generation of temporary, oriented rotamersets from rotsets.

If this is a symmetric packing case, symminfo must be provided. The resid1 and resid2 values need only be provided in the symmetric case.

Vikram K. Mulligan (vmulligan.org).

C++: core::pack::interaction_graph::PrecomputedPairEnergiesInteractionGraph::set_twobody_energies_multithreaded(const struct std::pair<unsigned long, unsigned long> &, struct std::pair<class std::shared_ptr<const class core::pack::rotamer_set::RotamerSet>, class std::shared_ptr<const class core::pack::rotamer_set::RotamerSet> >, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, const class basic::thread_manager::RosettaThreadAssignmentInfo &, const bool, class std::shared_ptr<const class core::conformation::symmetry::SymmetryInfo>, const struct std::pair<unsigned long, unsigned long> &, const bool, const bool) –> void

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: pyrosetta.rosetta.ObjexxFCL.FArray1_float_t, new_energy1b: pyrosetta.rosetta.ObjexxFCL.FArray1_float_t) → 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

pyrosetta.rosetta.core.pack.hbonds.create_and_init_hbond_graph(rotamer_sets: pyrosetta.rosetta.core.pack.rotamer_set.RotamerSets) → pyrosetta.rosetta.core.scoring.hbonds.graph.HBondGraph

This combines the HBondGraph constructor and init_node_info(). The HBondGraph constructor can not take core.4 objects because it is in core.3 (as of the time this was written).

C++: core::pack::hbonds::create_and_init_hbond_graph(const class core::pack::rotamer_set::RotamerSets &) –> class std::shared_ptr<class core::scoring::hbonds::graph::HBondGraph>

pyrosetta.rosetta.core.pack.hbonds.create_init_and_create_edges_for_hbond_graph(*args, **kwargs)

Overloaded function.

1. create_init_and_create_edges_for_hbond_graph(rotamer_sets: pyrosetta.rosetta.core.pack.rotamer_set.RotamerSets, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose, hydrogen_bond_threshold: float, clash_threshold: float) -> pyrosetta.rosetta.core.scoring.hbonds.graph.HBondGraph

2. create_init_and_create_edges_for_hbond_graph(rotamer_sets: pyrosetta.rosetta.core.pack.rotamer_set.RotamerSets, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose, hydrogen_bond_threshold: float, clash_threshold: float, hbond_energy_threshold_for_satisfaction: float) -> pyrosetta.rosetta.core.scoring.hbonds.graph.HBondGraph

3. create_init_and_create_edges_for_hbond_graph(rotamer_sets: pyrosetta.rosetta.core.pack.rotamer_set.RotamerSets, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose, hydrogen_bond_threshold: float, clash_threshold: float, hbond_energy_threshold_for_satisfaction: float, include_backbone_at_atom_level: bool) -> pyrosetta.rosetta.core.scoring.hbonds.graph.HBondGraph

Construct atom level hbond graph, initialize the node information, score rotamers to create hbonds. This will not work perfectly if you are using symmetry because it does not score one-body interactions, but can still provide a good template

C++: core::pack::hbonds::create_init_and_create_edges_for_hbond_graph(class std::shared_ptr<class core::pack::rotamer_set::RotamerSets>, const class core::scoring::ScoreFunction &, const class core::pose::Pose &, double, double, double, bool) –> class std::shared_ptr<class core::scoring::hbonds::graph::HBondGraph>

pyrosetta.rosetta.core.pack.hbonds.delete_edges_with_degree_zero(hb_graph: pyrosetta.rosetta.core.scoring.hbonds.graph.HBondGraph) → None

If you only care about hbond networks, then you might not care about edges that have no incident edges. This function deletes those edges.

C++: core::pack::hbonds::delete_edges_with_degree_zero(class core::scoring::hbonds::graph::HBondGraph &) –> void

pyrosetta.rosetta.core.pack.hbonds.determine_atom_level_edge_info(*args, **kwargs)

Overloaded function.

1. determine_atom_level_edge_info(hb_edge: pyrosetta.rosetta.core.scoring.hbonds.graph.HBondEdge, rotamer_sets: pyrosetta.rosetta.core.pack.rotamer_set.RotamerSets, database: pyrosetta.rosetta.core.scoring.hbonds.HBondDatabase, tenA_neighbor_graph: pyrosetta.rosetta.utility.graph.Graph, pose: pyrosetta.rosetta.core.pose.Pose) -> None

2. determine_atom_level_edge_info(hb_edge: pyrosetta.rosetta.core.scoring.hbonds.graph.HBondEdge, rotamer_sets: pyrosetta.rosetta.core.pack.rotamer_set.RotamerSets, database: pyrosetta.rosetta.core.scoring.hbonds.HBondDatabase, tenA_neighbor_graph: pyrosetta.rosetta.utility.graph.Graph, pose: pyrosetta.rosetta.core.pose.Pose, hbond_energy_threshold_for_satisfaction: float) -> None

3. determine_atom_level_edge_info(hb_edge: pyrosetta.rosetta.core.scoring.hbonds.graph.HBondEdge, rotamer_sets: pyrosetta.rosetta.core.pack.rotamer_set.RotamerSets, database: pyrosetta.rosetta.core.scoring.hbonds.HBondDatabase, tenA_neighbor_graph: pyrosetta.rosetta.utility.graph.Graph, pose: pyrosetta.rosetta.core.pose.Pose, hbond_energy_threshold_for_satisfaction: float, symm_info: pyrosetta.rosetta.core.conformation.symmetry.SymmetryInfo) -> None

Add information regarding the atoms participating in hbonds (see find_hbonds_in_residue_pair() ). symm_info needs to be != 0 if and only if you want to evaluate symmetry.

C++: core::pack::hbonds::determine_atom_level_edge_info(class core::scoring::hbonds::graph::HBondEdge &, const class core::pack::rotamer_set::RotamerSets &, const class core::scoring::hbonds::HBondDatabase &, const class utility::graph::Graph &, const class core::pose::Pose &, double, class std::shared_ptr<const class core::conformation::symmetry::SymmetryInfo>) –> void

pyrosetta.rosetta.core.pack.hbonds.determine_atom_level_edge_info_for_all_edges(*args, **kwargs)

Overloaded function.

1. determine_atom_level_edge_info_for_all_edges(hb_graph: pyrosetta.rosetta.core.scoring.hbonds.graph.HBondGraph, rotamer_sets: pyrosetta.rosetta.core.pack.rotamer_set.RotamerSets, database: pyrosetta.rosetta.core.scoring.hbonds.HBondDatabase, tenA_neighbor_graph: pyrosetta.rosetta.utility.graph.Graph, pose: pyrosetta.rosetta.core.pose.Pose) -> None

2. determine_atom_level_edge_info_for_all_edges(hb_graph: pyrosetta.rosetta.core.scoring.hbonds.graph.HBondGraph, rotamer_sets: pyrosetta.rosetta.core.pack.rotamer_set.RotamerSets, database: pyrosetta.rosetta.core.scoring.hbonds.HBondDatabase, tenA_neighbor_graph: pyrosetta.rosetta.utility.graph.Graph, pose: pyrosetta.rosetta.core.pose.Pose, skip_edges_with_degree_zero: bool) -> None

3. determine_atom_level_edge_info_for_all_edges(hb_graph: pyrosetta.rosetta.core.scoring.hbonds.graph.HBondGraph, rotamer_sets: pyrosetta.rosetta.core.pack.rotamer_set.RotamerSets, database: pyrosetta.rosetta.core.scoring.hbonds.HBondDatabase, tenA_neighbor_graph: pyrosetta.rosetta.utility.graph.Graph, pose: pyrosetta.rosetta.core.pose.Pose, skip_edges_with_degree_zero: bool, hbond_energy_threshold_for_satisfaction: float) -> None

4. determine_atom_level_edge_info_for_all_edges(hb_graph: pyrosetta.rosetta.core.scoring.hbonds.graph.HBondGraph, rotamer_sets: pyrosetta.rosetta.core.pack.rotamer_set.RotamerSets, database: pyrosetta.rosetta.core.scoring.hbonds.HBondDatabase, tenA_neighbor_graph: pyrosetta.rosetta.utility.graph.Graph, pose: pyrosetta.rosetta.core.pose.Pose, skip_edges_with_degree_zero: bool, hbond_energy_threshold_for_satisfaction: float, symm_info: pyrosetta.rosetta.core.conformation.symmetry.SymmetryInfo) -> None

Iterate through edges and calls determine_atom_level_edge_info(). skip_edges_with_degree_zero does not evaluate edges that have no incident edges and can not be part of a hydrogen bond network. symm_info needs to be != 0 if and only if you want to evaluate symmetry.

C++: core::pack::hbonds::determine_atom_level_edge_info_for_all_edges(class core::scoring::hbonds::graph::HBondGraph &, const class core::pack::rotamer_set::RotamerSets &, const class core::scoring::hbonds::HBondDatabase &, const class utility::graph::Graph &, const class core::pose::Pose &, bool, double, class std::shared_ptr<const class core::conformation::symmetry::SymmetryInfo>) –> void

pyrosetta.rosetta.core.pack.hbonds.determine_atom_level_node_info(*args, **kwargs)

Overloaded function.

1. determine_atom_level_node_info(node: pyrosetta.rosetta.core.scoring.hbonds.graph.HBondNode, rotamer_sets: pyrosetta.rosetta.core.pack.rotamer_set.RotamerSets, include_these_resids: pyrosetta.rosetta.utility.vector1_bool) -> None

2. determine_atom_level_node_info(node: pyrosetta.rosetta.core.scoring.hbonds.graph.HBondNode, rotamer_sets: pyrosetta.rosetta.core.pack.rotamer_set.RotamerSets, include_these_resids: pyrosetta.rosetta.utility.vector1_bool, include_backbone: bool) -> None

Store atom information for every node with a corresponding resid set to true in include_these_resids. include_these_resids was originally meant to protray “resid_is_buried” so that we only store atom info for buried residues. I don’t care what you use this for so I gave it a more generalized name.

C++: core::pack::hbonds::determine_atom_level_node_info(class core::scoring::hbonds::graph::HBondNode &, const class core::pack::rotamer_set::RotamerSets &, const class utility::vector1<bool, class std::allocator<bool> > &, bool) –> void

pyrosetta.rosetta.core.pack.hbonds.determine_atom_level_node_info_for_all_nodes(*args, **kwargs)

Overloaded function.

1. determine_atom_level_node_info_for_all_nodes(hb_graph: pyrosetta.rosetta.core.scoring.hbonds.graph.HBondGraph, rotamer_sets: pyrosetta.rosetta.core.pack.rotamer_set.RotamerSets, include_these_resids: pyrosetta.rosetta.utility.vector1_bool) -> None

2. determine_atom_level_node_info_for_all_nodes(hb_graph: pyrosetta.rosetta.core.scoring.hbonds.graph.HBondGraph, rotamer_sets: pyrosetta.rosetta.core.pack.rotamer_set.RotamerSets, include_these_resids: pyrosetta.rosetta.utility.vector1_bool, skip_nodes_with_no_edges: bool) -> None

3. determine_atom_level_node_info_for_all_nodes(hb_graph: pyrosetta.rosetta.core.scoring.hbonds.graph.HBondGraph, rotamer_sets: pyrosetta.rosetta.core.pack.rotamer_set.RotamerSets, include_these_resids: pyrosetta.rosetta.utility.vector1_bool, skip_nodes_with_no_edges: bool, include_backbone: bool) -> None

Calls determine_atom_level_node_info() for all nodes. skip_nodes_with_no_edges is recommended to be set to true but depends on your protocol. The default is false for safety purposes.

C++: core::pack::hbonds::determine_atom_level_node_info_for_all_nodes(class core::scoring::hbonds::graph::HBondGraph &, const class core::pack::rotamer_set::RotamerSets &, const class utility::vector1<bool, class std::allocator<bool> > &, bool, bool) –> void

pyrosetta.rosetta.core.pack.hbonds.find_hbonds_in_residue_pair(resA: pyrosetta.rosetta.core.conformation.Residue, resB: pyrosetta.rosetta.core.conformation.Residue, database: pyrosetta.rosetta.core.scoring.hbonds.HBondDatabase, tenA_neighbor_graph: pyrosetta.rosetta.utility.graph.Graph, set: core::scoring::hbonds::HBondSet) → None

Utility function used by other functions in this file. Given that an edge exists between two nodes, find all of the hbonds between those two residues. It does not matter which order resA and resB are. Output hbonds are put in the HBondSet provided. This should not be called before the graph is populated with edges (see HBondGraphInitializerIG) - nothing will crash if this is called with no edges but it just does not make sense.

C++: core::pack::hbonds::find_hbonds_in_residue_pair(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::scoring::hbonds::HBondDatabase &, const class utility::graph::Graph &, class core::scoring::hbonds::HBondSet &) –> void

pyrosetta.rosetta.core.pack.hbonds.find_satisfying_interactions_with_background(*args, **kwargs)

Overloaded function.

1. find_satisfying_interactions_with_background(node: pyrosetta.rosetta.core.scoring.hbonds.graph.HBondNode, rotamer_sets: pyrosetta.rosetta.core.pack.rotamer_set.RotamerSets, packer_neighbor_graph: pyrosetta.rosetta.utility.graph.Graph, poly_ala_pose: pyrosetta.rosetta.core.pose.Pose) -> None

2. find_satisfying_interactions_with_background(node: pyrosetta.rosetta.core.scoring.hbonds.graph.HBondNode, rotamer_sets: pyrosetta.rosetta.core.pack.rotamer_set.RotamerSets, packer_neighbor_graph: pyrosetta.rosetta.utility.graph.Graph, poly_ala_pose: pyrosetta.rosetta.core.pose.Pose, hbond_energy_threshold_for_satisfaction: float) -> None

CALL determine_atom_level_node_info() OR determine_atom_level_node_info_for_all_nodes() BEFORE CALLING THIS! After adding atom info to nodes, calling this function will result in removing atom info for atoms that hydrogen bond with the backbone or fixed sidechains.

C++: core::pack::hbonds::find_satisfying_interactions_with_background(class core::scoring::hbonds::graph::HBondNode &, const class core::pack::rotamer_set::RotamerSets &, const class utility::graph::Graph &, const class core::pose::Pose &, double) –> void

pyrosetta.rosetta.core.pack.hbonds.hbond_graph_from_partial_rotsets(*args, **kwargs)

Overloaded function.

1. hbond_graph_from_partial_rotsets(pose_in: pyrosetta.rosetta.core.pose.Pose, original_rotsets: pyrosetta.rosetta.core.pack.rotamer_set.RotamerSets, scorefxn_sc: pyrosetta.rosetta.core.scoring.ScoreFunction, scorefxn_bb: pyrosetta.rosetta.core.scoring.ScoreFunction, complete_rotsets_out: pyrosetta.rosetta.core.pack.rotamer_set.RotamerSets, position_had_rotset: pyrosetta.rosetta.utility.vector1_bool) -> pyrosetta.rosetta.core.scoring.hbonds.graph.HBondGraph

2. hbond_graph_from_partial_rotsets(pose_in: pyrosetta.rosetta.core.pose.Pose, original_rotsets: pyrosetta.rosetta.core.pack.rotamer_set.RotamerSets, scorefxn_sc: pyrosetta.rosetta.core.scoring.ScoreFunction, scorefxn_bb: pyrosetta.rosetta.core.scoring.ScoreFunction, complete_rotsets_out: pyrosetta.rosetta.core.pack.rotamer_set.RotamerSets, position_had_rotset: pyrosetta.rosetta.utility.vector1_bool, minimum_hb_cut: float) -> pyrosetta.rosetta.core.scoring.hbonds.graph.HBondGraph

Construct an HBondGraph from a partial rotsets (like you might see during packing)

BB-BB hbonds are only included for the first residue. This means that prolines are not

handled correctly. If proline is the first resdiue at a position and other residues are being packed at that position, any hbonds to the other Ns will not be reported.

If one wishes to have BB-BB hbonds for all pairs, enable all 4 hbond terms for scorefxn_sc and leave scorefxn_bb as a nullptr (or a blank scorefxn)

C++: core::pack::hbonds::hbond_graph_from_partial_rotsets(const class core::pose::Pose &, const class core::pack::rotamer_set::RotamerSets &, const class std::shared_ptr<class core::scoring::ScoreFunction> &, const class std::shared_ptr<class core::scoring::ScoreFunction> &, class std::shared_ptr<class core::pack::rotamer_set::RotamerSets> &, class utility::vector1<bool, class std::allocator<bool> > &, float) –> class std::shared_ptr<class core::scoring::hbonds::graph::HBondGraph>

pyrosetta.rosetta.core.pack.hbonds.init_node_info(graph: pyrosetta.rosetta.core.scoring.hbonds.graph.HBondGraph, rotamer_sets: pyrosetta.rosetta.core.pack.rotamer_set.RotamerSets) → None

This should be called immediately after creating the graph (and setting the number of nodes if need-be). This adds rotamer_sets info to the nodes for easier lookup later. Technically optional but recommended

C++: core::pack::hbonds::init_node_info(class core::scoring::hbonds::graph::HBondGraph &, const class core::pack::rotamer_set::RotamerSets &) –> void