ASDASDASDASDASD

diff --git a/src/dssptools.cpp b/src/dssptools.cpp
index 69333efb151fd866e63948902b753133a1359f6f..a3041d8b7ecf8014fd5d0bbdb4c319938d82238a 100644 (file)
--- a/src/dssptools.cpp
+++ b/src/dssptools.cpp
@@ -77,19 +77,20 @@ std::size_t backboneAtomIndexes::getIndex(backboneAtomTypes atomTypeName) const
 secondaryStructures::secondaryStructures(){
 }
 
-void secondaryStructures::initiateSearch(const std::vector<std::vector<bool> > &HBondsMap){
+void secondaryStructures::initiateSearch(const std::vector<std::vector<bool> > &HBondsMap, const bool PiHelixesPreferenz = true){
     SecondaryStructuresStatusMap.resize(0);
     SecondaryStructuresStringLine.resize(0);
     std::vector<std::size_t> temp; temp.resize(0),
+    PiHelixPreference = PiHelixesPreferenz;
     SecondaryStructuresStatusMap.resize(HBondsMap.front().size());
     SecondaryStructuresStringLine.resize(HBondsMap.front().size(), '~');
 }
 
 void secondaryStructures::secondaryStructuresData::setStatus(const secondaryStructureTypes secondaryStructureTypeName, const bool secondaryStructureStatus = true){
     SecondaryStructuresStatusArray[static_cast<std::size_t>(secondaryStructureTypeName)] = secondaryStructureStatus;
-    if(secondaryStructureTypeName > SSData){
-        SSData = secondaryStructureTypeName;
-    }
+//    if(secondaryStructureTypeName > SSData){
+    SSData = secondaryStructureTypeName;
+//    }
 }
 
 void secondaryStructures::secondaryStructuresData::setStatus(const HelixPositions helixPosition, const turnsTypes turn){
@@ -104,26 +105,10 @@ HelixPositions secondaryStructures::secondaryStructuresData::getStatus(const tur
     return TurnsStatusArray[static_cast<std::size_t>(turn)];
 }
 
-secondaryStructureTypes secondaryStructures::secondaryStructuresData::getStatus(const std::size_t resi) const{
+secondaryStructureTypes secondaryStructures::secondaryStructuresData::getStatus() const{
     return SSData;
 }
 
-secondaryStructureTypes         returnSpecificSS(turnsTypes turn){
-    switch(turn){
-    case turnsTypes::Turn_3:
-        return secondaryStructureTypes::Helix_3;
-        break;
-    case turnsTypes::Turn_4:
-        return secondaryStructureTypes::Helix_4;
-        break;
-    case turnsTypes::Turn_5:
-        return secondaryStructureTypes::Helix_5;
-        break;
-    default:
-        return secondaryStructureTypes::Loop;
-    }
-}
-
 bool secondaryStructures::NoChainBreaksBetween(const std::size_t Resi1, const std::size_t Resi2){
     bool flag {true};
     if (Resi1 < Resi2){
@@ -206,92 +191,78 @@ void secondaryStructures::analyzeBridgesAndLaddersPatterns(const std::vector<std
 }
 
 void secondaryStructures::analyzeTurnsAndHelixesPatterns(const std::vector<std::vector<bool>> &HBondsMap){
-    for(std::vector<turnsTypes>::const_iterator i = turns.begin(); i != turns.end(); ++i){
-        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)) ){
-                SecondaryStructuresStatusMap[j + (static_cast<std::size_t>(*i) + strideFactor)].setStatus(HelixPositions::End, *i);
-
-                for (std::size_t k {1}; k < (static_cast<std::size_t>(*i) + strideFactor); ++k){
-                    if( SecondaryStructuresStatusMap[j + k].getStatus(*i) == HelixPositions::None ){
-                        SecondaryStructuresStatusMap[j + k].setStatus(HelixPositions::Middle, *i);
+    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)) ){
+                SecondaryStructuresStatusMap[j + (static_cast<std::size_t>(i) + strideFactor)].setStatus(HelixPositions::End, i);
+
+                for (std::size_t k {1}; k < (static_cast<std::size_t>(i) + strideFactor); ++k){
+                    if( SecondaryStructuresStatusMap[j + k].getStatus(i) == HelixPositions::None ){
+                        SecondaryStructuresStatusMap[j + k].setStatus(HelixPositions::Middle, i);
                     }
 
                 }
 
-                if( SecondaryStructuresStatusMap[j].getStatus(*i) == HelixPositions::End ){
-                    SecondaryStructuresStatusMap[j].setStatus(HelixPositions::Start_AND_End, *i);
+                if( SecondaryStructuresStatusMap[j].getStatus(i) == HelixPositions::End ){
+                    SecondaryStructuresStatusMap[j].setStatus(HelixPositions::Start_AND_End, i);
                 }
                 else {
-                    SecondaryStructuresStatusMap[j].setStatus(HelixPositions::Start, *i);
+                    SecondaryStructuresStatusMap[j].setStatus(HelixPositions::Start, i);
                 }
-
-//                for(std::size_t k {0}; k + (static_cast<std::size_t>(*i) + strideFactor) < SecondaryStructuresStatusMap.size(); ++k){
-//                    if (SecondaryStructuresStatusMap[j + k].getStatus(*i) != HelixPositions::None){
-//                        SecondaryStructuresStatusMap[j + k].setStatus(secondaryStructureTypes::Turn);
-//                    }
-//                }
             }
         }
     }
 
-    for(std::vector<turnsTypes>::const_iterator i = turns.begin(); i != turns.end(); ++i){
-        switch(*i){
-        case turnsTypes::Turn_3:
-            SecondaryStructuresStatusMap[j + k].setStatus(secondaryStructureTypes::Helix_3);
-
-            break;
-        case turnsTypes::Turn_4:
-            for(std::size_t j {1}; j + (static_cast<std::size_t>(*i) + strideFactor) < SecondaryStructuresStatusMap.size(); ++j){
-                if ( (SecondaryStructuresStatusMap[j - 1].getStatus(*i) == HelixPositions::Start || SecondaryStructuresStatusMap[j - 1].getStatus(*i) == HelixPositions::Start_AND_End ) &&
-                     (SecondaryStructuresStatusMap[j].getStatus(*i) == HelixPositions::Start || SecondaryStructuresStatusMap[j].getStatus(*i) == HelixPositions::Start_AND_End ) ){
-                    for(std::size_t k{0}; k < (static_cast<std::size_t>(*i) + strideFactor); ++k ){
-                        SecondaryStructuresStatusMap[j + k].setStatus(secondaryStructureTypes::Helix_4);
+    for(const turnsTypes &i : { turnsTypes::Turn_4, turnsTypes::Turn_3, turnsTypes::Turn_5 }){
+        for(std::size_t j {1}; j + (static_cast<std::size_t>(i) + strideFactor) < SecondaryStructuresStatusMap.size(); ++j){
+            if ( (SecondaryStructuresStatusMap[j - 1].getStatus(i) == HelixPositions::Start || SecondaryStructuresStatusMap[j - 1].getStatus(i) == HelixPositions::Start_AND_End ) &&
+                 (SecondaryStructuresStatusMap[j].getStatus(i) == HelixPositions::Start || SecondaryStructuresStatusMap[j].getStatus(i) == HelixPositions::Start_AND_End ) ){
+                bool empty = true;
+                secondaryStructureTypes Helix;
+                switch(i){
+                case turnsTypes::Turn_3:
+                    for (std::size_t k {0}; empty && k < (static_cast<std::size_t>(i) + strideFactor); ++k){
+                        empty = SecondaryStructuresStatusMap[j + k].getStatus() == secondaryStructureTypes::Loop || SecondaryStructuresStatusMap[j + k].getStatus() == secondaryStructureTypes::Helix_3;
+                    }
+                    Helix = secondaryStructureTypes::Helix_3;
+                    break;
+                case turnsTypes::Turn_4:
+                    Helix = secondaryStructureTypes::Helix_4;
+                    break;
+                case turnsTypes::Turn_5:
+                    for (std::size_t k {0}; empty && k < (static_cast<std::size_t>(i) + strideFactor); ++k){
+                        empty = SecondaryStructuresStatusMap[j + k].getStatus() == secondaryStructureTypes::Loop || SecondaryStructuresStatusMap[j + k].getStatus() == secondaryStructureTypes::Helix_5 || (PiHelixPreference && SecondaryStructuresStatusMap[j + k].getStatus() == secondaryStructureTypes::Helix_5);
                     }
+                    Helix = secondaryStructureTypes::Helix_4;
+                    break;
                 }
-            }
-            break;
-        case turnsTypes::Turn_5:
-            SecondaryStructuresStatusMap[j + k].setStatus(secondaryStructureTypes::Helix_5);
-            break;
-        }
-
-        for(std::size_t j {1}; j + (static_cast<std::size_t>(*i) + strideFactor) < SecondaryStructuresStatusMap.size(); ++j){
-            if ( (SecondaryStructuresStatusMap[j - 1].getStatus(*i) == HelixPositions::Start || SecondaryStructuresStatusMap[j - 1].getStatus(*i) == HelixPositions::Start_AND_End ) &&
-                 (SecondaryStructuresStatusMap[j].getStatus(*i) == HelixPositions::Start || SecondaryStructuresStatusMap[j].getStatus(*i) == HelixPositions::Start_AND_End ) ){
-                for(std::size_t k{0}; k < (static_cast<std::size_t>(*i) + strideFactor); ++k ){
-                    SecondaryStructuresStatusMap[j + k].setStatus(secondaryStructureTypes::Helix_4);
+                if ( empty ){
+                    for(std::size_t k {0}; k < (static_cast<std::size_t>(i) + strideFactor); ++k ){
+                        SecondaryStructuresStatusMap[j + k].setStatus(Helix);
+                    }
                 }
             }
         }
     }
-}
-
-
-
-std::string secondaryStructures::calculateLinuxSucks(const std::vector<std::vector<bool>> &HBondsMap){
-    analyzeTurnsAndHelixesPatterns(HBondsMap);
-    analyzeBridgesAndLaddersPatterns(HBondsMap);
 
-    /*Write Data*/
+    for(std::size_t i {1}; i + 1 < SecondaryStructuresStatusMap.size(); ++i){
+        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){
+                    isTurn = (i >= k) && (SecondaryStructuresStatusMap[i - k].getStatus(j) == HelixPositions::Start || SecondaryStructuresStatusMap[i - k].getStatus(j) == HelixPositions::Start_AND_End) ;
+                }
+            }
 
-    for(std::size_t i {0}; i < static_cast<std::size_t>(secondaryStructureTypes::Count); ++i ){
-        for(std::size_t j {0}; j < HBondsMap.front().size(); ++j){
-            if( getStatus( j, static_cast<secondaryStructureTypes>(i) ) ){
-                SecondaryStructuresStringLine[j] = secondaryStructureTypeNames[static_cast<secondaryStructureTypes>(i)] ;
+            if (isTurn){
+                SecondaryStructuresStatusMap[i].setStatus(secondaryStructureTypes::Turn);
+            }
+            else if (SecondaryStructuresStatusMap[i].getStatus(secondaryStructureTypes::Bend)){
+                SecondaryStructuresStatusMap[i].setStatus(secondaryStructureTypes::Bend);
             }
         }
-    };
-
-    /*Add breaks*/
-
-    std::size_t linefactor{1};
-
-    for(std::size_t i {0}; i + 1 < HBondsMap.front().size(); ++i ){
-        if( getStatus( i, secondaryStructureTypes::Break) ){
-            SecondaryStructuresStringLine.insert(SecondaryStructuresStringLine.begin() + i + linefactor, secondaryStructureTypeNames[secondaryStructureTypes::Break]);
-            ++linefactor;        }
     }
-    return SecondaryStructuresStringLine;
+
 }
 
 std::string secondaryStructures::patternSearch(const std::vector<std::vector<bool>> &HBondsMap){

diff --git a/src/dssptools.h b/src/dssptools.h
index 960d00ecdd703350fd79284d6d0cc1f9b66baa69..aae4fdd4f6eece4efe0a64c8e6a43722b469fdb6 100644 (file)
--- a/src/dssptools.h
+++ b/src/dssptools.h
@@ -140,7 +140,7 @@ enum class bridgeTypes : std::size_t {
 class secondaryStructures{
 public:
     secondaryStructures();
-    void                    initiateSearch(const std::vector<std::vector<bool>> &HBondsMap);
+    void                    initiateSearch(const std::vector<std::vector<bool>> &HBondsMap, const bool PiHelixesPreference);
     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);
@@ -153,7 +153,7 @@ public:
         void                                setStatus(const HelixPositions helixPosition, const turnsTypes turn);
         bool                                getStatus(const secondaryStructureTypes secondaryStructureTypeName) const;
         HelixPositions                      getStatus(const turnsTypes turn) const;
-        secondaryStructureTypes             getStatus(const std::size_t resi) const;
+        secondaryStructureTypes             getStatus() const;
     private:
         std::array<bool, static_cast<std::size_t>(secondaryStructureTypes::Count)>  SecondaryStructuresStatusArray{ 0, 0, 0, 0, 0, 0, 0 };
         secondaryStructureTypes                                        SSData {secondaryStructureTypes::Loop};
@@ -172,13 +172,11 @@ private:
     };
 //    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<turnsTypes> turns{ turnsTypes::Turn_4, turnsTypes::Turn_3, turnsTypes::Turn_5 };
-    secondaryStructureTypes         returnSpecificSS(turnsTypes turn);
     const std::vector<bridgeTypes> Bridges{ bridgeTypes::Bridge, bridgeTypes::AntiBridge};
     std::string     SecondaryStructuresStringLine;
     const std::size_t     strideFactor{3};
 
-    bool            NoChainBreaksBetween(const std::size_t ResiStart, const std::size_t ResiEnd), isLoop(const std::size_t resiIndex) const, checkHelixEmptiness(const std::size_t resiIndex, const secondaryStructureTypes HelixType, const bool PiHelixPreference);
+    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);
 };