Experimental get_sheets() function

src/atom.py

         #e = 1.602176634 * 10*math.exp(-19)
         # dimensionnal factor f
         f = 332
+        # partial charges
         q1 = 0.42
         q2 = 0.20
         # r, distance between O-N atoms, in angströms

src/dssp.py

     get_bends(pdb_file.residues)
     get_chirality(pdb_file.residues)
     bridges = get_bridges(pdb_file.residues)
-    get_ladders(bridges)
+    ladders = get_ladders(bridges)
+    get_sheets(ladders)

src/structure.py

                         
 class Bridge(Structure):
 
-    def __init__(self, bridge_type, res_num):
+    def __init__(self, bridge_type, res_num, res_partner):
         self.bridge_type = bridge_type
         self.res_num = res_num
+        self.res_partner = res_partner
         Structure.res = res_num
 
 class Helix(Structure):
         Structure.res = res_num
         
 def get_turns(residues):
+    # TODO : prevent redondency of overlapping turns
     turns = {}
     for i,res in enumerate(residues):
         for j in range(3,6):
         # finally add the strongest bridge at i and j pos
         if(strongest_bridge):
             bridges[strongest_bridge['ipos']] = (Bridge(strongest_bridge['btype'],
-                                  strongest_bridge['ipos']))
+                                                        strongest_bridge['ipos'],
+                                                        strongest_bridge['jpos']))
             bridges[strongest_bridge['jpos']] = (Bridge(strongest_bridge['btype'],
-                                  strongest_bridge['jpos']))
+                                                        strongest_bridge['jpos'],
+                                                        strongest_bridge['ipos']))
     if(len(bridges)>0):
         return(bridges)
     else:
     i = 1
     while i < len(bridges):
         k = 1
-        while (((i in bridges.keys()) and (i+k in bridges.keys())) and
-        (bridges[i].bridge_type == bridges[i+k].bridge_type)):
-            k+=1
+        if i in bridges.keys():
+            temp_bridges = [bridges[i]]
+            while ((i+k in bridges.keys()) and
+                   (bridges[i].bridge_type == bridges[i+k].bridge_type)):
+                temp_bridges.append(bridges[i+k])
+                k+=1
         if k>1:
             ladders[bridges[i].res_num] = k-1
             print("ladder", bridges[i].res_num, bridges[i+k-1].res_num)
             ladders[bridges[i].res_num] = {'start':bridges[i].res_num,
-                                           'end':bridges[i+k-1].res_num}
+                                           'end':bridges[i+k-1].res_num,
+                                           'bridges':temp_bridges}
             i+=k-1
         else:
             i+=1
-     return ladders
+    return ladders
  
+def get_sheets(ladders):
+    """
+    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.
+    """
 
+    for ladder in ladders:
+        for bridge in ladders[ladder]['bridges']:
+            for ladd2 in ladders:
+                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'])
                 
+
+def res_list(ladder):
+    # TODO : method in ladder class
+    l=[]
+    for i in range(ladder['start'], ladder['end']):
+        l.append(i)
+    return(l)
+                   
 def get_bends(residues):
     bends = {}
     for i in range(2,len(residues)-2):