def hillclimber(protein):
''' Dit algoritme probeert de beste score van een gegeven proteine te vinden.
Door eerst een kopie te maken van de huidige staat, dan een mutatie uit te
voeren en vervolgens de twee met elkaar te vergelijken. De hoogste score
wordt behouden. In het geval dat de score's gelijk aan elkaar zijn wordt de
nieuwste score behouden.
Het neemt een proteine in de vorm van een string als argument en geeft een
score in de vorm van een integer terug.
'''
fold = ff.Fold(protein)
helpe.insert_protein(fold.Protein)
scoreslist = []
for i in range(10000):
current_grid, current_score, current_p_list = fold.random_fold()
if helpe.check_protein(fold.grid, fold.Protein) <= current_score:
continue
else:
fold.grid = current_grid
fold.Protein.protein_list = current_p_list
proteinlistlist = []
score = helpe.check_protein(fold.grid, fold.Protein)
scoreslist.append(score)
for k in range(len(fold.Protein.protein_list)):
proteinlistlist.append(fold.Protein.protein_list[k].row)
proteinlistlist.append(fold.Protein.protein_list[k].column)
scoreslist.append(proteinlistlist)
return scoreslist
def __init__(self, protein):
''' Initialiseert een fold-object. Neemt een string die het proteïne representeerd
als argument. Maakt een proteine-object aan en zet het object in een grid.
'''
self.protein = protein
self.Protein = pp.Protein(self.protein)
self.grid = helpe.insert_protein(self.Protein)
def random_fold(self):
''' Random_fold neemt een fold object als argument. Er wordt een aanpassing
gemaakt op een random plek in het proteïne naar een random vouwoptie.
Het geturnt het grid als numpy array, een integer die voor de score staat
en een proteinlist met Aminode objecten in een lijst.
'''
# Maak kopie van huidige staat voor latere vergelijkingen.
current_grid = copy.deepcopy(self.grid)
current_score = helpe.check_protein(self.grid, self.Protein)
current_p_list = copy.deepcopy(self.Protein.protein_list)
# Kies een random plek om te vouwen en kies een random optie om naar te vouwen.
j = random.randint(2, (len(self.Protein.protein_list) - 1))
current_row = self.Protein.protein_list[j - 1].row
current_col = self.Protein.protein_list[j - 1].column
future_row, future_col = self.choose_option(
self.optionlist(current_row, current_col, j), current_row,
current_col)
# Vouw en zet in het grid.
self.fold(future_row, future_col, current_row, current_col, j)
self.grid = helpe.insert_protein(self.Protein)
return current_grid, current_score, current_p_list
def random_structure_without_collision(protein):
''' Random_structure_without_collision neemt een proteïne string als argument
en maakt van dit proteïne een random structuur zonder collisions. Returnt
een proteïne object
'''
# Maak random structuur, zolang deze collisions heeft probeer opnieuw.
pro_obj = pp.Protein(protein)
row_list, column_list = random_structure(pro_obj)
while check_for_collision(row_list, column_list) == False:
row_list, column_list = random_structure(pro_obj)
grid = hp.insert_protein(pro_obj)
score = hp.check_protein(grid, pro_obj)
return score
def sim_anneal(protein, cool):
''' Ti = T0 - i(T0-Tn) / N
Kan ik i als temp gebruiken? denk dat dit handig is
T0 is iets van count die hoog staat
De begintemp kies je zo dat op iedere verslechtering de kans 1 is
'''
fold = ff.Fold(protein)
score = hill.hillclimber(protein)
highscore = copy.copy(score)
highproteinlist = copy.deepcopy(fold.Protein.protein_list)
fold.grid = helpe.insert_protein(fold.Protein)
# Linear
if cool == int(1):
T0 = 1000
Tn = 0
N = 10000
# Exponential
elif cool == int(2):
T0 = 10000
Tn = 1000
N = 1000
# Logarithmic
elif cool == int(3):
T0 = 1000
Tn = 0
N = 10000
A = ((T0 - Tn) * (N + 1)) / N
B = T0 - A
for i in range(0, 10000):
current_grid, current_score, current_p_list = fold.random_fold()
if helpe.check_protein(fold.grid, fold.Protein) <= current_score:
highscore, highproteinlist = helpe.check_highscore(
fold, current_score, highscore, highproteinlist)
else:
if cool == int(1):
temperature = T0 - (i * (T0 - Tn)) / N
elif cool == int(2):
temperature = T0 * ((Tn / T0)**(i / N))
elif cool == int(3):
temperature = (A / (i + 1)) + B
helpe.probability(temperature, fold, current_score, current_grid,
current_p_list)
return highscore