src.serena.local_minima_variation

This file is the entry point to get lmv results for an ensemble

  1#pylint: disable=line-too-long, too-many-arguments, too-many-locals
  2"""
  3This file is the entry point to get lmv results for an ensemble
  4"""
  5
  6from typing import List
  7
  8from serena.utilities.ensemble_structures import Sara2SecondaryStructure, Sara2StructureList
  9from serena.utilities.ensemble_variation import EV, EVResult, EVToken
 10from serena.utilities.ensemble_groups import MultipleEnsembleGroups, EnsembleSwitchStateMFEStructs
 11from serena.utilities.thread_manager import EV_ThreadProcessor
 12from serena.utilities.weighted_structures import WeightedEnsembleResult, WeightedStructure
 13from serena.utilities.local_minima_variation import LocalMinimaVariation
 14from serena.interfaces.nupack4_0_28_wsl2_interface import MaterialParameter, NUPACK4Interface
 15
 16class RunLocalMinimaVariation(LocalMinimaVariation):
 17    """
 18    Class that acts as the entry point into LMV algorithm
 19    """
 20
 21    def get_relative_mutli_group_lmv(self, ensemble: MultipleEnsembleGroups)->EVResult:
 22        """
 23        Function for getting the lmv_r for a RNA sequence for provided MultipleEnsembleGroups object
 24        """
 25        ev_values:List[EV] = []
 26        ref_list:List[Sara2SecondaryStructure] = []
 27        #for group in ensemble.groups:
 28        #    ref_structure:Sara2SecondaryStructure = group.group.sara_stuctures[0]
 29        #    ev_result:EVResult = self.get_single_group_lmv(ensemble_group=group,
 30        #                                                reference_structure=ref_structure)
 31        #    ev_values.append(ev_result.ev_values[0])
 32        
 33        for group in ensemble.groups:
 34            ref_structure:Sara2SecondaryStructure = group.group.sara_stuctures[0]
 35            ref_list.append(ref_structure)
 36        
 37        result: EVResult = self.get_multi_group_lmv_list_ref(ensemble=ensemble,
 38                                          reference_list=ref_list)
 39        return result
 40
 41    def get_relative_multi_group_lmv_nupack(self, sequence:str, material_param:MaterialParameter, temp_c: int, kcal_span_from_mfe:int, kcal_unit_increments: float = 1)->EVResult:
 42        """
 43        Function for getting the lmv_r for a RNA sequence folded in silico by NUPACK4
 44        """
 45        nupack4:NUPACK4Interface = NUPACK4Interface()
 46        structs:Sara2StructureList = nupack4.get_subopt_energy_gap(material_param=material_param,
 47                                                                    temp_C=temp_c,
 48                                                                    sequence_string=sequence,
 49                                                                    energy_delta_from_MFE=kcal_span_from_mfe,
 50                                                                    )
 51        switch_states:EnsembleSwitchStateMFEStructs = EnsembleSwitchStateMFEStructs(non_switch_mfe_struct=structs.sara_stuctures[0])
 52        ensemble:MultipleEnsembleGroups = nupack4.load_nupack_subopt_as_ensemble(span_structures=structs,
 53                                                                                    kcal_span_from_mfe=kcal_span_from_mfe,
 54                                                                                    Kcal_unit_increments=kcal_unit_increments,
 55                                                                                    switch_state=switch_states
 56                                                                                    )
 57        result:EVResult = self.get_relative_mutli_group_lmv(ensemble=ensemble)
 58        return result
 59
 60    def get_comp_multi_group_lmv(self, ensemble: MultipleEnsembleGroups, weighted_structures: WeightedEnsembleResult)->EVResult:
 61        """
 62        Function for getting the lmv_c for a RNA sequence for provided MultipleEnsembleGroups object and WeightedEnembleResult
 63        """
 64        ev_values:List[EV] = []
 65        ref_list:List[Sara2SecondaryStructure] = []
 66        #for group_index in range(len(ensemble.groups)):#pylint: disable=consider-using-enumerate
 67        #
 68        #    ref_structure:Sara2SecondaryStructure = weighted_structures.structs[group_index]
 69        #    ev_result:EVResult = self.get_single_group_lmv(ensemble_group=ensemble.groups[group_index],
 70        #                                                reference_structure=ref_structure)
 71        #    ev_values.append(ev_result.ev_values[0])
 72        
 73        for group_index in range(len(ensemble.groups)):#pylint: disable=consider-using-enumerate
 74
 75            ref_structure:Sara2SecondaryStructure = weighted_structures.structs[group_index]
 76            ref_list.append(ref_structure)
 77        
 78        result: EVResult = self.get_multi_group_lmv_list_ref(ensemble=ensemble,
 79                                                             reference_list=ref_list)
 80        #result: EVResult = EVResult(ev_values=ev_values)
 81        return result
 82
 83    def get_comp_multi_group_lmv_nupack(self, sequence:str, material_param:MaterialParameter, temp_c: int, kcal_span_from_mfe:int, kcal_unit_increments: float = 1)->EVResult:
 84        """
 85        Function for getting the lmv_c for a RNA sequence folded in silico by NUPACK4
 86        """
 87        nupack4:NUPACK4Interface = NUPACK4Interface()
 88        nupack_structs:Sara2StructureList = nupack4.get_subopt_energy_gap(material_param=material_param,
 89                                                                    temp_C=temp_c,
 90                                                                    sequence_string=sequence,
 91                                                                    energy_delta_from_MFE=kcal_span_from_mfe,
 92                                                                    )
 93        switch_states:EnsembleSwitchStateMFEStructs = EnsembleSwitchStateMFEStructs(non_switch_mfe_struct=nupack_structs.sara_stuctures[0])
 94        ensemble:MultipleEnsembleGroups = nupack4.load_nupack_subopt_as_ensemble(span_structures=nupack_structs,
 95                                                                                    kcal_span_from_mfe=kcal_span_from_mfe,
 96                                                                                    Kcal_unit_increments=kcal_unit_increments,
 97                                                                                    switch_state=switch_states
 98                                                                                    )
 99        structs:List[Sara2SecondaryStructure] = []
