make it possible to reconstruct several stretches instead of only one

!!!ATTENTION!!!: This might have an influence on AllAtomRelaxer

sidechain/pymod/export_sidechain_reconstructor.cc

@@ -50,6 +50,23 @@ WrapReconstructRN(SidechainReconstructor& sc_rec,
   return sc_rec.Reconstruct(num, num_residues, chain_idx);
 }
 
+SidechainReconstructionDataPtr
+WrapReconstructInputList(SidechainReconstructor& sc_rec,
+                         const boost::python::list& start_resnums,
+                         const boost::python::list& num_residues,
+                         const boost::python::list& chain_indices){
+
+  std::vector<uint> v_start_resnums;
+  std::vector<uint> v_num_residues;
+  std::vector<uint> v_chain_indices;
+
+  core::ConvertListToVector(start_resnums, v_start_resnums);
+  core::ConvertListToVector(num_residues, v_num_residues);
+  core::ConvertListToVector(num_residues, v_chain_indices);
+
+  return sc_rec.Reconstruct(v_start_resnums, v_num_residues, v_chain_indices);
+}
+
 template<typename LibType> void
 WrapAttachEnvironment(SidechainReconstructor& sc_rec, loop::AllAtomEnv& env,
                       bool use_frm, LibType lib_param) {

sidechain/src/sidechain_reconstructor.cc

@@ -39,49 +39,49 @@ SidechainReconstructor::Reconstruct(uint start_resnum, uint num_residues,
                          "attached!");
   }
 
-  // prepare result
-  SidechainReconstructionDataPtr res(new SidechainReconstructionData());
-  res->env_pos.reset(new loop::AllAtomEnvPositions);
-  std::vector<uint>& res_indices = res->env_pos->res_indices;
-  res->loop_length = num_residues;
-  res->all_pos = all_pos_;
-  
   // get loop indices
