def rod_swap_crossover(assembly_one_lattice, assembly_two_lattice,
assembly_two_rod_list, assembly_one_rod_list,
region_map):
#Swaps a rod between the two assemblies. It doesn't account to make sure that the rod is not in common with the current assembly.
chromosome_one = random.choice(assembly_one_rod_list)
chromosome_two = chromosome_one
while (chromosome_one == chromosome_two):
chromosome_two = random.choice(assembly_two_rod_list)
rod_count = 0
for rod in region_map:
if (rod == 1):
if (assembly_one_lattice[rod_count] == chromosome_one):
assembly_one_lattice[rod_count] = chromosome_two
if (assembly_two_lattice[rod_count] == chromosome_two):
assembly_two_lattice[rod_count] = chromosome_one
rod_count += 1
assembly_one_rod_list.remove(chromosome_one)
assembly_one_rod_list.append(chromosome_two)
assembly_two_rod_list.remove(chromosome_two)
assembly_two_rod_list.append(chromosome_one)
string_assembly_one_lattice = convert_to_string(assembly_one_lattice)
string_assembly_two_lattice = convert_to_string(assembly_two_lattice)
lattice_one_pin_map = metrics.return_pin_map(string_assembly_one_lattice)
lattice_two_pin_map = metrics.return_pin_map(string_assembly_two_lattice)
stowage = open('child_list.txt', 'a')
stowage.write('Assembly\n')
stowage.write(lattice_one_pin_map)
stowage.write('What_Happened: Rod_Swap_Crossover\n\n')
stowage.write('Assembly\n')
stowage.write(lattice_two_pin_map)
stowage.write('What_Happened: Rod_Swap_Crossover\n\n')
stowage.close()
def double_mutation(lattice, rod_list, region_map, pin_list):
# A function to alter two rod locations within the lattice. Does not introduce any new rod types.
suitable_swap_locations = []
for rod in xrange(len(region_map)):
if (region_map[rod] == 1): suitable_swap_locations.append(rod)
x1 = random.choice(suitable_swap_locations)
x2 = random.choice(suitable_swap_locations)
original_pin_one = lattice[x1]
original_pin_two = lattice[x2]
foo_one = original_pin_one
foo_two = original_pin_two
while (foo_one == original_pin_one):
foo_one = random.randint(0, len(pin_list[1]) - 1)
while (foo_two == original_pin_two):
foo_two = random.randint(0, len(pin_list[1]) - 1)
new_lattice = range(len(lattice))
for i in xrange(len(lattice)):
if (i == x1): new_lattice[i] = str(foo_one)
elif (i == x2): new_lattice[i] = str(foo_two)
else: new_lattice[i] = lattice[i]
string_new_lattice = convert_to_string(new_lattice)
pin_map = metrics.return_pin_map(string_new_lattice)
stowage = open('child_list.txt', 'a')
stowage.write('Assembly\n')
stowage.write(pin_map)
stowage.write('What_Happened: Double_Mutation\n\n')
stowage.close()
def single_mutation(lattice, rod_list, region_map, pin_list):
#A function to alter a single rod location within the lattice. Does not introduce new rod types to the lattice.
#I don't know why I didn't make this one so that it accepts the lattice. list. I think it would be
#best to make an organized mutation function similar to what I did for crossover.
suitable_swap_locations = []
for rod in xrange(len(region_map)):
if (region_map[rod] == 1): suitable_swap_locations.append(rod)
x = random.choice(suitable_swap_locations)
original_pin = lattice[x]
foo = original_pin
while (foo == original_pin):
foo = random.randint(0, len(pin_list[1]) - 1)
new_lattice = range(len(lattice))
for i in xrange(len(lattice)):
if (i == x): new_lattice[i] = str(foo)
else: new_lattice[i] = lattice[i]
string_new_lattice = convert_to_string(new_lattice)
pin_map = metrics.return_pin_map(string_new_lattice)
stowage = open('child_list.txt', 'a')
stowage.write('Assembly\n')
stowage.write(pin_map)
stowage.write('What_Happened: Single_Mutation\n\n')
stowage.close()
def crossover(full_lattice_list, region_map, pin_list):
remaining_assemblies = full_lattice_list[:]
number_of_pairs = len(remaining_assemblies) / 2
for foo in xrange(number_of_pairs):
current_assembly = remaining_assemblies[0][:]
current_rod_list = return_active_rod_list(current_assembly, region_map)
mate_lattice_number = 0
mate_score = 0
for assembly in range(1, len(remaining_assemblies)):
matching_rod_count = 0
current_examine_list = return_active_rod_list(
remaining_assemblies[assembly], region_map)
if (len(current_examine_list) > len(current_rod_list)):
shorter_list = len(current_rod_list)
else:
shorter_list = len(current_examine_list)
for rod in xrange(shorter_list):
if (current_rod_list[rod] == current_examine_list[rod]):
matching_rod_count += 1
if (matching_rod_count > mate_score):
mate_score = matching_rod_count
mate_lattice_number = assembly
mate_rod_list = current_examine_list[:]
mate_lattice = remaining_assemblies[mate_lattice_number]
suitable_swap_locations = []
rod_number = 0
for rod in xrange(len(current_assembly)):
if (mate_lattice[rod] == current_assembly[rod]):
pass
else:
suitable_swap_locations.append(rod)
if (len(suitable_swap_locations) < 4):
double_mutation(current_assembly, current_rod_list, region_map,
pin_list)
double_mutation(mate_lattice, mate_rod_list, region_map, pin_list)
else:
number_swaps = len(suitable_swap_locations) / 2
actual_swap_spots = []
for i in xrange(number_swaps):
x = random.choice(suitable_swap_locations)
actual_swap_spots.append(x)
new_assembly_one = range(len(current_assembly))
new_assembly_two = range(len(mate_lattice))
for i in xrange(len(current_assembly)):
not_swap_location = True
for foo in actual_swap_spots:
if (foo == i):
not_swap_location = False
if (not_swap_location == True):
new_assembly_one[i] = current_assembly[i]
new_assembly_two[i] = mate_lattice[i]
else:
new_assembly_one[i] = mate_lattice[i]
new_assembly_two[i] = current_assembly[i]
string_new_assembly_one = convert_to_string(new_assembly_one)
string_new_assembly_two = convert_to_string(new_assembly_two)
lattice_one_pin_map = metrics.return_pin_map(
string_new_assembly_one)
lattice_two_pin_map = metrics.return_pin_map(
string_new_assembly_two)
stowage = open('child_list.txt', 'a')
stowage.write('Assembly\n')
stowage.write(lattice_one_pin_map)
stowage.write('What_Happened: Pin_Swap_Crossover\n\n')
stowage.write('Assembly\n')
stowage.write(lattice_two_pin_map)
stowage.write('What_Happened: Pin_Swap_Crossover\n\n')
stowage.close()
if (current_assembly in remaining_assemblies):
remaining_assemblies.remove(current_assembly)
if (mate_lattice in remaining_assemblies):
remaining_assemblies.remove(mate_lattice)
def roulette(previous_generation, current_generation):
#A function for determining which assemblies survive to breed in the next generation.
#Uses a roulette method to select the survivors. All assemblies are drawn into single rank list. Then
#ranks are randomly picked until the population list is full.
#previous_generation is the name of the previous generation survivor list.
#rent_file = open(previous_generation, 'r')
parent_lines = parent_file.readlines()
parent_file.close()
child_file = open(current_generation, 'r')
child_lines = child_file.readlines()
child_file.close()
lattice_list = []
lattice_count = 0
cost_list = []
rod_list = []
what_happened_list = []
line_count = 1000
for line in parent_lines:
elems = line.strip().split()
if (len(elems) > 0):
if (elems[0] == 'Assembly'):
line_count = 0
lattice_count += 1
temp_lattice = []
if (line_count > 0 and line_count < 11):
for el in elems:
temp_lattice.append(el)
elif (line_count == 11):
lattice_list.append(temp_lattice)
what_happened_list.append(elems[1])
elif (line_count == 12):
cost_list.append(float(elems[1]))
line_count += 1
line_count = 1000
for line in child_lines:
elems = line.strip().split()
if (len(elems) > 0):
if (elems[0] == 'Assembly'):
line_count = 0
lattice_count += 1
temp_lattice = []
if (line_count > 0 and line_count < 11):
for el in elems:
temp_lattice.append(el)
elif (line_count == 11):
lattice_list.append(temp_lattice)
what_happened_list.append(elems[1])
elif (line_count == 12):
cost_list.append(float(elems[1]))
line_count += 1
average_cost = metrics.calculate_average_cost(cost_list)
variance = metrics.calculate_cost_variance(cost_list, average_cost)
(min_cost, max_cost, best_lattice, worst_lattice, best_what_happened,
worst_what_happened) = metrics.return_max_and_min(cost_list, lattice_list,
what_happened_list)
pin_average = metrics.return_average_pins_used(lattice_list)
metric_file = open('metrics_file.txt', 'a')
metric_file.write('Average Lattice Cost: ' + str(average_cost) + '\n')
metric_file.write('Variance in lattice score: ' + str(variance) + '\n')
metric_file.write('Minimum lattice score: ' + str(min_cost))
metric_file.write(' Maximum lattice score: ' + str(max_cost) + '\n')
metric_file.write('Average number of pins per assembly: ' +
str(pin_average))
metric_file.write('Highest scoring Pin Lattice \n' + best_lattice)
metric_file.write('Worst Scoring Pin Lattice \n' + worst_lattice +
'\n\n\n')
print('Average Lattice Cost: ' + str(average_cost) + '\n')
print('Variance in lattice score: ' + str(variance) + '\n')
print('Minimum lattice score: ' + str(min_cost))
print(' Maximum lattice score: ' + str(max_cost) + '\n')
print('Average number of pins per assembly: ' + str(pin_average))
print('Highest scoring Pin Lattice \n' + best_lattice)
print('Worst Scoring Pin Lattice \n' + worst_lattice + '\n\n\n')
metric_file.close()
new_parent = open('parent_list.txt', 'w')
number_of_rounds = lattice_count / 2
rank_list = 0
cost_sum = 0
for cost in cost_list:
cost_sum += cost
rank_sum = 0
for cost in cost_list:
temp_rank = (cost / cost_sum) + rank_sum
rank_list.append(temp_rank)
rank_sum = temp_rank
for i in xrange(number_of_rounds):
temp = random.random()
match_cost_not_found = True
assembly_count = 0
for rank in rank_list:
if (match_cost_not_found == True):
if (rank > temp):
assembly_number = assembly_count
match_cost_not_found = False
assembly_count += 1
new_parent.write('Assembly\n')
pin_map = metrics.return_pin_map(lattice_list[assembly_number])
new_parent.write(pin_map)
new_parent.write('What_Happened: ' +
what_happened_list[assembly_number] + '\n')
new_parent.write('Lattice_Cost: ' + str(cost_list[assembly_number]) +
'\n\n')
new_parent.close()
def tournament(previous_generation, current_generation):
#A function for determining which assemblies survive to breed in the next generation.
#Two assemblies are randomly drawn from the total list of assemblies.
#The assembly with the highest cost survives to the next generation while the lower
#cost assembly is killed.
#previous_generation is the name of the previous generation survivor list.
parent_file = open(previous_generation, 'r')
parent_lines = parent_file.readlines()
parent_file.close()
child_file = open(current_generation, 'r')
child_lines = child_file.readlines()
child_file.close()
lattice_list = []
lattice_count = 0
cost_list = []
rod_list = []
what_happened_list = []
line_count = 1000
for line in parent_lines:
elems = line.strip().split()
if (len(elems) > 0):
if (elems[0] == 'Assembly'):
line_count = 0
lattice_count += 1
temp_lattice = []
if (line_count > 0 and line_count < 11):
for el in elems:
temp_lattice.append(el)
elif (line_count == 11):
lattice_list.append(temp_lattice)
what_happened_list.append(elems[1])
elif (line_count == 12):
cost_list.append(float(elems[1]))
line_count += 1
line_count = 1000
for line in child_lines:
elems = line.strip().split()
if (len(elems) > 0):
if (elems[0] == 'Assembly'):
line_count = 0
lattice_count += 1
temp_lattice = []
if (line_count > 0 and line_count < 11):
for el in elems:
temp_lattice.append(el)
elif (line_count == 11):
lattice_list.append(temp_lattice)
what_happened_list.append(elems[1])
elif (line_count == 12):
cost_list.append(float(elems[1]))
line_count += 1
average_cost = metrics.calculate_average_cost(cost_list)
variance = metrics.calculate_cost_variance(cost_list, average_cost)
(min_cost, max_cost, best_lattice, worst_lattice, best_what_happened,
worst_what_happened) = metrics.return_max_and_min(cost_list, lattice_list,
what_happened_list)
pin_average = metrics.return_average_pins_used(lattice_list)
metric_file = open('metrics_file.txt', 'a')
metric_file.write('Average Lattice Cost: ' + str(average_cost) + '\n')
metric_file.write('Variance in lattice score: ' + str(variance) + '\n')
metric_file.write('Minimum lattice score: ' + str(min_cost))
metric_file.write(' Maximum lattice score: ' + str(max_cost) + '\n')
metric_file.write('Average number of pins per assembly: ' +
str(pin_average))
metric_file.write('Highest scoring Pin Lattice \n' + best_lattice)
metric_file.write('Worst Scoring Pin Lattice \n' + worst_lattice +
'\n\n\n')
print('Average Lattice Cost: ' + str(average_cost) + '\n')
print('Variance in lattice score: ' + str(variance) + '\n')
print('Minimum lattice score: ' + str(min_cost))
print(' Maximum lattice score: ' + str(max_cost) + '\n')
print('Average number of pins per assembly: ' + str(pin_average))
print('Highest scoring Pin Lattice \n' + best_lattice)
print('Worst Scoring Pin Lattice \n' + worst_lattice + '\n\n\n')
metric_file.close()
new_parent = open('parent_list.txt', 'w')
number_of_rounds = lattice_count / 2
for i in xrange(number_of_rounds):
foo_one = random.randint(0, len(lattice_list) - 1)
foo_two = foo_one
while (foo_one == foo_two):
foo_two = random.randint(0, len(lattice_list) - 1)
contestant_one_lattice = lattice_list[foo_one]
contestant_two_lattice = lattice_list[foo_two]
contestant_one_cost = cost_list[foo_one]
contestant_two_cost = cost_list[foo_two]
contestant_one_what_happened = what_happened_list[foo_one]
contestant_two_what_happened = what_happened_list[foo_two]
if (contestant_one_cost > contestant_two_cost):
new_parent.write('Assembly\n')
pin_map = metrics.return_pin_map(contestant_one_lattice)
new_parent.write(pin_map)
new_parent.write('What_Happened: ' + contestant_one_what_happened +
'\n')
new_parent.write('Lattice_Cost: ' + str(contestant_one_cost) +
'\n\n')
else:
new_parent.write('Assembly\n')
pin_map = metrics.return_pin_map(contestant_two_lattice)
new_parent.write(pin_map)
new_parent.write('What_Happened: ' + contestant_two_what_happened +
'\n')
new_parent.write('Lattice_Cost: ' + str(contestant_two_cost) +
'\n\n')
lattice_list.remove(contestant_one_lattice)
lattice_list.remove(contestant_two_lattice)
cost_list.remove(contestant_one_cost)
cost_list.remove(contestant_two_cost)
what_happened_list.remove(contestant_one_what_happened)
what_happened_list.remove(contestant_two_what_happened)
def pin_swap_crossover(current_assembly, mate_lattice, current_rod_list,
mate_rod_list):
#Swaps Rod Locations between two assemblies. Only rods that already exist within the bundle may be switched.
initial_lattice_rods = [0]
for rod in current_assembly:
doesnt_exist = True
for foo in initial_lattice_rods:
if (rod == foo):
doesnt_exist = False
if (doesnt_exist == True):
initial_lattice_rods.append(rod)
in_common_rod_list = [0]
for rod in mate_lattice:
for foo in initial_lattice_rods:
if (rod == foo):
doesnt_exist = True
for thing in in_common_rod_list:
if (thing == rod):
doesnt_exist = False
if (doesnt_exist == True):
in_common_rod_list.append(rod)
rod_number = 0
suitable_swap_locations = []
for rod in current_assembly:
for foo in in_common_rod_list:
if (rod == foo):
for footoo in in_common_rod_list:
if (mate_lattice[rod_number] == footoo):
if (mate_lattice[rod_number] == rod):
pass
else:
suitable_swap_locations.append(rod_number)
rod_number += 1
number_swaps = len(suitable_swap_locations) / 2
actual_swap_spots = []
for i in xrange(number_swaps):
x = random.choice(suitable_swap_locations)
actual_swap_spots.append(x)
new_assembly_one = range(len(current_assembly))
new_assembly_two = range(len(mate_lattice))
for i in xrange(len(current_assembly)):
not_swap_location = True
for foo in actual_swap_spots:
if (foo == i):
not_swap_location = False
if (not_swap_location == True):
new_assembly_one[i] = current_assembly[i]
new_assembly_two[i] = mate_lattice[i]
else:
new_assembly_one[i] = mate_lattice[i]
new_assembly_two[i] = current_assembly[i]
lattice_one_pin_map = metrics.return_pin_map(new_assembly_one)
lattice_two_pin_map = metrics.return_pin_map(new_assembly_two)
assembly_one_rod_list = []
assembly_two_rod_list = []
for rod in new_assembly_one:
if (rod == '0'):
pass
else:
rod_not_used = True
for foo in assembly_one_rod_list:
if (foo == rod):
rod_not_used = False
if (rod_not_used == True):
assembly_one_rod_list.append(rod)
for rod in new_assembly_two:
if (rod == '0'):
pass
else:
rod_not_used = True
for foo in assembly_two_rod_list:
if (foo == rod):
rod_not_used = False
if (rod_not_used == True):
assembly_two_rod_list.append(rod)
stowage = open('child_list.txt', 'a')
stowage.write('Assembly\n')
stowage.write(lattice_one_pin_map)
stowage.write('What_Happened: Pin_Swap_Crossover\n\n')
stowage.write('Assembly\n')
stowage.write(lattice_two_pin_map)
stowage.write('What_Happened: Pin_Swap_Crossover\n\n')
stowage.close()
number_batches = population / batch_size
#number_batches = 5
#population = number_batches*batch_size
final_generation = number_of_generations - 1 #not sure this line of code does anything
########################################################################
#This batch of code writes the initial Casmo input files for the population.
parent = open('parent_list.txt', 'w+')
for batch in xrange(number_batches):
for people in xrange(batch_size):
lattice_list = []
(temp_lattice, temp_rod_list) = input_data.make_input_lattices()
temp_str_map = []
for t in temp_lattice:
temp_str_map.append(str(t))
lattice_list.append(temp_str_map)
temp_rod_map = metrics.return_pin_map(temp_str_map)
parent.write('Assembly\n')
parent.write(temp_rod_map)
parent.write('What Happened: Original_file\n\n')
# print temp_lattice
(lower_lattice, upper_lattice) = reproduction.decode_rod_lattice(
temp_lattice, input_data.region_map, input_data.rod_list)
casmo = open(
'batch_' + str(batch) + '.lower_assembly.' + str(people + 1) +
'.inp', 'w')
pin_map = metrics.return_pin_map(lower_lattice)
line_number = 1
for line in lower_casmo_lines:
if (line_number == lower_skip):
casmo.write(pin_map)
next_gen_file.write('final_generation '+str(final_generation)+'\n')
next_gen_file.write('lower_skip '+str(lower_skip)+'\n')
next_gen_file.write('upper_skip '+str(upper_skip)+'\n')
next_gen_file.close()
casmo_functions.evaluate_bundles(batch_size,generation,population)
reproduction.merge_files('cost_list.txt','child_list.txt')
reproduction.tournament('parent_list.txt','child_list.txt')
lattice_list = reproduction.extract_lattices('parent_list.txt')
lattice_count = 0
for batch in xrange(number_batches):
for people in xrange(batch_size):
(lower_lattice,upper_lattice) = reproduction.decode_rod_lattice(new_lattice_list[lattice_count], input_data.region_map, input_data.rod_list)
casmo = open('final_batch_'+str(batch)+'.upper_assembly.'+str(people+1)+'.inp','w')
pin_map = metrics.return_pin_map(upper_lattice)
line_number = 1
for line in upper_casmo_lines:
if(line_number == lower_skip):
casmo.write(pin_map)
elif(line_number > lower_skip and line_number < upper_skip):
pass
else: casmo.write(line)
line_number+=1
casmo.close()
casmo = open('final_batch_'+str(batch)+'.lower_assembly.'+str(people+1)+'.inp','w')
for line in lower_casmo_lines:
if(line_number == lower_skip):
casmo.write(pin_map)
elif(line_number > lower_skip and line_number < upper_skip):
pass
casmo.close()
number_batches = population / batch_size
new_lattice_list = reproduction.extract_lattices('parent_list.txt')
lattice_count = 0
batch_number = 0
for lattice in new_lattice_list:
(lower_lattice,
upper_lattice) = reproduction.decode_rod_lattice(lattice,
input_data.region_map,
input_data.rod_list)
casmo = open(
'batch_' + str(batch_number) + '.lower_assembly.' +
str(lattice_count + 1) + '.inp', 'w')
pin_map = metrics.return_pin_map(lower_lattice)
line_number = 1
for line in lower_casmo_lines:
if (line_number == lower_skip):
casmo.write(pin_map)
elif (line_number > lower_skip and line_number <= upper_skip):
pass
else:
casmo.write(line)
line_number += 1
casmo.close()
lattice_count += 1
if (lattice_count == batch_size):
lattice_count = 0
batch_number += 1