100        #make weighted structures
101        for group in ensemble.groups:
102            weighted:WeightedStructure = WeightedStructure()
103            struct:Sara2SecondaryStructure = weighted.make_weighted_struct(structure_list=group.group)
104            structs.append(struct)
105
106        weighted_structures:WeightedEnsembleResult = WeightedEnsembleResult(structs=structs)
107        result:EVResult = self.get_comp_multi_group_lmv(ensemble=ensemble,
108                                                        weighted_structures=weighted_structures)
109        return result
110
111    def get_mfe_mult_group_lmv(self, ensemble: MultipleEnsembleGroups)->EVResult:
112        """
113        Function for getting the lmv_m for a RNA sequence for provided MultipleEnsembleGroups object
114        """
115        lmv_thread: EV_ThreadProcessor = EV_ThreadProcessor(stuctures=ensemble.raw_groups,
116                                                            comp_structure=ensemble.non_switch_state_structure)
117        result_thread_lmv:EVToken = lmv_thread.run_EV()
118        lmv_results: EVResult = result_thread_lmv.ev_results
119        return lmv_results
120
121    def get_mfe_multi_group_lmv_nupack(self, sequence:str, material_param:MaterialParameter, temp_c: int, kcal_span_from_mfe:int, kcal_unit_increments: float = 1)->EVResult:
122        """
123        Function for getting the lmv_m for a RNA sequence folded in silico by NUPACK4
124        """
125        nupack4:NUPACK4Interface = NUPACK4Interface()
126        structs:Sara2StructureList = nupack4.get_subopt_energy_gap(material_param=material_param,
127                                                                    temp_C=temp_c,
128                                                                    sequence_string=sequence,
129                                                                    energy_delta_from_MFE=kcal_span_from_mfe,
130                                                                    )
131        switch_states:EnsembleSwitchStateMFEStructs = EnsembleSwitchStateMFEStructs(non_switch_mfe_struct=structs.sara_stuctures[0])
132        ensemble:MultipleEnsembleGroups = nupack4.load_nupack_subopt_as_ensemble(span_structures=structs,
133                                                                                    kcal_span_from_mfe=kcal_span_from_mfe,
134                                                                                    Kcal_unit_increments=kcal_unit_increments,
135                                                                                    switch_state=switch_states
136                                                                                    )
137        results:EVResult = self.get_mfe_mult_group_lmv(ensemble=ensemble)
138        return results
139
140    def get_folded_group_lmv(self, ensemble: MultipleEnsembleGroups, folded_structure:Sara2SecondaryStructure)->EVResult:
141        """
142        Function for getting the lmv_f for a RNA sequence for provided MultipleEnsembleGroups object 
143        and folded structure as Sara2SecondaryStructure
144        """
145        lmv_thread: EV_ThreadProcessor = EV_ThreadProcessor(stuctures=ensemble.raw_groups,
146                                                            comp_structure=folded_structure)
147        result_thread_lmv:EVToken = lmv_thread.run_EV()
148        lmv_results: EVResult = result_thread_lmv.ev_results
149        return lmv_results
150
151    def get_folded_multi_group_lmv_nupack(self, ensemble_sequence:str, material_param:MaterialParameter, temp_c: int, kcal_span_from_mfe:int, folded_structure:Sara2SecondaryStructure, kcal_unit_increments: float = 1)->EVResult:
152        """
153        Function for getting the lmv_f for a RNA sequence folded in silico by NUPACK4
154        """
155        nupack4:NUPACK4Interface = NUPACK4Interface()
156        structs:Sara2StructureList = nupack4.get_subopt_energy_gap(material_param=material_param,
157                                                                    temp_C=temp_c,
158                                                                    sequence_string=ensemble_sequence,
159                                                                    energy_delta_from_MFE=kcal_span_from_mfe,
160                                                                    )
161        switch_states:EnsembleSwitchStateMFEStructs = EnsembleSwitchStateMFEStructs(non_switch_mfe_struct=structs.sara_stuctures[0],
162                                                                                    switched_mfe_struct=folded_structure)
163        ensemble:MultipleEnsembleGroups = nupack4.load_nupack_subopt_as_ensemble(span_structures=structs,
164                                                                                    kcal_span_from_mfe=kcal_span_from_mfe,
165                                                                                    Kcal_unit_increments=kcal_unit_increments,
166                                                                                    switch_state=switch_states
167                                                                                    )
168        result:EVResult = self.get_folded_group_lmv(ensemble=ensemble,
169                                                    folded_structure=folded_structure)
170        return result
class RunLocalMinimaVariation(serena.utilities.local_minima_variation.LocalMinimaVariation): 
 17class RunLocalMinimaVariation(LocalMinimaVariation):
 18    """
 19    Class that acts as the entry point into LMV algorithm
 20    """
 21
 22    def get_relative_mutli_group_lmv(self, ensemble: MultipleEnsembleGroups)->EVResult:
 23        """
 24        Function for getting the lmv_r for a RNA sequence for provided MultipleEnsembleGroups object
 25        """
 26        ev_values:List[EV] = []
 27        ref_list:List[Sara2SecondaryStructure] = []
 28        #for group in ensemble.groups:
 29        #    ref_structure:Sara2SecondaryStructure = group.group.sara_stuctures[0]
 30        #    ev_result:EVResult = self.get_single_group_lmv(ensemble_group=group,
 31        #                                                reference_structure=ref_structure)
 32        #    ev_values.append(ev_result.ev_values[0])
 33        
 34        for group in ensemble.groups:
 35            ref_structure:Sara2SecondaryStructure = group.group.sara_stuctures[0]
 36            ref_list.append(ref_structure)
 37        
 38        result: EVResult = self.get_multi_group_lmv_list_ref(ensemble=ensemble,
 39                                          reference_list=ref_list)
 40        return result
 41
 42    def get_relative_multi_group_lmv_nupack(self, sequence:str, material_param:MaterialParameter, temp_c: int, kcal_span_from_mfe:int, kcal_unit_increments: float = 1)->EVResult:
 43        """
 44        Function for getting the lmv_r for a RNA sequence folded in silico by NUPACK4
 45        """
 46        nupack4:NUPACK4Interface = NUPACK4Interface()
 47        structs:Sara2StructureList = nupack4.get_subopt_energy_gap(material_param=material_param,
 48                                                                    temp_C=temp_c,
 49                                                                    sequence_string=sequence,
 50                                                                    energy_delta_from_MFE=kcal_span_from_mfe,
 51                                                                    )
 52        switch_states:EnsembleSwitchStateMFEStructs = EnsembleSwitchStateMFEStructs(non_switch_mfe_struct=structs.sara_stuctures[0])
 53        ensemble:MultipleEnsembleGroups = nupack4.load_nupack_subopt_as_ensemble(span_structures=structs,
 54                                                                                    kcal_span_from_mfe=kcal_span_from_mfe,
 55                                                                                    Kcal_unit_increments=kcal_unit_increments,
 56                                                                                    switch_state=switch_states
 57                                                                                    )
 58        result:EVResult = self.get_relative_mutli_group_lmv(ensemble=ensemble)
 59        return result
 60
 61    def get_comp_multi_group_lmv(self, ensemble: MultipleEnsembleGroups, weighted_structures: WeightedEnsembleResult)->EVResult:
 62        """
 63        Function for getting the lmv_c for a RNA sequence for provided MultipleEnsembleGroups object and WeightedEnembleResult
 64        """
 65        ev_values:List[EV] = []
 66        ref_list:List[Sara2SecondaryStructure] = []
 67        #for group_index in range(len(ensemble.groups)):#pylint: disable=consider-using-enumerate
 68        #
 69        #    ref_structure:Sara2SecondaryStructure = weighted_structures.structs[group_index]
 70        #    ev_result:EVResult = self.get_single_group_lmv(ensemble_group=ensemble.groups[group_index],
 71        #                                                reference_structure=ref_structure)
 72        #    ev_values.append(ev_result.ev_values[0])
 73        
 74        for group_index in range(len(ensemble.groups)):#pylint: disable=consider-using-enumerate
 75
 76            ref_structure:Sara2SecondaryStructure = weighted_structures.structs[group_index]
 77            ref_list.append(ref_structure)
 78        
 79        result: EVResult = self.get_multi_group_lmv_list_ref(ensemble=ensemble,
 80                                                             reference_list=ref_list)
 81        #result: EVResult = EVResult(ev_values=ev_values)
 82        return result
 83
 84    def get_comp_multi_group_lmv_nupack(self, sequence:str, material_param:MaterialParameter, temp_c: int, kcal_span_from_mfe:int, kcal_unit_increments: float = 1)->EVResult:
 85        """
 86        Function for getting the lmv_c for a RNA sequence folded in silico by NUPACK4
 87        """
 88        nupack4:NUPACK4Interface = NUPACK4Interface()
 89        nupack_structs:Sara2StructureList = nupack4.get_subopt_energy_gap(material_param=material_param,
 90                                                                    temp_C=temp_c,
 91                                                                    sequence_string=sequence,
 92                                                                    energy_delta_from_MFE=kcal_span_from_mfe,
 93                                                                    )
 94        switch_states:EnsembleSwitchStateMFEStructs = EnsembleSwitchStateMFEStructs(non_switch_mfe_struct=nupack_structs.sara_stuctures[0])
 95        ensemble:MultipleEnsembleGroups = nupack4.load_nupack_subopt_as_ensemble(span_structures=nupack_structs,
 96                                                                                    kcal_span_from_mfe=kcal_span_from_mfe,
 97                                                                                    Kcal_unit_increments=kcal_unit_increments,
 98                                                                                    switch_state=switch_states
 99                                                                                    )
