From 766f76c564a51c8f0eb34def32592217a156a9f0 Mon Sep 17 00:00:00 2001
From: Gabriel Studer <gabriel.studer@unibas.ch>
Date: Sun, 28 Aug 2016 16:33:45 +0200
Subject: [PATCH] Rename Graph in sidechain module to RotamerGraph to avoid
confusion
---
doc/tests/scripts/sidechain_steps.py | 2 +-
sidechain/doc/graph.rst | 10 +-
sidechain/doc/index.rst | 2 +-
sidechain/pymod/_reconstruct_sidechains.py | 4 +-
sidechain/pymod/export_graph.cc | 30 +--
sidechain/src/graph.cc | 208 ++++++++++++---------
sidechain/src/graph.hh | 77 ++++----
sidechain/src/tree.cc | 18 +-
sidechain/src/tree.hh | 6 +-
9 files changed, 198 insertions(+), 159 deletions(-)
diff --git a/doc/tests/scripts/sidechain_steps.py b/doc/tests/scripts/sidechain_steps.py
index 34f0bef2..67d890d6 100644
--- a/doc/tests/scripts/sidechain_steps.py
+++ b/doc/tests/scripts/sidechain_steps.py
@@ -66,7 +66,7 @@ for i,r in enumerate(prot.residues):
# buildup a graph given the rotamer groups
-graph = sidechain.Graph.CreateFromFRMList(rotamer_groups)
+graph = sidechain.RotamerGraph.CreateFromFRMList(rotamer_groups)
# and get a solution out of it
solution = graph.Solve()
diff --git a/sidechain/doc/graph.rst b/sidechain/doc/graph.rst
index f7d48023..e4228af5 100644
--- a/sidechain/doc/graph.rst
+++ b/sidechain/doc/graph.rst
@@ -12,10 +12,10 @@ decomposition and dead end elimination, decomposes the graph in a tree form
and finally comes back with a solution.
-The Interaction Graph
+The Rotamer Graph
--------------------------------------------------------------------------------
-.. class:: Graph
+.. class:: RotamerGraph
The Graph object has no constructor exported to python. It is meant to be
constructed using the static create functions.
@@ -40,9 +40,9 @@ The Interaction Graph
.. method:: Solve([max_complexity=inf, initial_epsilon=0.02])
- The method solves a graph by iteratively performing dead end elimination
- and edge decomposition until the number of possible permutations, that
- have to be enumerated in the resulting tree, fall below
+ The method solves a rotamer graph by iteratively performing dead end
+ elimination and edge decomposition until the number of possible
+ permutations, that have to be enumerated in the resulting tree, fall below
**max_complecity**. In every iteration the epsilon value gets doubled to
enforce more edges to be approximated by edge decomposition. This function
assumes all self energies of the rotamers to be calculated and properly set!
diff --git a/sidechain/doc/index.rst b/sidechain/doc/index.rst
index 98c570f3..e8528c16 100644
--- a/sidechain/doc/index.rst
+++ b/sidechain/doc/index.rst
@@ -44,7 +44,7 @@ Contents:
Rotamers <rotamer>
Frame <frame>
Rotamer Library <rotamer_lib>
- Graph <graph>
+ RotamerGraph <graph>
The Settings - Control Things... <sidechain_settings>
Disulfid Bond Evaluation <disulfid>
Loading Libraries <loading>
diff --git a/sidechain/pymod/_reconstruct_sidechains.py b/sidechain/pymod/_reconstruct_sidechains.py
index 589b00e7..145c6067 100644
--- a/sidechain/pymod/_reconstruct_sidechains.py
+++ b/sidechain/pymod/_reconstruct_sidechains.py
@@ -496,9 +496,9 @@ def Reconstruct(ent, keep_sidechains=False, build_disulfids=True,
# set up graph and solve to get best rotamers
if use_frm:
- graph = sidechain.Graph.CreateFromFRMList(rotamer_groups)
+ graph = sidechain.RotamerGraph.CreateFromFRMList(rotamer_groups)
else:
- graph = sidechain.Graph.CreateFromRRMList(rotamer_groups)
+ graph = sidechain.RotamerGraph.CreateFromRRMList(rotamer_groups)
solution = graph.Solve(100000000,0.02)
diff --git a/sidechain/pymod/export_graph.cc b/sidechain/pymod/export_graph.cc
index 37c0201b..87f647da 100644
--- a/sidechain/pymod/export_graph.cc
+++ b/sidechain/pymod/export_graph.cc
@@ -9,25 +9,25 @@ using namespace promod3;
namespace {
-GraphPtr WrapRRMList(boost::python::list& rotamer_groups,
- boost::python::list& rt_operators) {
+RotamerGraphPtr WrapRRMList(boost::python::list& rotamer_groups,
+ boost::python::list& rt_operators) {
std::vector<RRMRotamerGroupPtr> v_rotamer_groups;
std::vector<geom::Transform> v_rt_operators;
core::ConvertListToVector(rotamer_groups, v_rotamer_groups);
core::ConvertListToVector(rt_operators, v_rt_operators);
- return Graph::CreateFromRRMList(v_rotamer_groups,v_rt_operators);
+ return RotamerGraph::CreateFromRRMList(v_rotamer_groups,v_rt_operators);
}
-GraphPtr WrapFRMList(boost::python::list& rotamer_groups,
- boost::python::list& rt_operators) {
+RotamerGraphPtr WrapFRMList(boost::python::list& rotamer_groups,
+ boost::python::list& rt_operators) {
std::vector<FRMRotamerGroupPtr> v_rotamer_groups;
std::vector<geom::Transform> v_rt_operators;
core::ConvertListToVector(rotamer_groups, v_rotamer_groups);
core::ConvertListToVector(rt_operators, v_rt_operators);
- return Graph::CreateFromFRMList(v_rotamer_groups,v_rt_operators);
+ return RotamerGraph::CreateFromFRMList(v_rotamer_groups,v_rt_operators);
}
-boost::python::list WrapSolve(GraphPtr graph, uint64_t max_complexity,
+boost::python::list WrapSolve(RotamerGraphPtr graph, uint64_t max_complexity,
Real initial_epsilon) {
std::vector<int> solution = graph->Solve(max_complexity,initial_epsilon);
boost::python::list return_list;
@@ -40,19 +40,19 @@ boost::python::list WrapSolve(GraphPtr graph, uint64_t max_complexity,
void export_Graph()
{
- class_<Graph,boost::noncopyable>("Graph", no_init)
+ class_<RotamerGraph,boost::noncopyable>("RotamerGraph", no_init)
.def("CreateFromRRMList",&WrapRRMList,(arg("rotamer_groups"),
arg("rt_operators")=boost::python::list())).staticmethod("CreateFromRRMList")
.def("CreateFromFRMList",&WrapFRMList,(arg("rotamer_groups"),
arg("rt_operators")=boost::python::list())).staticmethod("CreateFromFRMList")
- .def("Prune",&Graph::Prune,(arg("epsilon"),arg("consider_all_nodes")=false))
- .def("Reset", &Graph::Reset)
- .def("GetNumNodes", &Graph::GetNumNodes)
- .def("GetNumEdges", &Graph::GetNumEdges)
- .def("GetNumActiveNodes", &Graph::GetNumActiveNodes)
- .def("GetNumActiveEdges", &Graph::GetNumActiveEdges)
+ .def("Prune",&RotamerGraph::Prune,(arg("epsilon"),arg("consider_all_nodes")=false))
+ .def("Reset", &RotamerGraph::Reset)
+ .def("GetNumNodes", &RotamerGraph::GetNumNodes)
+ .def("GetNumEdges", &RotamerGraph::GetNumEdges)
+ .def("GetNumActiveNodes", &RotamerGraph::GetNumActiveNodes)
+ .def("GetNumActiveEdges", &RotamerGraph::GetNumActiveEdges)
.def("Solve",&WrapSolve,(arg("max_complexity")=std::numeric_limits<uint64_t>::max(),arg("initial_epsilon")=0.02))
;
- register_ptr_to_python<GraphPtr>();
+ register_ptr_to_python<RotamerGraphPtr>();
}
diff --git a/sidechain/src/graph.cc b/sidechain/src/graph.cc
index ddc2ab4d..d70e7561 100644
--- a/sidechain/src/graph.cc
+++ b/sidechain/src/graph.cc
@@ -12,31 +12,36 @@ namespace{
namespace promod3{ namespace sidechain{
-Edge::Edge(uint index, Node* node1, Node* node2, uint num_i, uint num_j,
- Real* pairwise_energies): index_(index),
- active_(true),
- node1_(node1), node2_(node2),
- maxi_(num_i), maxj_(num_j),
- pairwise_energies_(pairwise_energies){
+RotamerGraphEdge::RotamerGraphEdge(uint index,
+ RotamerGraphNode* node1,
+ RotamerGraphNode* node2,
+ uint num_i, uint num_j,
+ Real* pairwise_energies): index_(index),
+ active_(true),
+ node1_(node1),
+ node2_(node2),
+ maxi_(num_i),
+ maxj_(num_j),
+ pairwise_energies_(pairwise_energies){
}
-Edge::~Edge(){
+RotamerGraphEdge::~RotamerGraphEdge(){
delete [] pairwise_energies_;
//Nodes don't get deleted here!
//It is assumed, that this happens in the graph object
}
-void Edge::Reset(){
+void RotamerGraphEdge::Reset(){
active_ = true;
}
-void Edge::Deactivate(){
+void RotamerGraphEdge::Deactivate(){
if(!active_) return;
active_ = false;
}
-bool Edge::Decompose(Real thresh){
+bool RotamerGraphEdge::Decompose(Real thresh){
if(!active_) return false;
@@ -46,10 +51,10 @@ bool Edge::Decompose(Real thresh){
uint n_total = node2_->GetNumRotamers();
int temp;
- for(Node::iterator i = node1_->active_rotamers_begin();
+ for(RotamerGraphNode::iterator i = node1_->active_rotamers_begin();
i != node1_->active_rotamers_end(); ++i){
temp = (*i) * n_total;
- for(Node::iterator j = node2_->active_rotamers_begin();
+ for(RotamerGraphNode::iterator j = node2_->active_rotamers_begin();
j != node2_->active_rotamers_end(); ++j){
summed_e += pairwise_energies_[temp + (*j)];
}
@@ -61,11 +66,11 @@ bool Edge::Decompose(Real thresh){
Real bl[n];
uint m_counter = 0;
- for(Node::iterator i = node1_->active_rotamers_begin();
+ for(RotamerGraphNode::iterator i = node1_->active_rotamers_begin();
i != node1_->active_rotamers_end(); ++i){
summed_e = 0.0;
int temp = (*i) * n_total;
- for(Node::iterator j = node2_->active_rotamers_begin();
+ for(RotamerGraphNode::iterator j = node2_->active_rotamers_begin();
j != node2_->active_rotamers_end(); ++j){
summed_e += pairwise_energies_[temp + (*j)];
}
@@ -75,19 +80,20 @@ bool Edge::Decompose(Real thresh){
Real e;
uint n_counter = 0;
- for(Node::iterator i = node2_->active_rotamers_begin();
+ for(RotamerGraphNode::iterator i = node2_->active_rotamers_begin();
i != node2_->active_rotamers_end(); ++i){
summed_e = 0.0;
- for(Node::iterator j = node1_->active_rotamers_begin();
+ for(RotamerGraphNode::iterator j = node1_->active_rotamers_begin();
j != node1_->active_rotamers_end(); ++j){
summed_e += pairwise_energies_[(*j) * node2_->GetNumRotamers() + (*i)];
}
bl[n_counter] = summed_e/m - avg_value;
m_counter = 0;
- for(Node::iterator j = node1_->active_rotamers_begin();
+ for(RotamerGraphNode::iterator j = node1_->active_rotamers_begin();
j != node1_->active_rotamers_end(); ++j){
- e = std::abs(pairwise_energies_[(*j)*n_total+(*i)]-ak[m_counter]-bl[n_counter]);
+ e = std::abs(pairwise_energies_[(*j)*n_total+(*i)]-
+ ak[m_counter]-bl[n_counter]);
if(e > thresh) return false;
++m_counter;
}
@@ -95,14 +101,14 @@ bool Edge::Decompose(Real thresh){
}
for(uint i = 0; i < m; ++i){
- for(Node::iterator j = node1_->active_rotamers_begin();
+ for(RotamerGraphNode::iterator j = node1_->active_rotamers_begin();
j != node1_->active_rotamers_end(); ++j){
node1_->AddValue(*j,ak[i]);
}
}
for(uint i = 0; i < n; ++i){
- for(Node::iterator j = node2_->active_rotamers_begin();
+ for(RotamerGraphNode::iterator j = node2_->active_rotamers_begin();
j != node2_->active_rotamers_end(); ++j){
node2_->AddValue(*j,bl[i]);
}
@@ -113,33 +119,38 @@ bool Edge::Decompose(Real thresh){
return true;
}
-Real Edge::EMinDiff(const Node* node_ptr, uint idx1, uint idx2) const{
+Real RotamerGraphEdge::EMinDiff(const RotamerGraphNode* node_ptr,
+ uint idx1, uint idx2) const{
Real min = std::numeric_limits<Real>::max();
if(node_ptr == node1_){
int temp1 = idx1 * node2_->GetNumRotamers();
int temp2 = idx2 * node2_->GetNumRotamers();
- for(Node::const_iterator i = node2_->active_rotamers_begin();
+ for(RotamerGraphNode::const_iterator i = node2_->active_rotamers_begin();
i != node2_->active_rotamers_end(); ++i){
- min = std::min(min,pairwise_energies_[temp1 + (*i)] - pairwise_energies_[temp2 + (*i)]);
+ min = std::min(min,pairwise_energies_[temp1 + (*i)] -
+ pairwise_energies_[temp2 + (*i)]);
}
return min;
}
else if(node_ptr == node2_){
int num = node2_->GetNumRotamers();
- for(Node::const_iterator i = node1_->active_rotamers_begin();
+ for(RotamerGraphNode::const_iterator i = node1_->active_rotamers_begin();
i != node1_->active_rotamers_end(); ++i){
- min = std::min(min,pairwise_energies_[(*i)*num + idx1] - pairwise_energies_[(*i)*num + idx2]);
+ min = std::min(min,pairwise_energies_[(*i)*num + idx1] -
+ pairwise_energies_[(*i)*num + idx2]);
}
return min;
}
- throw promod3::Error("Cannot evaluate Node which is unconnected to the edge of interest!");
+ String err = "Cannot evaluate Node which is unconnected to the edge of ";
+ err += "interest!";
+ throw promod3::Error(err);
}
-void Edge::FillActiveEnergies(Real* pairwise_energies) const{
- for(Node::const_iterator i = node1_->active_rotamers_begin();
+void RotamerGraphEdge::FillActiveEnergies(Real* pairwise_energies) const{
+ for(RotamerGraphNode::const_iterator i = node1_->active_rotamers_begin();
i != node1_->active_rotamers_end(); ++i){
- for(Node::const_iterator j = node2_->active_rotamers_begin();
+ for(RotamerGraphNode::const_iterator j = node2_->active_rotamers_begin();
j != node2_->active_rotamers_end(); ++j){
*pairwise_energies = pairwise_energies_[*i*node2_->GetNumRotamers() + *j];
++pairwise_energies;
@@ -147,13 +158,13 @@ void Edge::FillActiveEnergies(Real* pairwise_energies) const{
}
}
-Node* Edge::GetOtherNode(Node* node){
+RotamerGraphNode* RotamerGraphEdge::GetOtherNode(RotamerGraphNode* node){
if(node == node1_) return node2_;
if(node == node2_) return node1_;
throw promod3::Error("Node does not belong to edge!");
}
-Node::Node(uint index,
+RotamerGraphNode::RotamerGraphNode(uint index,
uint num_rotamers,
Real* internal_energies,
Real* frame_energies): active_(true),index_(index),
@@ -169,16 +180,17 @@ Node::Node(uint index,
sorted_active_rotamers_.push_back(std::make_pair(i,self_energies_[i]));
}
- std::sort(sorted_active_rotamers_.begin(), sorted_active_rotamers_.end(),active_rotamer_sorter);
+ std::sort(sorted_active_rotamers_.begin(), sorted_active_rotamers_.end(),
+ active_rotamer_sorter);
}
-Node::~Node(){
+RotamerGraphNode::~RotamerGraphNode(){
delete [] internal_energies_;
delete [] frame_energies_;
delete [] self_energies_;
}
-void Node::Reset(){
+void RotamerGraphNode::Reset(){
//clear everything
active_rotamers_.clear();
@@ -192,16 +204,20 @@ void Node::Reset(){
self_energies_[i] = internal_energies_[i] + frame_energies_[i];
sorted_active_rotamers_.push_back(std::make_pair(i,self_energies_[i]));
}
- std::sort(sorted_active_rotamers_.begin(), sorted_active_rotamers_.end(),active_rotamer_sorter);
+ std::sort(sorted_active_rotamers_.begin(), sorted_active_rotamers_.end(),
+ active_rotamer_sorter);
for(uint i = 0; i < edges_.size(); ++i){
active_edges_.push_back(i);
}
- for(std::vector<Edge*>::iterator i = edges_.begin(); i != edges_.end(); ++i) (*i)->Reset();
+ for(std::vector<RotamerGraphEdge*>::iterator i = edges_.begin();
+ i != edges_.end(); ++i){
+ (*i)->Reset();
+ }
}
-void Node::Deactivate(){
+void RotamerGraphNode::Deactivate(){
if(!active_) return;
active_ = false;
//lets first figure out which is the lowest energy
@@ -218,35 +234,37 @@ void Node::Deactivate(){
active_rotamers_[0] = index;
//deactivate all edges connected to this node
- for(iterator i = this->active_edges_begin(); i != this->active_edges_end(); ++i){
- Node* other = edges_[*i]->GetOtherNode(this);
+ for(iterator i = this->active_edges_begin();
+ i != this->active_edges_end(); ++i){
+ RotamerGraphNode* other = edges_[*i]->GetOtherNode(this);
other->RemoveFromActiveEdges(edges_[*i]);
edges_[*i]->Deactivate();
}
active_edges_.clear();
}
-void Node::AddEdge(Edge* edge){
+void RotamerGraphNode::AddEdge(RotamerGraphEdge* edge){
edges_.push_back(edge);
active_edges_.push_back(edges_.size()-1);
}
-void Node::AddValue(Real value){
+void RotamerGraphNode::AddValue(Real value){
for(std::vector<uint>::iterator i = active_rotamers_.begin();
i != active_rotamers_.end(); ++i){
self_energies_[*i] += value;
}
}
-void Node::AddValue(uint node_idx, Real value){
+void RotamerGraphNode::AddValue(uint node_idx, Real value){
self_energies_[node_idx] += value;
}
-void Node::RemoveFromActiveEdges(Edge* edge){
+void RotamerGraphNode::RemoveFromActiveEdges(RotamerGraphEdge* edge){
uint counter = 0;
for(; counter < edges_.size(); ++counter){
if(edge == edges_[counter]){
- iterator i = std::find(active_edges_.begin(), active_edges_.end(), counter);
+ iterator i = std::find(active_edges_.begin(), active_edges_.end(),
+ counter);
if(i != active_edges_.end()){
active_edges_.erase(i);
}
@@ -256,7 +274,7 @@ void Node::RemoveFromActiveEdges(Edge* edge){
}
}
-bool Node::DEE(){
+bool RotamerGraphNode::DEE(){
if(active_rotamers_.size() <= 1) return false;
@@ -268,8 +286,10 @@ bool Node::DEE(){
if(i == rotamer_to_eliminate) continue;
sum = self_energies_[sorted_active_rotamers_[rotamer_to_eliminate].first] -
self_energies_[sorted_active_rotamers_[i].first];
- for(iterator j = this->active_edges_.begin(); j != this->active_edges_.end(); ++j){
- sum += edges_[*j]->EMinDiff(this,sorted_active_rotamers_[rotamer_to_eliminate].first,
+ for(iterator j = this->active_edges_.begin();
+ j != this->active_edges_.end(); ++j){
+ sum += edges_[*j]->EMinDiff(this,
+ sorted_active_rotamers_[rotamer_to_eliminate].first,
sorted_active_rotamers_[i].first);
}
if(sum >= 0){
@@ -278,7 +298,8 @@ bool Node::DEE(){
active_rotamers_.end(),
sorted_active_rotamers_[rotamer_to_eliminate].first);
active_rotamers_.erase(it);
- sorted_active_rotamers_.erase(sorted_active_rotamers_.begin() + rotamer_to_eliminate);
+ sorted_active_rotamers_.erase(sorted_active_rotamers_.begin() +
+ rotamer_to_eliminate);
break;
}
}
@@ -288,7 +309,7 @@ bool Node::DEE(){
return something_happened;
}
-void Node::FillActiveSelfEnergies(Real* self_energies) const{
+void RotamerGraphNode::FillActiveSelfEnergies(Real* self_energies) const{
for(const_iterator i = this->active_rotamers_begin();
i != this->active_rotamers_end(); ++i){
*self_energies = self_energies_[*i];
@@ -296,26 +317,26 @@ void Node::FillActiveSelfEnergies(Real* self_energies) const{
}
}
-Graph::~Graph(){
- for(std::vector<Node*>::iterator i = nodes_.begin();
+RotamerGraph::~RotamerGraph(){
+ for(std::vector<RotamerGraphNode*>::iterator i = nodes_.begin();
i != nodes_.end(); ++i){
delete *i;
}
- for(std::vector<Edge*>::iterator i = edges_.begin();
+ for(std::vector<RotamerGraphEdge*>::iterator i = edges_.begin();
i != edges_.end(); ++i){
delete *i;
}
}
-GraphPtr Graph::CreateFromRRMList(
+RotamerGraphPtr RotamerGraph::CreateFromRRMList(
const std::vector<RRMRotamerGroupPtr>& rotamer_groups,
const std::vector<geom::Transform>& rt_operators) {
core::ScopedTimerPtr prof = core::StaticRuntimeProfiler::StartScoped(
"Graph::CreateFromRRMList", 2);
- GraphPtr graph(new Graph);
+ RotamerGraphPtr graph(new RotamerGraph);
//let's create the nodes
graph->nodes_.resize(rotamer_groups.size());
@@ -330,16 +351,20 @@ GraphPtr Graph::CreateFromRRMList(
internal_energies[j] = (**i)[j]->GetInternalEnergy();
frame_energies[j] = (**i)[j]->GetFrameEnergy();
}
- graph->nodes_[counter] = new Node(counter,(*i)->size(),internal_energies,frame_energies);
+ graph->nodes_[counter] = new RotamerGraphNode(counter,
+ (*i)->size(),
+ internal_energies,
+ frame_energies);
}
//let's create the edges and directly add them to the corresponding nodes
for(uint i = 0; i < rotamer_groups.size(); ++i){
for(uint j = i+1; j < rotamer_groups.size(); ++j){
- Real* pairwise_energies = rotamer_groups[i]->CalculatePairwiseEnergies(rotamer_groups[j],0.01);
+ Real* pairwise_energies =
+ rotamer_groups[i]->CalculatePairwiseEnergies(rotamer_groups[j],0.01);
if(pairwise_energies!=NULL){
- Edge* edge = new Edge(graph->edges_.size(),
+ RotamerGraphEdge* edge = new RotamerGraphEdge(graph->edges_.size(),
graph->nodes_[i],graph->nodes_[j],
rotamer_groups[i]->size(),
rotamer_groups[j]->size(),
@@ -363,7 +388,8 @@ GraphPtr Graph::CreateFromRRMList(
for(uint i = 0; i < rotamer_groups.size(); ++i){
for(uint j = 0; j < transformed_groups.size(); ++j){
- Real* pairwise_energies = rotamer_groups[i]->CalculatePairwiseEnergies(transformed_groups[j],0.01);
+ Real* pairwise_energies =
+ rotamer_groups[i]->CalculatePairwiseEnergies(transformed_groups[j],0.01);
if(pairwise_energies!=NULL){
if(i > j){
int i_size = rotamer_groups[i]->size();
@@ -371,7 +397,7 @@ GraphPtr Graph::CreateFromRRMList(
Real* inverted_energies = new Real[i_size * j_size];
Invert(pairwise_energies,inverted_energies,i_size,j_size);
delete [] pairwise_energies;
- Edge* edge = new Edge(graph->edges_.size(),
+ RotamerGraphEdge* edge = new RotamerGraphEdge(graph->edges_.size(),
graph->nodes_[j],
graph->nodes_[i],
rotamer_groups[j]->size(),
@@ -383,7 +409,7 @@ GraphPtr Graph::CreateFromRRMList(
continue;
}
- Edge* edge = new Edge(graph->edges_.size(),
+ RotamerGraphEdge* edge = new RotamerGraphEdge(graph->edges_.size(),
graph->nodes_[i],
graph->nodes_[j],
rotamer_groups[i]->size(),
@@ -401,14 +427,14 @@ GraphPtr Graph::CreateFromRRMList(
}
-GraphPtr Graph::CreateFromFRMList(
+RotamerGraphPtr RotamerGraph::CreateFromFRMList(
const std::vector<FRMRotamerGroupPtr>& rotamer_groups,
const std::vector<geom::Transform>& rt_operators) {
core::ScopedTimerPtr prof = core::StaticRuntimeProfiler::StartScoped(
"Graph::CreateFromFRMList", 2);
- GraphPtr graph(new Graph);
+ RotamerGraphPtr graph(new RotamerGraph);
//let's create the nodes
graph->nodes_.resize(rotamer_groups.size());
@@ -423,15 +449,19 @@ GraphPtr Graph::CreateFromFRMList(
internal_energies[j] = (**i)[j]->GetInternalEnergy();
frame_energies[j] = (**i)[j]->GetFrameEnergy();
}
- graph->nodes_[counter] = new Node(counter,(*i)->size(),internal_energies,frame_energies);
+ graph->nodes_[counter] = new RotamerGraphNode(counter,
+ (*i)->size(),
+ internal_energies,
+ frame_energies);
}
//let's create the edges and directly add them to the corresponding nodes
for(uint i = 0; i < rotamer_groups.size(); ++i){
for(uint j = i+1; j < rotamer_groups.size(); ++j){
- Real* pairwise_energies = rotamer_groups[i]->CalculatePairwiseEnergies(rotamer_groups[j],0.01);
+ Real* pairwise_energies =
+ rotamer_groups[i]->CalculatePairwiseEnergies(rotamer_groups[j],0.01);
if(pairwise_energies != NULL){
- Edge* edge = new Edge(graph->edges_.size(),
+ RotamerGraphEdge* edge = new RotamerGraphEdge(graph->edges_.size(),
graph->nodes_[i],
graph->nodes_[j],
rotamer_groups[i]->size(),
@@ -456,7 +486,8 @@ GraphPtr Graph::CreateFromFRMList(
for(uint i = 0; i < rotamer_groups.size(); ++i){
for(uint j = 0; j < transformed_groups.size(); ++j){
- Real* pairwise_energies = rotamer_groups[i]->CalculatePairwiseEnergies(transformed_groups[j],0.01);
+ Real* pairwise_energies =
+ rotamer_groups[i]->CalculatePairwiseEnergies(transformed_groups[j],0.01);
if(pairwise_energies!=NULL){
if(i > j){
int i_size = rotamer_groups[i]->size();
@@ -464,7 +495,7 @@ GraphPtr Graph::CreateFromFRMList(
Real* inverted_energies = new Real[i_size * j_size];
Invert(pairwise_energies,inverted_energies,i_size,j_size);
delete [] pairwise_energies;
- Edge* edge = new Edge(graph->edges_.size(),
+ RotamerGraphEdge* edge = new RotamerGraphEdge(graph->edges_.size(),
graph->nodes_[j],
graph->nodes_[i],
rotamer_groups[j]->size(),
@@ -476,7 +507,7 @@ GraphPtr Graph::CreateFromFRMList(
continue;
}
- Edge* edge = new Edge(graph->edges_.size(),
+ RotamerGraphEdge* edge = new RotamerGraphEdge(graph->edges_.size(),
graph->nodes_[i],
graph->nodes_[j],
rotamer_groups[i]->size(),
@@ -493,54 +524,58 @@ GraphPtr Graph::CreateFromFRMList(
return graph;
}
-size_t Graph::GetNumActiveRotamers() const{
+size_t RotamerGraph::GetNumActiveRotamers() const{
size_t num_rotamers = 0;
- for(std::vector<Node*>::const_iterator i = nodes_.begin(); i != nodes_.end(); ++i){
+ for(std::vector<RotamerGraphNode*>::const_iterator i = nodes_.begin();
+ i != nodes_.end(); ++i){
if(!(*i)->IsActive()) continue;
num_rotamers += (*i)->GetNumActiveRotamers();
}
return num_rotamers;
}
-size_t Graph::GetNumActiveEdges() const{
+size_t RotamerGraph::GetNumActiveEdges() const{
size_t num_edges = 0;
- for(std::vector<Edge*>::const_iterator i = edges_.begin(); i != edges_.end(); ++i){
+ for(std::vector<RotamerGraphEdge*>::const_iterator i = edges_.begin();
+ i != edges_.end(); ++i){
if((*i)->IsActive()) ++num_edges;
}
return num_edges;
}
-size_t Graph::GetNumActiveNodes() const{
+size_t RotamerGraph::GetNumActiveNodes() const{
size_t num_nodes = 0;
- for(std::vector<Node*>::const_iterator i = nodes_.begin(); i != nodes_.end(); ++i){
+ for(std::vector<RotamerGraphNode*>::const_iterator i = nodes_.begin();
+ i != nodes_.end(); ++i){
if((*i)->IsActive()) ++num_nodes;
}
return num_nodes;
}
-size_t Graph::GetNumRotamers() const{
+size_t RotamerGraph::GetNumRotamers() const{
size_t num_rotamers = 0;
- for(std::vector<Node*>::const_iterator i = nodes_.begin(); i != nodes_.end(); ++i){
+ for(std::vector<RotamerGraphNode*>::const_iterator i = nodes_.begin();
+ i != nodes_.end(); ++i){
num_rotamers += (*i)->GetNumRotamers();
}
return num_rotamers;
}
-void Graph::GetNumRotamers(std::vector<int>& num_rotamers) const{
+void RotamerGraph::GetNumRotamers(std::vector<int>& num_rotamers) const{
num_rotamers.resize(nodes_.size());
for(uint i = 0; i < nodes_.size(); ++i){
num_rotamers[i] = nodes_[i]->GetNumRotamers();
}
}
-void Graph::GetNumActiveRotamers(std::vector<int>& num_rotamers) const{
+void RotamerGraph::GetNumActiveRotamers(std::vector<int>& num_rotamers) const{
num_rotamers.resize(nodes_.size());
for(uint i = 0; i < nodes_.size(); ++i){
num_rotamers[i] = nodes_[i]->GetNumActiveRotamers();
}
}
-void Graph::Prune(Real epsilon, bool consider_all_nodes){
+void RotamerGraph::Prune(Real epsilon, bool consider_all_nodes){
//nodes/edges, where something happened
std::vector<bool> hot_edges(edges_.size(),true);
@@ -571,9 +606,9 @@ void Graph::Prune(Real epsilon, bool consider_all_nodes){
if(nodes_[i]->DEE()){
//let's set the status hot to the edges, as well as other
//nodes connected to that node
- for(Node::iterator j = nodes_[i]->active_edges_begin();
+ for(RotamerGraphNode::iterator j = nodes_[i]->active_edges_begin();
j != nodes_[i]->active_edges_end(); ++j){
- Edge* current_edge = nodes_[i]->GetEdge(*j);
+ RotamerGraphEdge* current_edge = nodes_[i]->GetEdge(*j);
hot_edges[current_edge->GetIndex()] = true;
//one of the following connected node is the checked node
//itself... will be set to false again...
@@ -589,7 +624,7 @@ void Graph::Prune(Real epsilon, bool consider_all_nodes){
}
}
-void Graph::Reset(){
+void RotamerGraph::Reset(){
for(node_iterator i = nodes_begin(); i != nodes_end(); ++i){
(*i)->Reset();
}
@@ -598,7 +633,8 @@ void Graph::Reset(){
}
}
-std::vector<int> Graph::Solve(uint64_t max_complexity, Real initial_epsilon) {
+std::vector<int> RotamerGraph::Solve(uint64_t max_complexity,
+ Real initial_epsilon) {
core::ScopedTimerPtr prof = core::StaticRuntimeProfiler::StartScoped(
"Graph::Solve", 2);
@@ -621,13 +657,15 @@ std::vector<int> Graph::Solve(uint64_t max_complexity, Real initial_epsilon) {
//the indices are based on the active rotamers in the rotamer groups
//we have to map that
int actual_pos = 0;;
- for(node_iterator i = this->nodes_begin(); i != this->nodes_end(); ++i, ++actual_pos){
+ for(node_iterator i = this->nodes_begin();
+ i != this->nodes_end(); ++i, ++actual_pos){
return_vec[actual_pos] = (*i)->GetOverallIndex(return_vec[actual_pos]);
}
return return_vec;
}
-void Graph::Invert(Real* energies, Real* inverted_energies, int i_size, int j_size){
+void RotamerGraph::Invert(Real* energies, Real* inverted_energies,
+ int i_size, int j_size){
Real* e_ptr = energies;
for(int i = 0; i < i_size; ++i){
for(int j = 0; j < j_size; ++j){
diff --git a/sidechain/src/graph.hh b/sidechain/src/graph.hh
index 8eb80fae..31d83a4e 100644
--- a/sidechain/src/graph.hh
+++ b/sidechain/src/graph.hh
@@ -1,5 +1,5 @@
-#ifndef PROMOD3_GRAPH_COMPONENTS_HH
-#define PROMOD3_GRAPH_COMPONENTS_HH
+#ifndef PROMOD3_ROTAMER_GRAPH_COMPONENTS_HH
+#define PROMOD3_ROTAMER_GRAPH_COMPONENTS_HH
#include <math.h>
#include <vector>
@@ -19,18 +19,19 @@
namespace promod3{ namespace sidechain{
-class Edge;
-class Node;
-class Graph;
+class RotamerGraphEdge;
+class RotamerGraphNode;
+class RotamerGraph;
-typedef boost::shared_ptr<Graph> GraphPtr;
+typedef boost::shared_ptr<RotamerGraph> RotamerGraphPtr;
-class Edge{
+class RotamerGraphEdge{
public:
- Edge(uint index, Node* node1, Node* node2, uint num_i, uint num_j, Real* pairwise_energies_);
+ RotamerGraphEdge(uint index, RotamerGraphNode* node1, RotamerGraphNode* node2,
+ uint num_i, uint num_j, Real* pairwise_energies_);
- ~Edge();
+ ~RotamerGraphEdge();
void Reset();
@@ -44,38 +45,38 @@ public:
Real GetPairwiseEnergy(uint i, uint j) const { return pairwise_energies_[i * maxj_ + j]; }
- Node* GetNode1() const { return node1_; }
+ RotamerGraphNode* GetNode1() const { return node1_; }
- Node* GetNode2() const { return node2_; }
+ RotamerGraphNode* GetNode2() const { return node2_; }
- Node* GetOtherNode(Node* node);
+ RotamerGraphNode* GetOtherNode(RotamerGraphNode* node);
//resolves the expression min_x(EPair(idx1,x)-EPair(idx2,x))
//in the DEE formalism, where x only considers the active
//rotamers from the OTHER node than node_ptr
- Real EMinDiff(const Node* node_ptr, uint idx1, uint idx2) const;
+ Real EMinDiff(const RotamerGraphNode* node_ptr, uint idx1, uint idx2) const;
void FillActiveEnergies(Real* pairwise_energies) const;
private:
uint index_;
bool active_;
- Node* node1_;
- Node* node2_;
+ RotamerGraphNode* node1_;
+ RotamerGraphNode* node2_;
uint maxi_;
uint maxj_;
Real* pairwise_energies_;
};
-class Node{
+class RotamerGraphNode{
public:
- Node(uint index,
+ RotamerGraphNode(uint index,
uint num_rotamers,
Real* internal_energies,
Real* frame_energies);
- ~Node();
+ ~RotamerGraphNode();
void Reset();
@@ -85,11 +86,11 @@ public:
uint GetIndex() { return index_; }
- void AddEdge(Edge* edge);
+ void AddEdge(RotamerGraphEdge* edge);
- Edge* GetEdge(uint index) const { return edges_.at(index); }
+ RotamerGraphEdge* GetEdge(uint index) const { return edges_.at(index); }
- void RemoveFromActiveEdges(Edge* edge);
+ void RemoveFromActiveEdges(RotamerGraphEdge* edge);
void AddValue(Real val);
@@ -135,20 +136,20 @@ private:
std::vector<uint> active_rotamers_;
std::vector<uint> active_edges_;
std::vector<std::pair<uint,Real> > sorted_active_rotamers_;
- std::vector<Edge*> edges_;
+ std::vector<RotamerGraphEdge*> edges_;
};
-class Graph{
+class RotamerGraph{
public:
- ~Graph();
+ ~RotamerGraph();
- static GraphPtr CreateFromRRMList(const std::vector<RRMRotamerGroupPtr>& rotamer_groups,
- const std::vector<geom::Transform>& rt_operators = std::vector<geom::Transform>());
+ static RotamerGraphPtr CreateFromRRMList(const std::vector<RRMRotamerGroupPtr>& rotamer_groups,
+ const std::vector<geom::Transform>& rt_operators = std::vector<geom::Transform>());
- static GraphPtr CreateFromFRMList(const std::vector<FRMRotamerGroupPtr>& rotamer_groups,
- const std::vector<geom::Transform>& rt_operators = std::vector<geom::Transform>());
+ static RotamerGraphPtr CreateFromFRMList(const std::vector<FRMRotamerGroupPtr>& rotamer_groups,
+ const std::vector<geom::Transform>& rt_operators = std::vector<geom::Transform>());
size_t GetNumActiveRotamers() const;
@@ -173,15 +174,15 @@ public:
std::vector<int> Solve(uint64_t max_complexity = std::numeric_limits<uint64_t>::max(),
Real intial_epsilon = 0.02);
- Node* GetNode(uint index) { return nodes_.at(index); }
+ RotamerGraphNode* GetNode(uint index) { return nodes_.at(index); }
- Edge* GetEdge(uint index) { return edges_.at(index); }
+ RotamerGraphEdge* GetEdge(uint index) { return edges_.at(index); }
- typedef std::vector<Node*>::const_iterator const_node_iterator;
- typedef std::vector<Node*>::iterator node_iterator;
+ typedef std::vector<RotamerGraphNode*>::const_iterator const_node_iterator;
+ typedef std::vector<RotamerGraphNode*>::iterator node_iterator;
- typedef std::vector<Edge*>::const_iterator const_edge_iterator;
- typedef std::vector<Edge*>::iterator edge_iterator;
+ typedef std::vector<RotamerGraphEdge*>::const_iterator const_edge_iterator;
+ typedef std::vector<RotamerGraphEdge*>::iterator edge_iterator;
node_iterator nodes_begin() { return nodes_.begin(); }
node_iterator nodes_end() { return nodes_.end(); }
@@ -194,15 +195,15 @@ public:
const_edge_iterator edges_end() const{ return edges_.end(); }
private:
- Graph() { }
+ RotamerGraph() { }
- Graph(const Graph& other) { }
+ RotamerGraph(const RotamerGraph& other) { }
static void Invert(Real* energies, Real* inverted_energies,
int i_size , int j_size);
- std::vector<Node*> nodes_;
- std::vector<Edge*> edges_;
+ std::vector<RotamerGraphNode*> nodes_;
+ std::vector<RotamerGraphEdge*> edges_;
};
}}//ns
diff --git a/sidechain/src/tree.cc b/sidechain/src/tree.cc
index 466efbf0..e348b64c 100644
--- a/sidechain/src/tree.cc
+++ b/sidechain/src/tree.cc
@@ -312,7 +312,7 @@ Tree::~Tree(){
//they only contain pointers to the memory adresses just deleted
}
-uint64_t Tree::GenerateTree(Graph* graph){
+uint64_t Tree::GenerateTree(RotamerGraph* graph){
if(graph->GetNumNodes() != num_nodes_){
std::stringstream ss;
ss << "Cannot do the tree decomposition, given graph object differs in number of nodes ";
@@ -336,16 +336,16 @@ uint64_t Tree::GenerateTree(Graph* graph){
//to generate the matrix we need a ptr/index mapper...
//could be implemented a bit more efficient
- std::map<Node*,int> ptr_index_map;
+ std::map<RotamerGraphNode*,int> ptr_index_map;
int counter = 0;
- for(Graph::node_iterator i = graph->nodes_begin();
+ for(RotamerGraph::node_iterator i = graph->nodes_begin();
i != graph->nodes_end(); ++i){
ptr_index_map[*i] = counter;
++counter;
}
int a,b;
- for(Graph::edge_iterator i = graph->edges_begin();
+ for(RotamerGraph::edge_iterator i = graph->edges_begin();
i != graph->edges_end(); ++i){
if(!(*i)->IsActive()) continue;
a = ptr_index_map[(*i)->GetNode1()];
@@ -415,7 +415,7 @@ uint64_t Tree::GenerateTree(Graph* graph){
return complexity;
}
-void Tree::Solve(Graph* graph, std::vector<int>& overall_solution){
+void Tree::Solve(RotamerGraph* graph, std::vector<int>& overall_solution){
if(graph->GetNumNodes() != num_nodes_){
std::stringstream ss;
ss << "Cannot get complexity, given graph object differs in number of nodes ";
@@ -431,7 +431,7 @@ void Tree::Solve(Graph* graph, std::vector<int>& overall_solution){
//fill up self energies
uint pos = 0;
- for(Graph::const_node_iterator i = graph->nodes_begin();
+ for(RotamerGraph::const_node_iterator i = graph->nodes_begin();
i != graph->nodes_end(); ++i, ++pos){
Real* self_energies = new Real[num_rotamers[pos]];
(*i)->FillActiveSelfEnergies(self_energies);
@@ -442,15 +442,15 @@ void Tree::Solve(Graph* graph, std::vector<int>& overall_solution){
for(uint i = 0; i < num_nodes_; ++i){
pairwise_energies_[i].clear();
}
- std::map<Node*,int> ptr_index_map;
+ std::map<RotamerGraphNode*,int> ptr_index_map;
int counter = 0;
- for(Graph::node_iterator i = graph->nodes_begin();
+ for(RotamerGraph::node_iterator i = graph->nodes_begin();
i != graph->nodes_end(); ++i){
ptr_index_map[*i] = counter;
++counter;
}
int a,b;
- for(Graph::edge_iterator i = graph->edges_begin();
+ for(RotamerGraph::edge_iterator i = graph->edges_begin();
i != graph->edges_end(); ++i){
if(!(*i)->IsActive()) continue;
a = ptr_index_map[(*i)->GetNode1()];
diff --git a/sidechain/src/tree.hh b/sidechain/src/tree.hh
index 187d0605..5cd4405e 100644
--- a/sidechain/src/tree.hh
+++ b/sidechain/src/tree.hh
@@ -24,15 +24,15 @@ typedef boost::shared_ptr<Bag> BagPtr;
class Tree{
public:
- Tree(Graph* graph): num_nodes_(graph->GetNumNodes()) { }
+ Tree(RotamerGraph* graph): num_nodes_(graph->GetNumNodes()) { }
~Tree();
size_t GetNumNodes() const { return num_nodes_; }
- uint64_t GenerateTree(Graph* graph);
+ uint64_t GenerateTree(RotamerGraph* graph);
- void Solve(Graph* graph, std::vector<int>& overall_solution);
+ void Solve(RotamerGraph* graph, std::vector<int>& overall_solution);
private:
uint num_nodes_;
--
GitLab