def re_evaluate_pk_with_IB(pk_dic_ib, INIT, PENALTY):
""" Function: re_evaluate_pk_with_IB()
Purpose: Calculate pseudoknot free energies under energy model LongPK
where one of the stems is interrupted. Take into account
recursive structure elements which can occur in loops L1 and L3.
Input: Dictionary with pseudoknots where one of the stems is
interrupted.
Return: Dictionary with pseudoknots and associated free energy.
"""
for pk_stem, values in pk_dic_ib.items():
if values[1] or values[2] or values[3]:
list1 = values[1]
list2 = values[2]
list3 = values[3]
l1 = values[0][1]
l2 = values[0][2]
l3 = values[0][3]
entropy_l1, energy_l1, entropy_l2, energy_l2, entropy_l3, energy_l3 = 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
energy = values[0][4] # Store stem energies for S1 and S2
# Calculate effective loop lengths
if list1:
energy_l1 = sum([item[3] for item in list1]) # Add free energies
effective_l1 = functions.effective_length(list1, l1) # Calculate effective loop length
else:
effective_l1 = l1
if list2:
energy_l2 = sum([item[3] for item in list2]) # Add free energies
effective_l2 = functions.effective_length(list2, l2) # Calculate effective loop length
else:
effective_l2 = l2
if list3:
energy_l3 = sum([item[3] for item in list3]) # Add free energies
effective_l3 = functions.effective_length(list3, l3) # Calculate effective loop length
else:
effective_l3 = l3
looplength = effective_l1 + effective_l2 + effective_l3
entropy = PENALTY*(looplength)
pk_energy = energy + entropy + energy_l1 + energy_l2 + energy_l3 + INIT
# Only include internal loop energies if this leads to more stable pseudoknots
if pk_energy < values[0][0]:
pk_dic_ib[pk_stem] = pk_energy, values[1], values[2], values[3]
else:
energy = values[0][0]
pk_dic_ib[pk_stem] = energy, [], [], []
else:
energy = values[0][0]
pk_dic_ib[pk_stem] = energy, values[1], values[2], values[3]
return pk_dic_ib
def re_evaluate_pk_with_IB(pk_dic_ib, INIT, PENALTY):
""" Function: re_evaluate_pk_with_IB()
Purpose: Calculate pseudoknot free energies under energy model LongPK
where one of the stems is interrupted. Take into account
recursive structure elements which can occur in loops L1 and L3.
Input: Dictionary with pseudoknots where one of the stems is
interrupted.
Return: Dictionary with pseudoknots and associated free energy.
"""
for pk_stem, values in pk_dic_ib.items():
if values[1] or values[2] or values[3]:
list1 = values[1]
list2 = values[2]
list3 = values[3]
l1 = values[0][1]
l2 = values[0][2]
l3 = values[0][3]
entropy_l1, energy_l1, entropy_l2, energy_l2, entropy_l3, energy_l3 = 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
energy = values[0][4] # Store stem energies for S1 and S2
# Calculate effective loop lengths
if list1:
energy_l1 = sum([item[3]
for item in list1]) # Add free energies
effective_l1 = functions.effective_length(
list1, l1) # Calculate effective loop length
else:
effective_l1 = l1
if list2:
energy_l2 = sum([item[3]
for item in list2]) # Add free energies
effective_l2 = functions.effective_length(
list2, l2) # Calculate effective loop length
else:
effective_l2 = l2
if list3:
energy_l3 = sum([item[3]
for item in list3]) # Add free energies
effective_l3 = functions.effective_length(
list3, l3) # Calculate effective loop length
else:
effective_l3 = l3
looplength = effective_l1 + effective_l2 + effective_l3
entropy = PENALTY * (looplength)
pk_energy = energy + entropy + energy_l1 + energy_l2 + energy_l3 + INIT
# Only include internal loop energies if this leads to more stable pseudoknots
if pk_energy < values[0][0]:
pk_dic_ib[pk_stem] = pk_energy, values[1], values[2], values[3]
else:
energy = values[0][0]
pk_dic_ib[pk_stem] = energy, [], [], []
else:
energy = values[0][0]
pk_dic_ib[pk_stem] = energy, values[1], values[2], values[3]
return pk_dic_ib
def pk_energy_reevaluation_09(pk_dic_cc09, entropies_dic, entropies_dic_L1, entropies_dic_L3):
""" Function: pk_energy_reevaluation_09()
Purpose: Energy evaluation for pseudoknots with energy parameters CC09.
Take into account recursive structure elements which can
occur in loops L1 and L3.
Input: Dictionary with pseudoknots where 2 <= L2 <= 6.
Return: Dictionary with recursive pseudoknots and associated free energy.
"""
pk_dic_cc09_result = {}
for pk_stem, values in pk_dic_cc09.items():
entropy = 0.0
list1 = values[1]
list3 = values[3]
if list1 or list3:
i, j, k, l = pk_stem[2], pk_stem[3], pk_stem[5], pk_stem[6]
stemlength1 = pk_stem[4]
stemlength2 = pk_stem[7]
l1 = k - (i + stemlength1)
l2 = (j - stemlength1 + 1) - (k + stemlength2)
l3 = (l - stemlength2) - j
energy_l1, energy_l3 = 0.0, 0.0
if stemlength1 > 10:
stemlength1 = 10
if stemlength2 > 10:
stemlength2 = 10
effective_l1 = functions.effective_length(list1, l1) # Calculate effective loop length
effective_l3 = functions.effective_length(list3, l3) # Calculate effective loop length
if list1:
energy_l1 = sum([item[3] for item in list1]) # Add free energies
if list3:
energy_l3 = sum([item[3] for item in list3]) # Add free energies
if effective_l1 <= 7 and effective_l3 <= 7:
quintet = stemlength1, stemlength2, effective_l1, effective_l3, l2
if quintet in entropies_dic:
entropy = entropies_dic[quintet]
elif effective_l1 <= 7 and effective_l3 > 7:
quintet = stemlength1, stemlength2, effective_l1, 'long', l2
if quintet in entropies_dic_L3:
a_b = entropies_dic_L3[quintet]
entropy = a_b[0] * math.log(effective_l3) + a_b[1]
elif effective_l1 > 7 and effective_l3 <= 7:
quintet = stemlength1, stemlength2, 'long', effective_l3, l2
if quintet in entropies_dic_L1:
a_b = entropies_dic_L1[quintet]
entropy = a_b[0] * math.log(effective_l1) + a_b[1]
elif effective_l1 > 7 and effective_l3 > 7:
quintet = stemlength1, stemlength2, effective_l1, 'long', l2
if quintet in entropies_dic_L3:
a_b = entropies_dic_L3[quintet]
entropy = a_b[0] * math.log(l3) + a_b[1]
else:
entropy = 0.0
stack_s1 = values[0][1]
stack_s2 = values[0][2]
pk_energy = stack_s1 + stack_s2 - (0.62 * entropy) + energy_l1 + energy_l3
if entropy:
if pk_energy < 0.0:
if pk_energy < values[0][0]:
pk_dic_cc09_result[pk_stem] = pk_energy, values[1], values[2], values[3]
else:
pk_dic_cc09_result[pk_stem] = values[0][0], [], [], []
else:
pk_energy = pk_dic_cc09[pk_stem][0][0]
pk_dic_cc09_result[pk_stem] = pk_energy, values[1], values[2], values[3]
return pk_dic_cc09_result
def pk_energy_reevaluation_long(pk_dic_longpk, INIT, PENALTY):
""" Function: pk_energy_reevaluation_long()
Purpose: Calculate pseudoknot free energies under energy model LongPK.
Take into account recursive structure elements which can
occur in loops L1, L2 and L3.
Input: Dictionary with recursive pseudoknots where L2 >= 7.
Return: Dictionary with recursive pseudoknots and associated free energy.
"""
for pk_stem, values in pk_dic_longpk.items():
list1 = values[1]
list2 = values[2]
list3 = values[3]
if list1 or list2 or list3:
i, j, k, l = pk_stem[2], pk_stem[3], pk_stem[5], pk_stem[6]
stem1 = i, j
stemlength1 = pk_stem[4]
stem2 = k, l
stemlength2 = pk_stem[7]
stack_s1 = values[0][1]
stack_s2 = values[0][2]
l1 = values[0][3]
l2 = values[0][4]
l3 = values[0][5]
entropy_l1, energy_l1 = 0.0, 0.0
entropy_l2, energy_l2 = 0.0, 0.0
entropy_l3, energy_l3 = 0.0, 0.0
energy = stack_s1 + stack_s2 # Store stem energies for S1 plus S2
# Calculate effective loop lengths
effective_looplength1 = functions.effective_length(list1, l1)
effective_looplength2 = functions.effective_length(list2, l2)
effective_looplength3 = functions.effective_length(list3, l3)
if list1:
energy_l1 = sum([item[3] for item in list1]) # Add free energies
if list2:
energy_l2 = sum([item[3] for item in list2]) # Add free energies
if list3:
energy_l3 = sum([item[3] for item in list3]) # Add free energies
# Calculate free energy of pseudoknot
entropy = PENALTY * (effective_looplength1 + effective_looplength2 + effective_looplength3)
pk_energy = stack_s1 + stack_s2 + entropy + energy_l1 + energy_l2 + energy_l3 + INIT
if pk_energy < values[0][0]:
pk_dic_longpk[pk_stem] = pk_energy, values[1], values[2], values[3]
else:
energy = values[0][0]
pk_dic_longpk[pk_stem] = energy, [], [], []
else:
energy = values[0][0]
pk_dic_longpk[pk_stem] = energy, values[1], values[2], values[3]
return pk_dic_longpk
def traceback_mwis_2d(seq, array, MAX_LOOP_UPPER):
""" Function: traceback_mwis_2d()
Purpose: Traceback.
Input: Dynamic programming matrix.
Return: Result for each loop interval plus effective looplength.
"""
# Traceback for given loop interval
array_traceback = [[(0.0, None) for i in xrange(len(seq) + 1)]
for j in xrange(len(seq) + 1)]
for i in xrange(1, len(seq)):
for j in xrange(i - 1, len(seq)):
if j - i + 1 <= MAX_LOOP_UPPER:
energy = array[i][j][0]
loop_start = i
loop_end = j
elements = []
#if energy != 0.0:
energy = array[loop_start][loop_end][0]
element = array[loop_start][loop_end][1]
new_loop_end = loop_end
if element:
elements.append(element)
energy = array[loop_start][loop_end][0] - element[3]
new_loop_end = element[0]
while round(energy, 2) != 0.0:
element = array[loop_start][new_loop_end][1]
if element:
elements.append(element)
energy = array[loop_start][new_loop_end][0] - element[3]
new_loop_end = element[0]
elif new_loop_end > loop_start:
new_loop_end = new_loop_end - 1
else:
break
# Calculate effective loop length
looplength = loop_end - loop_start + 1
effective_looplength = functions.effective_length(
elements, looplength)
#else:
# effective_looplength = j - i + 1
array_traceback[i][j] = array[i][j][
0], elements, effective_looplength
"""mwis_2d_file = file("mwis_2d_file.txt",'w')
for index, item in enumerate(array_traceback):
for index2, item2 in enumerate(array_traceback[index]):
#if item2[0] != 0.0 and item2[1] != [] and index < index2:
mwis_2d_file.write(str(index))
mwis_2d_file.write(" ")
mwis_2d_file.write(str(index2))
mwis_2d_file.write(" result ")
mwis_2d_file.write(str(item2))
mwis_2d_file.write("\n")"""
return array_traceback
def pk_energy_reevaluation_06(pk_dic_cc06):
""" Function: pk_energy_reevaluation_06()
Purpose: Calculate pseudoknot free energies under energy model CC06.
Take into account recursive structure elements which can
occur in loops L1 and L3.
Input: Dictionary with recursive pseudoknots where L2 <= 1.
Return: Dictionary with recursive pseudoknots and associated free energy.
"""
for pk_stem, values in pk_dic_cc06.items():
i, j, k, l = pk_stem[2], pk_stem[3], pk_stem[5], pk_stem[6]
stemlength1 = pk_stem[4]
stemlength2 = pk_stem[7]
l1 = k - (i + stemlength1)
l2 = (j - stemlength1 + 1) - (k + stemlength2)
l3 = (l - stemlength2) - j
list1 = values[1]
list3 = values[3]
if list1:
energy_l1 = sum([item[3] for item in list1]) # Add free energies
effective_l1 = functions.effective_length(
list1, l1) # Calculate effective loop length
if stemlength2 > 12:
stemlength2 = 12
# Calculate loop entropy for L1 dependent on stem S2
loop1_stem2 = effective_l1, stemlength2
if loop1_stem2 in loop1_dic_cc:
entropy_l1 = 0.62 * loop1_dic_cc[loop1_stem2]
else:
if effective_l1 > 0:
ln_w_coil = 2.14 * effective_l1 + 0.10
fitting = lmin_S2[stemlength2]
l_min = fitting[0]
ln_w = fitting[1] * math.log(
effective_l1 - l_min + 1) + fitting[2] * (
effective_l1 - l_min + 1) + fitting[3]
entropy_l1 = 0.62 * (ln_w_coil - ln_w)
else:
energy_l1 = 0.0
entropy_l1 = values[0][3]
if list3:
energy_l3 = sum([item[3] for item in list3]) # Add free energies
effective_l3 = functions.effective_length(
list3, l3) # Calculate effective loop length
if stemlength1 > 12:
stemlength1 = 12
# Calculate loop entropy for L3 dependent on stem S1
loop3_stem1 = effective_l3, stemlength1
if loop3_stem1 in loop3_dic_cc:
entropy_l3 = 0.62 * loop3_dic_cc[loop3_stem1]
else:
if effective_l3 > 1:
ln_w_coil = 2.14 * effective_l3 + 0.10
fitting = lmin_S1[stemlength1]
l_min = fitting[0]
ln_w = fitting[1] * math.log(
effective_l3 - l_min + 1) + fitting[2] * (
effective_l3 - l_min + 1) + fitting[3]
entropy_l3 = 0.62 * (ln_w_coil - ln_w)
else:
energy_l3 = 0.0
entropy_l3 = values[0][5]
stack_s1 = values[0][1]
stack_s2 = values[0][2]
energy = stack_s1 + stack_s2 + entropy_l1 + energy_l1 + entropy_l3 + energy_l3 + 1.3 + values[
0][6]
if energy < values[0][0]: # If recursive elements stabilize pseudoknot
pk_dic_cc06[pk_stem] = energy, values[1], values[2], values[3]
else:
energy = values[0][0]
pk_dic_cc06[pk_stem] = energy, [], [], []
return pk_dic_cc06
def traceback_mwis_2d_positive(seq, array, MAX_LOOP_UPPER):
""" Function: traceback_mwis_2d_positive()
Purpose: Traceback for positive weights.
Input: Dynamic programming matrix.
Return: Result for each loop interval plus effective looplength.
"""
# Traceback for given loop interval
rows = len(seq)
columns = len(seq)
array_traceback = [[(0.0, None, None) for i in xrange(columns + 1)]
for j in xrange(rows + 1)]
for i in xrange(1, len(seq)):
for j in xrange(i - 1, len(seq)):
if j - i + 1 <= MAX_LOOP_UPPER:
energy = array[i][j][0]
loop_start = i
loop_end = j
elements = []
if energy != 0.0:
energy = array[loop_start][loop_end][0]
element = array[loop_start][loop_end][1]
new_loop_end = loop_end
if element:
elements.append(element)
energy = array[loop_start][loop_end][0] - element[2]
new_loop_end = element[0]
while round(energy, 2) != 0.0:
element = array[loop_start][new_loop_end][1]
if element:
elements.append(element)
energy = array[loop_start][new_loop_end][
0] - element[2]
new_loop_end = element[0]
elif new_loop_end > loop_start:
new_loop_end = new_loop_end - 1
else:
break
# Calculate effective loop length
looplength = loop_end - loop_start + 1
effective_looplength = functions.effective_length(
elements, looplength)
else:
effective_looplength = j - i + 1
array_traceback[i][j] = array[i][j][
0], elements, effective_looplength
# Now write real, positive free energy weights to array
for i in xrange(1, len(seq)):
for j in xrange(i - 1, len(seq)):
elements = array_traceback[i][j][1]
if elements:
energy = sum([item[3] for item in elements])
array_traceback[i][j] = energy, elements, array_traceback[i][
j][2]
return array_traceback
def pk_energy_reevaluation_06(pk_dic_cc06):
""" Function: pk_energy_reevaluation_06()
Purpose: Calculate pseudoknot free energies under energy model CC06.
Take into account recursive structure elements which can
occur in loops L1 and L3.
Input: Dictionary with recursive pseudoknots where L2 <= 1.
Return: Dictionary with recursive pseudoknots and associated free energy.
"""
for pk_stem, values in pk_dic_cc06.items():
i, j, k, l = pk_stem[2], pk_stem[3], pk_stem[5], pk_stem[6]
stemlength1 = pk_stem[4]
stemlength2 = pk_stem[7]
l1 = k - (i + stemlength1)
l2 = (j - stemlength1 + 1) - (k + stemlength2)
l3 = (l - stemlength2) - j
list1 = values[1]
list3 = values[3]
if list1:
energy_l1 = sum([item[3] for item in list1]) # Add free energies
effective_l1 = functions.effective_length(list1, l1) # Calculate effective loop length
if stemlength2 > 12:
stemlength2 = 12
# Calculate loop entropy for L1 dependent on stem S2
loop1_stem2 = effective_l1, stemlength2
if loop1_stem2 in loop1_dic_cc:
entropy_l1 = 0.62 * loop1_dic_cc[loop1_stem2]
else:
if effective_l1 > 0:
ln_w_coil = 2.14 * effective_l1 + 0.10
fitting = lmin_S2[stemlength2]
l_min = fitting[0]
ln_w = fitting[1] * math.log(effective_l1 - l_min + 1) + fitting[2] * (effective_l1 - l_min + 1) + fitting[3]
entropy_l1 = 0.62*(ln_w_coil - ln_w)
else:
energy_l1 = 0.0
entropy_l1 = values[0][3]
if list3:
energy_l3 = sum([item[3] for item in list3]) # Add free energies
effective_l3 = functions.effective_length(list3, l3) # Calculate effective loop length
if stemlength1 > 12:
stemlength1 = 12
# Calculate loop entropy for L3 dependent on stem S1
loop3_stem1 = effective_l3, stemlength1
if loop3_stem1 in loop3_dic_cc:
entropy_l3 = 0.62 * loop3_dic_cc[loop3_stem1]
else:
if effective_l3 > 1:
ln_w_coil = 2.14 * effective_l3 + 0.10
fitting = lmin_S1[stemlength1]
l_min = fitting[0]
ln_w = fitting[1] * math.log(effective_l3 - l_min + 1) + fitting[2] * (effective_l3 - l_min + 1) + fitting[3]
entropy_l3 = 0.62*(ln_w_coil - ln_w)
else:
energy_l3 = 0.0
entropy_l3 = values[0][5]
stack_s1 = values[0][1]
stack_s2 = values[0][2]
energy = stack_s1 + stack_s2 + entropy_l1 + energy_l1 + entropy_l3 + energy_l3 + 1.3 + values[0][6]
if energy < values[0][0]: # If recursive elements stabilize pseudoknot
pk_dic_cc06[pk_stem] = energy, values[1], values[2], values[3]
else:
energy = values[0][0]
pk_dic_cc06[pk_stem] = energy, [],[],[]
return pk_dic_cc06
def traceback_mwis_2d(seq, array, MAX_LOOP_UPPER):
""" Function: traceback_mwis_2d()
Purpose: Traceback.
Input: Dynamic programming matrix.
Return: Result for each loop interval plus effective looplength.
"""
# Traceback for given loop interval
array_traceback = [[(0.0, None) for i in xrange(len(seq) + 1)] for j in xrange(len(seq) + 1)]
for i in xrange(1, len(seq)):
for j in xrange(i-1, len(seq)):
if j - i + 1 <= MAX_LOOP_UPPER:
energy = array[i][j][0]
loop_start = i
loop_end = j
elements = []
#if energy != 0.0:
energy = array[loop_start][loop_end][0]
element = array[loop_start][loop_end][1]
new_loop_end = loop_end
if element:
elements.append(element)
energy = array[loop_start][loop_end][0] - element[3]
new_loop_end = element[0]
while round(energy, 2) != 0.0:
element = array[loop_start][new_loop_end][1]
if element:
elements.append(element)
energy = array[loop_start][new_loop_end][0] - element[3]
new_loop_end = element[0]
elif new_loop_end > loop_start:
new_loop_end = new_loop_end - 1
else:
break
# Calculate effective loop length
looplength = loop_end - loop_start + 1
effective_looplength = functions.effective_length(elements, looplength)
#else:
# effective_looplength = j - i + 1
array_traceback[i][j] = array[i][j][0], elements, effective_looplength
"""mwis_2d_file = file("mwis_2d_file.txt",'w')
for index, item in enumerate(array_traceback):
for index2, item2 in enumerate(array_traceback[index]):
#if item2[0] != 0.0 and item2[1] != [] and index < index2:
mwis_2d_file.write(str(index))
mwis_2d_file.write(" ")
mwis_2d_file.write(str(index2))
mwis_2d_file.write(" result ")
mwis_2d_file.write(str(item2))
mwis_2d_file.write("\n")"""
return array_traceback
def traceback_mwis_2d_positive(seq, array, MAX_LOOP_UPPER):
""" Function: traceback_mwis_2d_positive()
Purpose: Traceback for positive weights.
Input: Dynamic programming matrix.
Return: Result for each loop interval plus effective looplength.
"""
# Traceback for given loop interval
rows = len(seq)
columns = len(seq)
array_traceback = [[(0.0, None, None) for i in xrange(columns + 1)] for j in xrange(rows + 1)]
for i in xrange(1, len(seq)):
for j in xrange(i-1, len(seq)):
if j - i + 1 <= MAX_LOOP_UPPER:
energy = array[i][j][0]
loop_start = i
loop_end = j
elements = []
if energy != 0.0:
energy = array[loop_start][loop_end][0]
element = array[loop_start][loop_end][1]
new_loop_end = loop_end
if element:
elements.append(element)
energy = array[loop_start][loop_end][0] - element[2]
new_loop_end = element[0]
while round(energy, 2) != 0.0:
element = array[loop_start][new_loop_end][1]
if element:
elements.append(element)
energy = array[loop_start][new_loop_end][0] - element[2]
new_loop_end = element[0]
elif new_loop_end > loop_start:
new_loop_end = new_loop_end - 1
else:
break
# Calculate effective loop length
looplength = loop_end - loop_start + 1
effective_looplength = functions.effective_length(elements, looplength)
else:
effective_looplength = j - i + 1
array_traceback[i][j] = array[i][j][0], elements, effective_looplength
# Now write real, positive free energy weights to array
for i in xrange(1, len(seq)):
for j in xrange(i-1, len(seq)):
elements = array_traceback[i][j][1]
if elements:
energy = sum([item[3] for item in elements])
array_traceback[i][j] = energy, elements, array_traceback[i][j][2]
return array_traceback
def pk_energy_reevaluation_long(pk_dic_longpk, INIT, PENALTY):
""" Function: pk_energy_reevaluation_long()
Purpose: Calculate pseudoknot free energies under energy model LongPK.
Take into account recursive structure elements which can
occur in loops L1, L2 and L3.
Input: Dictionary with recursive pseudoknots where L2 >= 7.
Return: Dictionary with recursive pseudoknots and associated free energy.
"""
for pk_stem, values in pk_dic_longpk.items():
list1 = values[1]
list2 = values[2]
list3 = values[3]
if list1 or list2 or list3:
i, j, k, l = pk_stem[2], pk_stem[3], pk_stem[5], pk_stem[6]
stem1 = i, j
stemlength1 = pk_stem[4]
stem2 = k, l
stemlength2 = pk_stem[7]
stack_s1 = values[0][1]
stack_s2 = values[0][2]
l1 = values[0][3]
l2 = values[0][4]
l3 = values[0][5]
entropy_l1, energy_l1 = 0.0, 0.0
entropy_l2, energy_l2 = 0.0, 0.0
entropy_l3, energy_l3 = 0.0, 0.0
energy = stack_s1 + stack_s2 # Store stem energies for S1 plus S2
# Calculate effective loop lengths
effective_looplength1 = functions.effective_length(list1, l1)
effective_looplength2 = functions.effective_length(list2, l2)
effective_looplength3 = functions.effective_length(list3, l3)
if list1:
energy_l1 = sum([item[3]
for item in list1]) # Add free energies
if list2:
energy_l2 = sum([item[3]
for item in list2]) # Add free energies
if list3:
energy_l3 = sum([item[3]
for item in list3]) # Add free energies
# Calculate free energy of pseudoknot
entropy = PENALTY * (effective_looplength1 +
effective_looplength2 + effective_looplength3)
pk_energy = stack_s1 + stack_s2 + entropy + energy_l1 + energy_l2 + energy_l3 + INIT
if pk_energy < values[0][0]:
pk_dic_longpk[pk_stem] = pk_energy, values[1], values[
2], values[3]
else:
energy = values[0][0]
pk_dic_longpk[pk_stem] = energy, [], [], []
else:
energy = values[0][0]
pk_dic_longpk[pk_stem] = energy, values[1], values[2], values[3]
return pk_dic_longpk
def pk_energy_reevaluation_09(pk_dic_cc09, entropies_dic, entropies_dic_L1,
entropies_dic_L3):
""" Function: pk_energy_reevaluation_09()
Purpose: Energy evaluation for pseudoknots with energy parameters CC09.
Take into account recursive structure elements which can
occur in loops L1 and L3.
Input: Dictionary with pseudoknots where 2 <= L2 <= 6.
Return: Dictionary with recursive pseudoknots and associated free energy.
"""
pk_dic_cc09_result = {}
for pk_stem, values in pk_dic_cc09.items():
entropy = 0.0
list1 = values[1]
list3 = values[3]
if list1 or list3:
i, j, k, l = pk_stem[2], pk_stem[3], pk_stem[5], pk_stem[6]
stemlength1 = pk_stem[4]
stemlength2 = pk_stem[7]
l1 = k - (i + stemlength1)
l2 = (j - stemlength1 + 1) - (k + stemlength2)
l3 = (l - stemlength2) - j
energy_l1, energy_l3 = 0.0, 0.0
if stemlength1 > 10:
stemlength1 = 10
if stemlength2 > 10:
stemlength2 = 10
effective_l1 = functions.effective_length(
list1, l1) # Calculate effective loop length
effective_l3 = functions.effective_length(
list3, l3) # Calculate effective loop length
if list1:
energy_l1 = sum([item[3]
for item in list1]) # Add free energies
if list3:
energy_l3 = sum([item[3]
for item in list3]) # Add free energies
if effective_l1 <= 7 and effective_l3 <= 7:
quintet = stemlength1, stemlength2, effective_l1, effective_l3, l2
if quintet in entropies_dic:
entropy = entropies_dic[quintet]
elif effective_l1 <= 7 and effective_l3 > 7:
quintet = stemlength1, stemlength2, effective_l1, 'long', l2
if quintet in entropies_dic_L3:
a_b = entropies_dic_L3[quintet]
entropy = a_b[0] * math.log(effective_l3) + a_b[1]
elif effective_l1 > 7 and effective_l3 <= 7:
quintet = stemlength1, stemlength2, 'long', effective_l3, l2
if quintet in entropies_dic_L1:
a_b = entropies_dic_L1[quintet]
entropy = a_b[0] * math.log(effective_l1) + a_b[1]
elif effective_l1 > 7 and effective_l3 > 7:
quintet = stemlength1, stemlength2, effective_l1, 'long', l2
if quintet in entropies_dic_L3:
a_b = entropies_dic_L3[quintet]
entropy = a_b[0] * math.log(l3) + a_b[1]
else:
entropy = 0.0
stack_s1 = values[0][1]
stack_s2 = values[0][2]
pk_energy = stack_s1 + stack_s2 - (0.62 *
entropy) + energy_l1 + energy_l3
if entropy:
if pk_energy < 0.0:
if pk_energy < values[0][0]:
pk_dic_cc09_result[pk_stem] = pk_energy, values[
1], values[2], values[3]
else:
pk_dic_cc09_result[pk_stem] = values[0][0], [], [], []
else:
pk_energy = pk_dic_cc09[pk_stem][0][0]
pk_dic_cc09_result[pk_stem] = pk_energy, values[1], values[
2], values[3]
return pk_dic_cc09_result