-  res_indices = idx_handler_->ToIdxVector(start_resnum, res->loop_length,
+  std::vector<uint> indices = idx_handler_->ToIdxVector(start_resnum, 
+                                                        num_residues,
                                                         chain_idx);
-  // get surrounding
-  std::set<uint> nb_indices;
-  const uint n_stem_idx = res->GetNStemIdx();
-  const uint c_stem_idx = res->GetCStemIdx();
-  ScCBetaSpatialOrganizer::WithinResult within_result;
-  std::pair<ScCBetaSpatialOrganizerItem*,Real>* a;
-  for (uint i = 0; i < res->loop_length; ++i) {
-    const uint res_idx = res_indices[i];
-    within_result = env_->FindWithin(GetCxPos_(*all_pos_, res_idx), cutoff_);
-    a = within_result.first;
-    for (uint j = 0; j < within_result.second; ++j) {
-      const uint other_res_idx = a[j].first->res_idx;
-      if (other_res_idx < n_stem_idx || other_res_idx > c_stem_idx) {
-        nb_indices.insert(a[j].first->res_idx);
+  return this->ReconstructFromIndices(indices);
+
 }
+
+SidechainReconstructionDataPtr
+SidechainReconstructor::Reconstruct(const std::vector<uint>& start_resnums, 
+                                    const std::vector<uint>& num_residues,
+                                    const std::vector<uint>& chain_indices) const {
+  
+  promod3::core::ScopedTimerPtr prof = core::StaticRuntimeProfiler::StartScoped(
+                            "SidechainReconstructor::Reconstruct", 2);
+
+  if (!attached_environment_) {
+    throw promod3::Error("Can only reconstruct sidechains when environment is "
+                         "attached!");
   }
+
+  if(start_resnums.size() != num_residues.size()){
+    String err = "Size inconsistency of input data in SidechainReconstructor!";
+    throw promod3::Error(err);
   }
-  // append unique surrounding residue indices (first loop part, then rest)
-  res_indices.insert(res_indices.end(), nb_indices.begin(), nb_indices.end());
 
-  // add information on termini
-  res->is_n_ter.resize(res_indices.size());
-  res->is_c_ter.resize(res_indices.size());
-  for (uint i = 0; i < res_indices.size(); ++i) {
-    const uint res_idx = res_indices[i];
-    res->is_n_ter[i] = env_->IsNTerminal(res_idx);
-    res->is_c_ter[i] = env_->IsCTerminal(res_idx);
+  if(start_resnums.size() != chain_indices.size()){
+    String err = "Size inconsistency of input data in SidechainReconstructor!";
+    throw promod3::Error(err);
   }
   
-  // solve system
-  if (env_->HasFRMRotamers()) SolveSystem_<FRMRotamerGroup>(res);
-  else                        SolveSystem_<RRMRotamerGroup>(res);
-  return res;
+  std::vector<uint> full_indices;
+
+  for(uint i = 0; i < start_resnums.size(); ++i){
+    // get loop indices
+    std::vector<uint> indices = idx_handler_->ToIdxVector(start_resnums[i], 
+                                                          num_residues[i],
+                                                          chain_indices[i]);
+
+    full_indices.insert(full_indices.end(), indices.begin(), indices.end());
+  }
+
+  return this->ReconstructFromIndices(full_indices);
 }
 
 void SidechainReconstructor::AttachEnvironment(loop::AllAtomEnv& env,
@@ -129,6 +129,54 @@ void SidechainReconstructor::AttachEnvironment(loop::AllAtomEnv& env,
   SetEnvData_(env);
 }
 
+SidechainReconstructionDataPtr
+SidechainReconstructor::ReconstructFromIndices(const std::vector<uint>& indices) const{
+
+  // prepare result
+  SidechainReconstructionDataPtr res(new SidechainReconstructionData());
+  res->env_pos.reset(new loop::AllAtomEnvPositions);
+  std::vector<uint>& res_indices = res->env_pos->res_indices;
+  res_indices = indices;
+  res->loop_length = indices.size();
+  res->all_pos = all_pos_;
+
+  // get surrounding
+  std::set<uint> nb_indices;
+  ScCBetaSpatialOrganizer::WithinResult within_result;
+  std::pair<ScCBetaSpatialOrganizerItem*,Real>* a;
+  for (uint i = 0; i < res->loop_length; ++i) {
+    const uint res_idx = res_indices[i];
+    within_result = env_->FindWithin(GetCxPos_(*all_pos_, res_idx), cutoff_);
+    a = within_result.first;
+    for (uint j = 0; j < within_result.second; ++j) {
+      nb_indices.insert(a[j].first->res_idx);
+    }
+  }
+
+  // remove the indices form nb_indices
+  for(std::vector<uint>::iterator i = res_indices.begin(); 
+      i != res_indices.end(); ++i){
+    nb_indices.erase(*i);
+  }
+
+  // append unique surrounding residue indices (first loop part, then rest)
+  res_indices.insert(res_indices.end(), nb_indices.begin(), nb_indices.end());
+
+  // add information on termini
+  res->is_n_ter.resize(res_indices.size());
+  res->is_c_ter.resize(res_indices.size());
+  for (uint i = 0; i < res_indices.size(); ++i) {
+    const uint res_idx = res_indices[i];
+    res->is_n_ter[i] = env_->IsNTerminal(res_idx);
+    res->is_c_ter[i] = env_->IsCTerminal(res_idx);
+  }
+
+  // solve system
+  if (env_->HasFRMRotamers()) SolveSystem_<FRMRotamerGroup>(res);
+  else                        SolveSystem_<RRMRotamerGroup>(res);
+  return res;
+}
+
 void SidechainReconstructor::CheckEnvListener_(bool use_frm) const {
   // check consistency of relevant features
   if (use_frm != env_->HasFRMRotamers()) {

sidechain/src/sidechain_reconstructor.hh

@@ -56,6 +56,11 @@ public:
   SidechainReconstructionDataPtr
   Reconstruct(uint start_resnum, uint num_residues, uint chain_idx = 0) const;
 
+  SidechainReconstructionDataPtr
+  Reconstruct(const std::vector<uint>& start_resnums, 
+              const std::vector<uint>& num_residues, 
+              const std::vector<uint>& chain_indices) const;
+
   // options as in SidechainEnvListener (only used if no listener there yet!)
   void AttachEnvironment(loop::AllAtomEnv& env, bool use_frm = true,
                          bool use_bbdep_lib = true);
@@ -66,6 +71,9 @@ public:
 
 private:
 
+  SidechainReconstructionDataPtr 
+  ReconstructFromIndices(const std::vector<uint>& indices) const;
+
   // HELPERS
   void CheckEnvListener_(bool use_frm) const;
   void SetEnvData_(loop::AllAtomEnv& env);