100        structs:List[Sara2SecondaryStructure] = []
101        #make weighted structures
102        for group in ensemble.groups:
103            weighted:WeightedStructure = WeightedStructure()
104            struct:Sara2SecondaryStructure = weighted.make_weighted_struct(structure_list=group.group)
105            structs.append(struct)
106
107        weighted_structures:WeightedEnsembleResult = WeightedEnsembleResult(structs=structs)
108        result:EVResult = self.get_comp_multi_group_lmv(ensemble=ensemble,
109                                                        weighted_structures=weighted_structures)
110        return result
111
112    def get_mfe_mult_group_lmv(self, ensemble: MultipleEnsembleGroups)->EVResult:
113        """
114        Function for getting the lmv_m for a RNA sequence for provided MultipleEnsembleGroups object
115        """
116        lmv_thread: EV_ThreadProcessor = EV_ThreadProcessor(stuctures=ensemble.raw_groups,
117                                                            comp_structure=ensemble.non_switch_state_structure)
118        result_thread_lmv:EVToken = lmv_thread.run_EV()
119        lmv_results: EVResult = result_thread_lmv.ev_results
120        return lmv_results
121
122    def get_mfe_multi_group_lmv_nupack(self, sequence:str, material_param:MaterialParameter, temp_c: int, kcal_span_from_mfe:int, kcal_unit_increments: float = 1)->EVResult:
123        """
124        Function for getting the lmv_m for a RNA sequence folded in silico by NUPACK4
125        """
126        nupack4:NUPACK4Interface = NUPACK4Interface()
127        structs:Sara2StructureList = nupack4.get_subopt_energy_gap(material_param=material_param,
128                                                                    temp_C=temp_c,
129                                                                    sequence_string=sequence,
130                                                                    energy_delta_from_MFE=kcal_span_from_mfe,
131                                                                    )
132        switch_states:EnsembleSwitchStateMFEStructs = EnsembleSwitchStateMFEStructs(non_switch_mfe_struct=structs.sara_stuctures[0])
133        ensemble:MultipleEnsembleGroups = nupack4.load_nupack_subopt_as_ensemble(span_structures=structs,
134                                                                                    kcal_span_from_mfe=kcal_span_from_mfe,
135                                                                                    Kcal_unit_increments=kcal_unit_increments,
136                                                                                    switch_state=switch_states
137                                                                                    )
138        results:EVResult = self.get_mfe_mult_group_lmv(ensemble=ensemble)
139        return results
140
141    def get_folded_group_lmv(self, ensemble: MultipleEnsembleGroups, folded_structure:Sara2SecondaryStructure)->EVResult:
142        """
143        Function for getting the lmv_f for a RNA sequence for provided MultipleEnsembleGroups object 
144        and folded structure as Sara2SecondaryStructure
145        """
146        lmv_thread: EV_ThreadProcessor = EV_ThreadProcessor(stuctures=ensemble.raw_groups,
147                                                            comp_structure=folded_structure)
148        result_thread_lmv:EVToken = lmv_thread.run_EV()
149        lmv_results: EVResult = result_thread_lmv.ev_results
150        return lmv_results
151
152    def get_folded_multi_group_lmv_nupack(self, ensemble_sequence:str, material_param:MaterialParameter, temp_c: int, kcal_span_from_mfe:int, folded_structure:Sara2SecondaryStructure, kcal_unit_increments: float = 1)->EVResult:
153        """
154        Function for getting the lmv_f for a RNA sequence folded in silico by NUPACK4
155        """
156        nupack4:NUPACK4Interface = NUPACK4Interface()
157        structs:Sara2StructureList = nupack4.get_subopt_energy_gap(material_param=material_param,
158                                                                    temp_C=temp_c,
159                                                                    sequence_string=ensemble_sequence,
160                                                                    energy_delta_from_MFE=kcal_span_from_mfe,
161                                                                    )
162        switch_states:EnsembleSwitchStateMFEStructs = EnsembleSwitchStateMFEStructs(non_switch_mfe_struct=structs.sara_stuctures[0],
163                                                                                    switched_mfe_struct=folded_structure)
164        ensemble:MultipleEnsembleGroups = nupack4.load_nupack_subopt_as_ensemble(span_structures=structs,
165                                                                                    kcal_span_from_mfe=kcal_span_from_mfe,
166                                                                                    Kcal_unit_increments=kcal_unit_increments,
167                                                                                    switch_state=switch_states
168                                                                                    )
169        result:EVResult = self.get_folded_group_lmv(ensemble=ensemble,
170                                                    folded_structure=folded_structure)
171        return result

