src.serena.utilities.weighted_structures

  1from dataclasses import dataclass
  2from typing import List
  3import collections
  4
  5from serena.utilities.ensemble_structures import Sara2StructureList, Sara2SecondaryStructure
  6from serena.utilities.ensemble_groups import MultipleEnsembleGroups, SingleEnsembleGroup
  7
  8@dataclass
  9class WeightedEnsembleResult():
 10    """
 11    Class that holds the resuls from weighted structurs as sara2SecondaryStructures
 12    """
 13    structs: List[Sara2SecondaryStructure]
 14
 15@dataclass
 16class WeightedNucCounts():
 17    """
 18    Class for the weighted structure counts
 19    """
 20    num_bound:float = -1
 21    num_unbound:float = -1
 22    num_both:float = -1
 23    num_dot:float = -1
 24    num_nucs:int = -1
 25
 26@dataclass
 27class WeightedComparisonResult():
 28    """
 29    Holds the results from weighting the structures
 30    """
 31    comp_struct: str = ''
 32    unbound_mfe_struct:Sara2SecondaryStructure = Sara2SecondaryStructure()
 33    bound_mfe_struct: Sara2SecondaryStructure = Sara2SecondaryStructure()
 34    weighted_nuc_counts:WeightedNucCounts = WeightedNucCounts()
 35
 36class WeightedStructure():
 37
 38    def __init__(self) -> None:
 39        pass
 40
 41    def make_weighted_struct(self, structure_list: Sara2StructureList)->Sara2SecondaryStructure:
 42        is_bond_value: int = 2
 43        not_bond_value: int = -1
 44
 45        nuc_poistion_values: List[int] = []
 46        nuc_pairs_comp_list: List[List[str]] = []
 47        good_nucs_each_pos: List[bool] = []
 48
 49        struct_count: int = structure_list.num_structures
 50
 51        for nucIndex in range(structure_list.nuc_count):
 52            nuc_poistion_values.append(0)
 53            pairs_list: List[str] = []            
 54            nuc_pairs_comp_list.append(pairs_list)
 55            #good_nucs_each_pos.append(False)
 56
 57        for struct in structure_list.sara_stuctures:
 58            for nucIndex in range(structure_list.nuc_count):
 59                nuc_bond_type:str = struct.structure[nucIndex]
 60                nuc_pairs_comp_list[nucIndex].append(nuc_bond_type)
 61                adder: int = 0
 62                if nuc_bond_type == '.':
 63                    adder = not_bond_value
 64                else:
 65                    adder = is_bond_value
 66                nuc_poistion_values[nucIndex] = nuc_poistion_values[nucIndex] + adder
 67
 68        #now record if the nuc position has a weghted bond
 69        for nucIndex in range(structure_list.nuc_count):
 70            is_weighted_bond=False
 71            if nuc_poistion_values[nucIndex] > struct_count:
 72                is_weighted_bond = True
 73            good_nucs_each_pos.append(is_weighted_bond)
 74
 75        weighted_structure:str = ''
 76        for nucIndex in range(structure_list.nuc_count):
 77            is_bonded = good_nucs_each_pos[nucIndex]
 78            new_counter: collections.Counter = collections.Counter(nuc_pairs_comp_list[nucIndex])
 79            most_common_char: str= '.'
 80            if is_bonded is True:
 81                #most_common_char = '|'
 82                new_char:str = new_counter.most_common(2)[0][0]
 83                length = len(new_counter.most_common(2))
 84                if new_char == '.' and length > 1:
 85                    #then get second most common
 86                    new_char = new_counter.most_common(2)[1][0]
 87                most_common_char = new_char
 88            weighted_structure = weighted_structure + most_common_char
 89
 90        weighted_structure: Sara2SecondaryStructure = Sara2SecondaryStructure(sequence=structure_list.sara_stuctures[0].sequence,
 91                                                                                structure=weighted_structure,)
 92
 93        return weighted_structure
 94
 95    def compair_weighted_structure(self, unbound_mfe_struct:Sara2SecondaryStructure, bound_mfe_struct:Sara2SecondaryStructure, weighted_result:Sara2SecondaryStructure, nuc_count:int):
 96        """
 97        Compaire the weighted structure against the folded and not-folded mfe's.
 98        If a element is present in the folded mfe then it gets a '-'
 99        if element is in unbound only then it gets a '|'.
100        The idea is that if you have a straight line in the list then it is very close to the
101        folded mfe and if it is not straight then it is more like the unbound mfe.
102        """
103        unbound:str = '|'
104        num_unbound:int = 0
105        bound:str = '-'
106        num_bound:int = 0
107        both:str = '+'
108        num_both:int = 0
109        dot:str = '.'
110        num_dot:int = 0
111        compared_struct:str = ''            
112
113        for nuc_index in range(nuc_count):
114            weighted_nuc:str = weighted_result.structure[nuc_index]
115            unbound_nuc:str = unbound_mfe_struct.structure[nuc_index]
116            bound_nuc: str = bound_mfe_struct.structure[nuc_index]
117
118            comp_nuc_symbol:str = ''
119
120            if weighted_nuc == bound_nuc and weighted_nuc != unbound_nuc:
121                comp_nuc_symbol = bound
122                num_bound += 1
123            elif weighted_nuc != bound_nuc and weighted_nuc == unbound_nuc:
124                comp_nuc_symbol = unbound
125                num_unbound += 1
126            elif weighted_nuc == bound_nuc and weighted_nuc == unbound_nuc:
127                comp_nuc_symbol = both
128                num_both += 1
129            else:
130                comp_nuc_symbol = dot
131                num_dot += 1
132
133            weighted_nuc_counts:WeightedNucCounts = WeightedNucCounts(num_unbound=num_unbound,
134                                                                        num_bound=num_bound,
135                                                                        num_both=num_both,
136                                                                        num_dot=num_dot,
137                                                                        num_nucs=nuc_count
138                                                                        )
139            compared_struct = compared_struct + comp_nuc_symbol
140
141            weighted_nuc_counts.num_nucs = nuc_count
142
143        compared_data: WeightedComparisonResult = WeightedComparisonResult(comp_struct=compared_struct,
144                                                                           unbound_mfe_struct=unbound_mfe_struct,
145                                                                           bound_mfe_struct=bound_mfe_struct,
146                                                                           weighted_nuc_counts=weighted_nuc_counts)    
147        return compared_data