Before go back to bridges and ladders methods

src/atom.py

         E = q1*q2*(1/r_ON + 1/r_CH - 1/r_OH - 1/r_CN)*f
         return(E)
 
-    def get_turns(self, residues, turns):
+    def get_turns(self, residues):
         """
         Get all the turns from a specific residue.
         """
+        turns = {}
         i = residues.index(self)
+        k = 0
         for j in range(3,6):
                 if(i+j<len(residues)):
                     if(self.h_bond(residues[i+j])<-0.5):
-                        print(j,"TURN", residues[i].resid, residues[i+j].resid)
-                        turns[i] = Turn(j,residues[i].resid)
+                        k = j
+        if k != 0:    
+            #print(k,"TURN", residues[i].resid, residues[i+k].resid)
+            return Turn(k,residues[i].resid)
 
+        return False
+    
     def get_bridges(self, residues):
         bridges = {}
         bridge = {}
         else:
             return(False)
 
-    def get_helix(self, residues, turns):
+    def get_helix(self, residues):
         """
         Return if there is an helix at a given residue,
         as well as its type.
         """
         i = residues.index(self)
         # if there are no turns or it is the first residue, skip
-        if not turns or i == 0:
+        if i == 0:
             return False
-        if (i <= len(residues)):
-            if(i in turns.keys() and i-1 in turns.keys()):
-                print(turns[i].turn_type,"- HELIX at", residues[i].resid)
-                return(turns[i].turn_type, residues[i].resid)
+        
+        if(self.get_turns(residues) and residues[i-1].get_turns(residues)):
+            print(self.get_turns(residues).turn_type,"- HELIX at", residues[i].resid)
+            return(self.get_turns(residues).turn_type, residues[i].resid)
+        return(False)
+
+    def get_helix2(self, residues):
+        """
+        Return if there is an helix at a given residue,
+        as well as its type.
+        """
+        i = residues.index(self)
+        # if there are no turns or it is the first residue, skip
+        if i == 0:
+            return False
+        
+        if(i in turns.keys() and i-1 in turns.keys()):
+            print(turns[i].turn_type,"- HELIX at", residues[i].resid)
+            return(turns[i].turn_type, residues[i].resid)
         return(False)
     
-    def get_ladders(self, residues, ladders):
+    def get_ladders(self, residues, ladders={}):
+        #ladders = {}
         i = residues.index(self)
         if i != 0:
             if self.get_bridges(residues):
                         ladders[i] = {'start':i-1,
                                       'end':i,
                                       'bridges':[consec_bridge, local_bridge]}
+        return ladders
+
+    def get_ladder(self, residues):
+        #ladders = {}
+        i = residues.index(self)
+        if i != 0:
+            if self.get_bridges(residues):
+                if (residues[i-1].get_bridges(residues)):
+                    local_bridge = self.get_bridges(residues)
+                    consec_bridge = residues[i-1].get_bridges(residues)
+                    if local_bridge.bridge_type == consec_bridge.bridge_type:
+                        #print("ladder", consec_bridge.res_num, local_bridge.res_num)
+                        ladder = {'start':consec_bridge.res_num,
+                                  'end':local_bridge.res_num,
+                                  'bridges':[consec_bridge, local_bridge]}
+                        return ladder
+        return False
+
+    def get_sheets(self, residues):
+        """
+        Bridges between ladders.
+        Check if 1 bridge between one ladder and one or more other ladders.
+        Iterate over all residues of one ladder and check if bridge with other residues
+        of the other ladders.
+        """
+        sheets = {}
+        sheet_start = residues.index(self)
+        j=sheet_start
+        k=2
+        if(self.get_ladder(residues)):
+            local_ladder = self.get_ladder(residues)
+            while j < len(residues)-2:
+                k = 2
+                while residues[j+k].get_ladder(residues):
+                    if(residues[j+k].get_bridges(residues)):
+                        j = j+k     
+                    k+=1
+                if(k>):
+                    last = j
+                j+=1
+                print(j)
+        if(k>2):                
+            sheet_end = last      
+                        
+            print("SHEET", sheet_start, sheet_end)       
+
+    def get_sheets2(self):
+        """
+        Bridges between ladders.
+        Check if 1 bridge between one ladder and one or more other ladders.
+        Iterate over all residues of one ladder and check if bridge with other residues
+        of the other ladders.
+        """
+        sheets = {}
+        for ladder in ladders:
+            for ladd2 in ladders:
+                for bridge in ladders[ladder]['bridges']:
+                    if bridge.res_partner in res_list(ladders[ladd2]):
+                        print("ladder",ladders[ladder]['start'], ladders[ladder]['end'],"bridge",bridge.res_num, bridge.res_partner,
+                        "ladder 2",ladders[ladd2]['start'], ladders[ladd2]['end'])
+                #print("stop ladder 2")
+            print("stop ladder 1")            
+
+            
 
     def get_ladders2(self, bridges, residues):
         ladders = {}

src/dssp.py

     #print(residues[2].atoms, residues[0].resid, residues[1].resid)
     print(get_TCO(residues[2],residues[3]))
 
-    turns = {}
+    #turns = {}
     ladders = {}
     for i,res in enumerate(residues):
         # res.get_turns(residues, turns)
-        # res.get_helix(residues, turns)
-        res.get_bridges(residues)
+        #res.get_helix(residues)
+        #res.get_bridges(residues)
         res.get_ladders(residues, ladders)
-        
- 
+        #res.get_sheets(residues)