Class that acts as the entry point into LMV algorithm

def get_relative_mutli_group_lmv( self, ensemble: serena.utilities.ensemble_groups.MultipleEnsembleGroups) -> serena.utilities.ensemble_variation.EVResult: 
22    def get_relative_mutli_group_lmv(self, ensemble: MultipleEnsembleGroups)->EVResult:
23        """
24        Function for getting the lmv_r for a RNA sequence for provided MultipleEnsembleGroups object
25        """
26        ev_values:List[EV] = []
27        ref_list:List[Sara2SecondaryStructure] = []
28        #for group in ensemble.groups:
29        #    ref_structure:Sara2SecondaryStructure = group.group.sara_stuctures[0]
30        #    ev_result:EVResult = self.get_single_group_lmv(ensemble_group=group,
31        #                                                reference_structure=ref_structure)
32        #    ev_values.append(ev_result.ev_values[0])
33        
34        for group in ensemble.groups:
35            ref_structure:Sara2SecondaryStructure = group.group.sara_stuctures[0]
36            ref_list.append(ref_structure)
37        
38        result: EVResult = self.get_multi_group_lmv_list_ref(ensemble=ensemble,
39                                          reference_list=ref_list)
40        return result

Function for getting the lmv_r for a RNA sequence for provided MultipleEnsembleGroups object

