fgdfgd

diff --git a/src/dssptools.cpp b/src/dssptools.cpp
index a3041d8b7ecf8014fd5d0bbdb4c319938d82238a..551343e5b950f12b01a115badb62821ef7c66c89 100644 (file)
--- a/src/dssptools.cpp
+++ b/src/dssptools.cpp
@@ -44,7 +44,9 @@
 
 
 
-/* Запилить версию поиска всех остатков против всех. Медленно, но как в дссп.*/
+/* Запилить версию поиска всех остатков против всех. Медленно, но как в дссп.
+   Расхождение может быть из-за тестбонда.
+*/
 
 #include "dssptools.h"
 
@@ -77,11 +79,11 @@ std::size_t backboneAtomIndexes::getIndex(backboneAtomTypes atomTypeName) const
 secondaryStructures::secondaryStructures(){
 }
 
-void secondaryStructures::initiateSearch(const std::vector<std::vector<bool> > &HBondsMap, const bool PiHelixesPreferenz = true){
+void secondaryStructures::initiateSearch(const std::vector<std::vector<bool> > &HBondsMap, const bool PiHelicesPreferenz = true){
     SecondaryStructuresStatusMap.resize(0);
     SecondaryStructuresStringLine.resize(0);
     std::vector<std::size_t> temp; temp.resize(0),
-    PiHelixPreference = PiHelixesPreferenz;
+    PiHelixPreference = PiHelicesPreferenz;
     SecondaryStructuresStatusMap.resize(HBondsMap.front().size());
     SecondaryStructuresStringLine.resize(HBondsMap.front().size(), '~');
 }
@@ -132,65 +134,99 @@ bool secondaryStructures::NoChainBreaksBetween(const std::size_t Resi1, const st
 
 }
 
-void secondaryStructures::analyzeBridgesAndLaddersPatterns(const std::vector<std::vector<bool>> &HBondsMap){
+bridgeTypes secondaryStructures::calculateBridge(const std::size_t i, const std::size_t j, const std::vector<std::vector<bool> > &HBondsMap){
 
-    for (std::size_t i{ 1 }; i < HBondsMap.front().size() - 1; ++i){
-        for (std::size_t j{ 1 }; j < HBondsMap.front().size() - 1; ++j){
-            if (std::abs(static_cast<int>(i) - static_cast<int>(j)) > 2){
-                if ((HBondsMap[i - 1][j] && HBondsMap[j][i + 1])    ||
-                    (HBondsMap[j - 1][i] && HBondsMap[i][j + 1])){
-                    Bridge[i].push_back(j);
-                }
-                if ((HBondsMap[i][j] && HBondsMap[j][i])    ||
-                    (HBondsMap[i - 1][j + 1] && HBondsMap[j - 1][i + 1])){
-                    AntiBridge[i].push_back(j);
-                }
-            }
-        }
+    if( i < 0 || j < 0 || i >= HBondsMap.size() || j >= HBondsMap.size() ){
+        return bridgeTypes::None;
     }
 
-
-    for (std::size_t i{ 0 }; i < HBondsMap.front().size(); ++i){
-        if ((!Bridge[i].empty() || !AntiBridge[i].empty())){
-            setStatus(i, secondaryStructureTypes::Bulge);
+    if(NoChainBreaksBetween(i - 1, i + 1) && NoChainBreaksBetween(j - 1, j + 1)){
+        if((HBondsMap[i + 1][j] && HBondsMap[j][i - 1]) || (HBondsMap[j + 1][i] && HBondsMap[i][j - 1]) ){
+            return bridgeTypes::Bridge;
+        }
+        else if((HBondsMap[i + 1][j - 1] && HBondsMap[j + 1][i - 1]) || (HBondsMap[j][i] && HBondsMap[i][j]) ){
+            return bridgeTypes::AntiBridge;
         }
     }
-    for (std::size_t i{ 2 }; i + 2 < HBondsMap.front().size(); ++i){
-        for (std::size_t j { i - 2 }; j <= (i + 2); ++j){
-            if (j == i){
-                continue;
-            }
-            else {
-                for (std::vector<bridgeTypes>::const_iterator bridge {Bridges.begin()}; bridge != Bridges.end(); ++bridge ){
-                    if (!getBridge(*bridge)[i].empty() || !getBridge(*bridge)[j].empty()){
-                        for (std::size_t i_resi{ 0 }; i_resi < getBridge(*bridge)[i].size(); ++i_resi){
-                            for (std::size_t j_resi{ 0 }; j_resi < getBridge(*bridge)[j].size(); ++j_resi){
-                                if (abs(static_cast<int>(getBridge(*bridge)[i][i_resi])
-                                        - static_cast<int>(getBridge(*bridge)[j][j_resi]))
-                                        && (abs(static_cast<int>(getBridge(*bridge)[i][i_resi])
-                                        - static_cast<int>(getBridge(*bridge)[j][j_resi]))
-                                        < 5)){
-                                    if (j < i){
-                                        for (std::size_t k{ 0 }; k <= i - j; ++k){
-                                            setStatus(i + k, secondaryStructureTypes::Ladder);
-                                        }
-                                    }
-                                    else{
-                                        for (std::size_t k{ 0 }; k <= j - i; ++k){
-                                            setStatus(i + k, secondaryStructureTypes::Ladder);
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
+
+    return bridgeTypes::None;
+}
+
+void secondaryStructures::analyzeBridgesAndLaddersPatterns(const std::vector<std::vector<bool>> &HBondsMap){
+
+    for(std::size_t i {1}; i + 4 < SecondaryStructuresStatusMap.size(); ++i){
+
+        for(std::size_t j {i + 3}; j + 1 < SecondaryStructuresStatusMap.size(); ++j ){
+
         }
     }
+
+
+
+
+
+
+
+
+
+
+
+
+//    for (std::size_t i{ 1 }; i < HBondsMap.front().size() - 1; ++i){
+//        for (std::size_t j{ 1 }; j < HBondsMap.front().size() - 1; ++j){
+//            if (std::abs(static_cast<int>(i) - static_cast<int>(j)) > 2){
+//                if ((HBondsMap[i - 1][j] && HBondsMap[j][i + 1])    ||
+//                    (HBondsMap[j - 1][i] && HBondsMap[i][j + 1])){
+//                    Bridge[i].push_back(j);
+//                }
+//                if ((HBondsMap[i][j] && HBondsMap[j][i])    ||
+//                    (HBondsMap[i - 1][j + 1] && HBondsMap[j - 1][i + 1])){
+//                    AntiBridge[i].push_back(j);
+//                }
+//            }
+//        }
+//    }
+//    for (std::size_t i{ 0 }; i < HBondsMap.front().size(); ++i){
+//        if ((!Bridge[i].empty() || !AntiBridge[i].empty())){
+//            setStatus(i, secondaryStructureTypes::Bulge);
+//        }
+//    }
+//    for (std::size_t i{ 2 }; i + 2 < HBondsMap.front().size(); ++i){
+//        for (std::size_t j { i - 2 }; j <= (i + 2); ++j){
+//            if (j == i){
+//                continue;
+//            }
+//            else {
+//                for (std::vector<bridgeTypes>::const_iterator bridge {Bridges.begin()}; bridge != Bridges.end(); ++bridge ){
+//                    if (!getBridge(*bridge)[i].empty() || !getBridge(*bridge)[j].empty()){
+//                        for (std::size_t i_resi{ 0 }; i_resi < getBridge(*bridge)[i].size(); ++i_resi){
+//                            for (std::size_t j_resi{ 0 }; j_resi < getBridge(*bridge)[j].size(); ++j_resi){
+//                                if (abs(static_cast<int>(getBridge(*bridge)[i][i_resi])
+//                                        - static_cast<int>(getBridge(*bridge)[j][j_resi]))
+//                                        && (abs(static_cast<int>(getBridge(*bridge)[i][i_resi])
+//                                        - static_cast<int>(getBridge(*bridge)[j][j_resi]))
+//                                        < 5)){
+//                                    if (j < i){
+//                                        for (std::size_t k{ 0 }; k <= i - j; ++k){
+//                                            setStatus(i + k, secondaryStructureTypes::Ladder);
+//                                        }
+//                                    }
+//                                    else{
+//                                        for (std::size_t k{ 0 }; k <= j - i; ++k){
+//                                            setStatus(i + k, secondaryStructureTypes::Ladder);
+//                                        }
+//                                    }
+//                                }
+//                            }
+//                        }
+//                    }
+//                }
+//            }
+//        }
+//    }
 }
 
-void secondaryStructures::analyzeTurnsAndHelixesPatterns(const std::vector<std::vector<bool>> &HBondsMap){
+void secondaryStructures::analyzeTurnsAndHelicesPatterns(const std::vector<std::vector<bool>> &HBondsMap){
     for(const turnsTypes &i : { turnsTypes::Turn_4, turnsTypes::Turn_3, turnsTypes::Turn_5 }){
         for(std::size_t j {0}; j + (static_cast<std::size_t>(i) + strideFactor) < SecondaryStructuresStatusMap.size(); ++j){
             if ( HBondsMap[j][j + (static_cast<std::size_t>(i) + strideFactor)] && NoChainBreaksBetween(j, j + (static_cast<std::size_t>(i) + strideFactor)) ){
@@ -249,7 +285,7 @@ void secondaryStructures::analyzeTurnsAndHelixesPatterns(const std::vector<std::
         if (SecondaryStructuresStatusMap[i].getStatus() == secondaryStructureTypes::Loop ){
             bool isTurn = false;
             for(const turnsTypes &j : {turnsTypes::Turn_3, turnsTypes::Turn_4, turnsTypes::Turn_5}){
-                for(std::size_t k {1}; k < (static_cast<std::size_t>(i) + strideFactor); ++k){
+                for(std::size_t k {1}; k < (static_cast<std::size_t>(j) + strideFactor); ++k){
                     isTurn = (i >= k) && (SecondaryStructuresStatusMap[i - k].getStatus(j) == HelixPositions::Start || SecondaryStructuresStatusMap[i - k].getStatus(j) == HelixPositions::Start_AND_End) ;
                 }
             }
@@ -267,8 +303,9 @@ void secondaryStructures::analyzeTurnsAndHelixesPatterns(const std::vector<std::
 
 std::string secondaryStructures::patternSearch(const std::vector<std::vector<bool>> &HBondsMap){
 
-    analyzeTurnsAndHelixesPatterns(HBondsMap);
     analyzeBridgesAndLaddersPatterns(HBondsMap);
+    analyzeTurnsAndHelicesPatterns(HBondsMap);
+    analyzePPHelicesPatterns(HBondsMap);
 
     /*Write Data*/
 
@@ -716,7 +753,7 @@ void DsspTool::analyzeFrame(int frnr, const t_trxframe &fr, t_pbc *pbc, const bo
 }
 
 std::vector<std::pair<int, std::string>> DsspTool::getData(){
-    return Storage.returnData(DsspTool::counter);
+    return Storage.returnData();
 }
 
 } // namespace analysismodules

diff --git a/src/dssptools.h b/src/dssptools.h
index aae4fdd4f6eece4efe0a64c8e6a43722b469fdb6..8fc03a6ad13698153fe26d63eb4d6b18884d1246 100644 (file)
--- a/src/dssptools.h
+++ b/src/dssptools.h
@@ -64,7 +64,7 @@ enum class modeType : std::size_t
 {
     Classique = 0,
     Experimental,
-    Ramachanrdan,
+    Extra,
     Count
 };
 
@@ -132,15 +132,16 @@ enum class HelixPositions : std::size_t {
 };
 
 enum class bridgeTypes : std::size_t {
-    Bridge = 0,
+    None = 0,
     AntiBridge,
+    Bridge,
     Count
 };
 
 class secondaryStructures{
 public:
     secondaryStructures();
-    void                    initiateSearch(const std::vector<std::vector<bool>> &HBondsMap, const bool PiHelixesPreference);
+    void                    initiateSearch(const std::vector<std::vector<bool>> &HBondsMap, const bool PiHelicesPreference);
     std::string             calculateLinuxSucks(const std::vector<std::vector<bool>> &HBondsMap);
     std::string             patternSearch(const std::vector<std::vector<bool>> &HBondsMap);
 //    void                    setStatus(const std::size_t resiIndex, const secondaryStructureTypes secondaryStructureTypeName, const bool secondaryStructureStatus);
@@ -163,21 +164,19 @@ public:
 
     std::vector<secondaryStructuresData>     SecondaryStructuresStatusMap;
 private:
-//    std::array<bool, static_cast<std::size_t>(secondaryStructureTypes::Count)>                  SecondaryStructuresStatusArray{ 0, 0, 0, 0, 0, 0, 0 };
-//    std::array<bool, static_cast<std::size_t>(turnsTypes::Count)>                               HelixStartsArray{ 0, 0, 0};
 
 
     const gmx::EnumerationArray<secondaryStructureTypes, const char> secondaryStructureTypeNames = {
        { '=', 'S', 'T', 'I', 'G', 'E', 'B', 'H'} // TODO
     };
-//    std::vector<std::array<bool, static_cast<std::size_t>(turnsTypes::Count)>>                  HelixesStartMap;
-//    std::vector<std::vector<std::size_t>> Bridge, AntiBridge, getBridge(const bridgeTypes bridgeType);
     const std::vector<bridgeTypes> Bridges{ bridgeTypes::Bridge, bridgeTypes::AntiBridge};
     std::string     SecondaryStructuresStringLine;
     const std::size_t     strideFactor{3};
 
+    bridgeTypes     calculateBridge(const std::size_t resi1, const std::size_t resi2, const std::vector<std::vector<bool>> &HBondsMap);
+
     bool            NoChainBreaksBetween(const std::size_t ResiStart, const std::size_t ResiEnd), isLoop(const std::size_t resiIndex) const, PiHelixPreference;
-    void            analyzeTurnsAndHelixesPatterns(const std::vector<std::vector<bool>> &HBondsMap), analyzeBridgesAndLaddersPatterns(const std::vector<std::vector<bool>> &HBondsMap);
+    void            analyzeBridgesAndLaddersPatterns(const std::vector<std::vector<bool>> &HBondsMap), analyzeTurnsAndHelicesPatterns(const std::vector<std::vector<bool>> &HBondsMap), analyzePPHelicesPatterns(const std::vector<std::vector<bool>> &HBondsMap);
 };
 
 class alternateNeighborhoodSearch{