def get_relative_multi_group_lmv_nupack( self, sequence: str, material_param: serena.interfaces.nupack4_0_28_wsl2_interface.MaterialParameter, temp_c: int, kcal_span_from_mfe: int, kcal_unit_increments: float = 1) -> serena.utilities.ensemble_variation.EVResult: 
42    def get_relative_multi_group_lmv_nupack(self, sequence:str, material_param:MaterialParameter, temp_c: int, kcal_span_from_mfe:int, kcal_unit_increments: float = 1)->EVResult:
43        """
44        Function for getting the lmv_r for a RNA sequence folded in silico by NUPACK4
45        """
46        nupack4:NUPACK4Interface = NUPACK4Interface()
47        structs:Sara2StructureList = nupack4.get_subopt_energy_gap(material_param=material_param,
48                                                                    temp_C=temp_c,
49                                                                    sequence_string=sequence,
50                                                                    energy_delta_from_MFE=kcal_span_from_mfe,
51                                                                    )
52        switch_states:EnsembleSwitchStateMFEStructs = EnsembleSwitchStateMFEStructs(non_switch_mfe_struct=structs.sara_stuctures[0])
53        ensemble:MultipleEnsembleGroups = nupack4.load_nupack_subopt_as_ensemble(span_structures=structs,
54                                                                                    kcal_span_from_mfe=kcal_span_from_mfe,
55                                                                                    Kcal_unit_increments=kcal_unit_increments,
56                                                                                    switch_state=switch_states
57                                                                                    )
58        result:EVResult = self.get_relative_mutli_group_lmv(ensemble=ensemble)
59        return result

Function for getting the lmv_r for a RNA sequence folded in silico by NUPACK4

def get_comp_multi_group_lmv( self, ensemble: serena.utilities.ensemble_groups.MultipleEnsembleGroups, weighted_structures: serena.utilities.weighted_structures.WeightedEnsembleResult) -> serena.utilities.ensemble_variation.EVResult: 
61    def get_comp_multi_group_lmv(self, ensemble: MultipleEnsembleGroups, weighted_structures: WeightedEnsembleResult)->EVResult:
62        """
63        Function for getting the lmv_c for a RNA sequence for provided MultipleEnsembleGroups object and WeightedEnembleResult
64        """
65        ev_values:List[EV] = []
66        ref_list:List[Sara2SecondaryStructure] = []
67        #for group_index in range(len(ensemble.groups)):#pylint: disable=consider-using-enumerate
68        #
69        #    ref_structure:Sara2SecondaryStructure = weighted_structures.structs[group_index]
70        #    ev_result:EVResult = self.get_single_group_lmv(ensemble_group=ensemble.groups[group_index],
71        #                                                reference_structure=ref_structure)
72        #    ev_values.append(ev_result.ev_values[0])
73        
74        for group_index in range(len(ensemble.groups)):#pylint: disable=consider-using-enumerate
75
76            ref_structure:Sara2SecondaryStructure = weighted_structures.structs[group_index]
77            ref_list.append(ref_structure)
78        
79        result: EVResult = self.get_multi_group_lmv_list_ref(ensemble=ensemble,
80                                                             reference_list=ref_list)
81        #result: EVResult = EVResult(ev_values=ev_values)
82        return result

Function for getting the lmv_c for a RNA sequence for provided MultipleEnsembleGroups object and WeightedEnembleResult

def get_comp_multi_group_lmv_nupack( self, sequence: str, material_param: serena.interfaces.nupack4_0_28_wsl2_interface.MaterialParameter, temp_c: int, kcal_span_from_mfe: int, kcal_unit_increments: float = 1) -> serena.utilities.ensemble_variation.EVResult: 
 84    def get_comp_multi_group_lmv_nupack(self, sequence:str, material_param:MaterialParameter, temp_c: int, kcal_span_from_mfe:int, kcal_unit_increments: float = 1)->EVResult:
 85        """
 86        Function for getting the lmv_c for a RNA sequence folded in silico by NUPACK4
 87        """
 88        nupack4:NUPACK4Interface = NUPACK4Interface()
 89        nupack_structs:Sara2StructureList = nupack4.get_subopt_energy_gap(material_param=material_param,
 90                                                                    temp_C=temp_c,
 91                                                                    sequence_string=sequence,
 92                                                                    energy_delta_from_MFE=kcal_span_from_mfe,
 93                                                                    )
 94        switch_states:EnsembleSwitchStateMFEStructs = EnsembleSwitchStateMFEStructs(non_switch_mfe_struct=nupack_structs.sara_stuctures[0])
 95        ensemble:MultipleEnsembleGroups = nupack4.load_nupack_subopt_as_ensemble(span_structures=nupack_structs,
 96                                                                                    kcal_span_from_mfe=kcal_span_from_mfe,
 97                                                                                    Kcal_unit_increments=kcal_unit_increments,
 98                                                                                    switch_state=switch_states
 99                                                                                    )
100        structs:List[Sara2SecondaryStructure] = []
101        #make weighted structures
102        for group in ensemble.groups:
103            weighted:WeightedStructure = WeightedStructure()
104            struct:Sara2SecondaryStructure = weighted.make_weighted_struct(structure_list=group.group)
105            structs.append(struct)
106
107        weighted_structures:WeightedEnsembleResult = WeightedEnsembleResult(structs=structs)
108        result:EVResult = self.get_comp_multi_group_lmv(ensemble=ensemble,
109                                                        weighted_structures=weighted_structures)
110        return result

Function for getting the lmv_c for a RNA sequence folded in silico by NUPACK4

def get_mfe_mult_group_lmv( self, ensemble: serena.utilities.ensemble_groups.MultipleEnsembleGroups) -> serena.utilities.ensemble_variation.EVResult: 
112    def get_mfe_mult_group_lmv(self, ensemble: MultipleEnsembleGroups)->EVResult:
113        """
114        Function for getting the lmv_m for a RNA sequence for provided MultipleEnsembleGroups object
115        """
116        lmv_thread: EV_ThreadProcessor = EV_ThreadProcessor(stuctures=ensemble.raw_groups,
117                                                            comp_structure=ensemble.non_switch_state_structure)
118        result_thread_lmv:EVToken = lmv_thread.run_EV()
119        lmv_results: EVResult = result_thread_lmv.ev_results
120        return lmv_results

Function for getting the lmv_m for a RNA sequence for provided MultipleEnsembleGroups object

def get_mfe_multi_group_lmv_nupack( self, sequence: str, material_param: serena.interfaces.nupack4_0_28_wsl2_interface.MaterialParameter, temp_c: int, kcal_span_from_mfe: int, kcal_unit_increments: float = 1) -> serena.utilities.ensemble_variation.EVResult: 
122    def get_mfe_multi_group_lmv_nupack(self, sequence:str, material_param:MaterialParameter, temp_c: int, kcal_span_from_mfe:int, kcal_unit_increments: float = 1)->EVResult:
123        """
124        Function for getting the lmv_m for a RNA sequence folded in silico by NUPACK4
125        """
126        nupack4:NUPACK4Interface = NUPACK4Interface()
127        structs:Sara2StructureList = nupack4.get_subopt_energy_gap(material_param=material_param,
128                                                                    temp_C=temp_c,
129                                                                    sequence_string=sequence,
130                                                                    energy_delta_from_MFE=kcal_span_from_mfe,
131                                                                    )
132        switch_states:EnsembleSwitchStateMFEStructs = EnsembleSwitchStateMFEStructs(non_switch_mfe_struct=structs.sara_stuctures[0])
133        ensemble:MultipleEnsembleGroups = nupack4.load_nupack_subopt_as_ensemble(span_structures=structs,
134                                                                                    kcal_span_from_mfe=kcal_span_from_mfe,
135                                                                                    Kcal_unit_increments=kcal_unit_increments,
136                                                                                    switch_state=switch_states
137                                                                                    )
138        results:EVResult = self.get_mfe_mult_group_lmv(ensemble=ensemble)
139        return results

Function for getting the lmv_m for a RNA sequence folded in silico by NUPACK4

def get_folded_group_lmv( self, ensemble: serena.utilities.ensemble_groups.MultipleEnsembleGroups, folded_structure: serena.utilities.ensemble_structures.Sara2SecondaryStructure) -> serena.utilities.ensemble_variation.EVResult: 
141    def get_folded_group_lmv(self, ensemble: MultipleEnsembleGroups, folded_structure:Sara2SecondaryStructure)->EVResult:
142        """
143        Function for getting the lmv_f for a RNA sequence for provided MultipleEnsembleGroups object 
144        and folded structure as Sara2SecondaryStructure
145        """
146        lmv_thread: EV_ThreadProcessor = EV_ThreadProcessor(stuctures=ensemble.raw_groups,
147                                                            comp_structure=folded_structure)
148        result_thread_lmv:EVToken = lmv_thread.run_EV()
149        lmv_results: EVResult = result_thread_lmv.ev_results
150        return lmv_results

Function for getting the lmv_f for a RNA sequence for provided MultipleEnsembleGroups object and folded structure as Sara2SecondaryStructure

def get_folded_multi_group_lmv_nupack( self, ensemble_sequence: str, material_param: serena.interfaces.nupack4_0_28_wsl2_interface.MaterialParameter, temp_c: int, kcal_span_from_mfe: int, folded_structure: serena.utilities.ensemble_structures.Sara2SecondaryStructure, kcal_unit_increments: float = 1) -> serena.utilities.ensemble_variation.EVResult: 
152    def get_folded_multi_group_lmv_nupack(self, ensemble_sequence:str, material_param:MaterialParameter, temp_c: int, kcal_span_from_mfe:int, folded_structure:Sara2SecondaryStructure, kcal_unit_increments: float = 1)->EVResult:
153        """
154        Function for getting the lmv_f for a RNA sequence folded in silico by NUPACK4
155        """
156        nupack4:NUPACK4Interface = NUPACK4Interface()
157        structs:Sara2StructureList = nupack4.get_subopt_energy_gap(material_param=material_param,
158                                                                    temp_C=temp_c,
159                                                                    sequence_string=ensemble_sequence,
160                                                                    energy_delta_from_MFE=kcal_span_from_mfe,
161                                                                    )
162        switch_states:EnsembleSwitchStateMFEStructs = EnsembleSwitchStateMFEStructs(non_switch_mfe_struct=structs.sara_stuctures[0],
163                                                                                    switched_mfe_struct=folded_structure)
164        ensemble:MultipleEnsembleGroups = nupack4.load_nupack_subopt_as_ensemble(span_structures=structs,
165                                                                                    kcal_span_from_mfe=kcal_span_from_mfe,
166                                                                                    Kcal_unit_increments=kcal_unit_increments,
167                                                                                    switch_state=switch_states
168                                                                                    )
169        result:EVResult = self.get_folded_group_lmv(ensemble=ensemble,
170                                                    folded_structure=folded_structure)
171        return result

Function for getting the lmv_f for a RNA sequence folded in silico by NUPACK4

Inherited Members
serena.utilities.local_minima_variation.LocalMinimaVariation
get_multi_group_lmv
get_single_group_lmv