def mutate(self, list_of_individuals):
### Currently only works on a material-basis
#print("MUTATING!!!")
if self.options['mutation_type'] == 'bitwise':
#print("BITWISE!", len(list_of_individuals))
for ind_count, individual in enumerate(list_of_individuals):
#print("MUTATING:", ind_count)
original_material_matrix = copy.deepcopy(
individual.material_matrix)
individual.material_matrix = self.single_bit_mutation(
original_material_matrix)
if self.options['verify_fuel_mass_after_mutation']:
### Checking if new child meets fuel # requirement
fuel_count = individual.count_material(1)
# try_count = 0
while (
(fuel_count > self.options['maximum_fuel_elements']) or
(fuel_count < self.options['minimum_fuel_elements'])):
individual.material_matrix = self.single_bit_mutation(
original_material_matrix)
fuel_count = individual.count_material(1)
# print("mutation fuel count:", fuel_count)
# try_count += 1
# print("fixed mutation in:", try_count, "tries")
return list_of_individuals
def write_options_funct(self, output_file, individual):
write_string = ""
for write_option in self.options['output_writeout_values']:
if write_option == 'generation':
write_string += str(self.generation) + ","
if write_option == 'individual_count':
write_string += str(individual.ind_count) + ","
if write_option == 'keff':
write_string += str(individual.keff) + ","
if write_option == 'materials':
write_string += str(individual.make_material_string_csv())
if write_option == 'input_name':
try:
write_string += str(individual.scale_input_filename) + ','
except:
write_string += "N/A,"
if write_option == 'number_of_fuel':
write_string += str(individual.count_material(1)) + ','
if write_option == 'write_out_parents':
write_string += str(individual.parent_string) + ','
if write_option == 'write_out_average_diversity_score':
if self.options['choose_parent_based_on_bitwise_diversity'] == True:
try:
average_tds = individual.total_diversity_score / (self.options['number_of_parents'] - 1)
write_string += str(average_tds) + ','
except:
write_string += "N/A,"
return write_string
def write_options_funct(self, output_file, individual):
write_string = ""
for write_option in self.options['output_writeout_values']:
if "#" in write_option:
write_option_split = write_option.split("#")
write_option = write_option_split[0]
if write_option == 'generation':
write_string += str(self.generation) + ","
if write_option == 'individual_count':
write_string += str(individual.ind_count) + ","
if write_option == 'keff':
write_string += str(individual.keff) + ","
if write_option == 'front_rank':
try:
write_string += str(individual.front_rank) + ","
except:
write_string += "N/A,"
if write_option == 'crowding_distance':
try:
write_string += str(individual.crowding_distance) + ","
except:
write_string += "N/A,"
if write_option == 'total_flux':
try:
write_string += str(individual.total_flux) + ","
except:
write_string += "N/A,"
if write_option == 'representativity':
try:
write_string += str(individual.representativity) + ","
except:
write_string += "N/A,"
if write_option == 'materials':
write_string += str(individual.make_material_string_csv())
if write_option == 'input_name':
try:
write_string += str(individual.input_file_string) + ','
except:
write_string += "N/A,"
if write_option == 'number_of_fuel':
write_string += str(individual.count_material(1)) + ','
if write_option == 'write_out_parents':
write_string += str(individual.parent_string) + ','
if write_option == 'write_out_average_diversity_score':
if self.options[
'choose_parent_based_on_bitwise_diversity'] == True:
try:
average_tds = individual.total_diversity_score / (
self.options['number_of_parents'] - 1)
write_string += str(average_tds) + ','
except:
write_string += "N/A,"
else:
write_string += "N/A,"
return write_string
def bitwise_crossover(self, parent_1, parent_2):
child_ind = individual.individual(self.options, self.generation,
self.individual_count)
self.individual_count += 1
# print("parent 1 pattern:", parent_1.material_matrix)
# print("parent 2 pattern:", parent_2.material_matrix)
# print("Child pattern before:", child_ind.material_matrix, child_ind.ind_count)
temp_material_master_list = []
for material_list_count, material_list in enumerate(
parent_1.material_matrix):
temp_material_list = []
for material_count, material in enumerate(material_list):
selection = random.randint(0, 1)
material = parent_1.material_matrix[material_list_count][
material_count]
if selection == 1:
material = parent_2.material_matrix[material_list_count][
material_count]
temp_material_list.append(material)
temp_material_master_list.append(temp_material_list)
child_ind.material_matrix = temp_material_master_list
# print("Child pattern after:", child_ind.material_matrix)
return child_ind
def mutate(self):
### Currently only works on a material-basis
if self.options['mutation_type'] == 'bitwise':
for ind_count, individual in enumerate(self.individuals):
### Will not mutate parents/elite population
if ind_count < self.options['number_of_parents']:
continue
original_material_matrix = copy.deepcopy(individual.material_matrix)
individual.material_matrix = self.single_bit_mutation(original_material_matrix)
if self.options['verify_fuel_mass_after_mutation']:
### Checking if new child meets fuel # requirement
fuel_count = individual.count_material(1)
# try_count = 0
while ((fuel_count > self.options['maximum_fuel_elements']) or (
fuel_count < self.options['minimum_fuel_elements'])):
individual.material_matrix = self.single_bit_mutation(original_material_matrix)
fuel_count = individual.count_material(1)
def evaluate(self, evaluation_type, list_of_individuals):
scale_inputs = []
if evaluation_type == 'representivitiy':
print("Solving for representivity")
if 'mcnp' in self.options['solver']:
self.mcnp_inputs = []
mcnp_file_handler = MCNP_File_Handler.mcnp_file_handler()
for individual in list_of_individuals:
### Building MCNP input file
print(individual.create_discrete_material_mcnp_dictionary(self.options['keywords_list']))
mcnp_file_handler.write_mcnp_input(template_file = self.options['mcnp_template_file_string'],
dictionary_of_replacements = individual.create_discrete_material_mcnp_dictionary(self.options['keywords_list']),
input_file_str = individual.input_file_string)
mcnp_file_handler.run_mcnp_input(individual.input_file_string)
self.mcnp_inputs.append(individual.input_file_string)
self.wait_on_jobs('mcnp')
print("")
if evaluation_type == 'keff':
if 'scale' in self.options['solver']:
### create scale inputs, add filenames to list
for individual in self.individuals:
if individual.evaluated == False:
if self.options['geometry'] == 'cyl':
individual.make_material_string('cyl_materials')
elif self.options['geometry'] == 'grid':
individual.make_material_string('%array%1')
else:
print("Geometry not handled in evaluate function")
exit()
scale_inputs.append(individual.setup_scale(self.generation))
individual.evaluated = True
if self.options['fake_fitness_debug']:
individual.keff = random.uniform(0.5, 1.5)
self.scale_inputs = scale_inputs
### submitting all jobs and waiting on all jobs
if self.options['solver_location'] == 'necluster':
self.submit_jobs(self.scale_inputs)
self.wait_on_jobs('scale')
if self.options['solver_location'] == 'local':
print("Cant run scale locally... yet... fix this")
exit()
for individual in self.individuals:
individual.get_scale_keff()
else:
print("Not able to evaluate keff with mcnp yet")
def singlepoint_crossover(self, parent_1, parent_2):
child_ind = individual.individual(self.options, self.generation)
temp_material_master_list = []
for material_list_count, material_list in enumerate(child_ind.material_matrix):
temp_material_list = []
ml_length = len(material_list) - 1
singlepoint_value = random.randint(1, ml_length)
temp_material_list = parent_1.material_matrix[material_list_count][0:singlepoint_value] + \
parent_2.material_matrix[material_list_count][singlepoint_value - 1:ml_length]
temp_material_master_list.append(temp_material_list)
child_ind.material_matrix = temp_material_master_list
return child_ind
def enforce_fuel_count(self):
for individual in self.individuals:
fuel_count = individual.count_material(1)
if fuel_count != self.options['enforced_fuel_count_value']:
individual.fix_material_count(1, self.options['enforced_fuel_count_value'])
def __init__(self, options_dict):
print("Initializing GA with:", options_dict)
self.options = options_dict
self.individuals = []
self.generation = 0
self.individual_count = 0
### Creating initial population
for ind in range(self.options['number_of_individuals']):
self.individuals.append(individual.individual(options_dict, self.generation, self.individual_count))
self.individual_count += 1
### Loading CNN if needed
#if 'cnn' in self.options['solver']:
# model_string = "CNN_3d_11x11_fm_cad_4x4_kern_v2.hdf5"
# self.cnn_handler = CNN_Handler.CNN_handler(model_string)
# self.cnn_input = []
if self.options['include_pattern']:
for ind_count, pattern_to_include in enumerate(self.options['pattern_to_include']):
for _ in self.individuals[ind_count].material_matrix:
print(_)
self.individuals[ind_count].material_matrix = pattern_to_include
self.individuals[ind_count].make_material_string('%array%1')
for _ in self.individuals[ind_count].material_matrix:
print(_)
if self.options['enforce_fuel_count']:
print("enforcing fuel count:", self.options['enforced_fuel_count_value'])
for ind_count, ind in enumerate(self.individuals):
ind.enforce_material_count(1, self.options['enforced_fuel_count_value'])
### Creating output csv if needed
if self.options['write_output_csv']:
output_csv = open(self.options['output_filename'] + '.csv', 'w')
for flag in self.options:
output_csv.write("{},{}\n".format(flag, self.options[flag]))
output_csv.close()
### Evaluating initial population, gen 0
print("Evaluating initial population")
self.evaluate(self.options['fitness'], self.individuals)
self.individuals.sort(key=lambda x: getattr(x, self.options['fitness']), reverse=True)
### Evaluating diversity of population
if self.options['choose_parent_based_on_bitwise_diversity']:
print("Evaluating diversity of parents")
self.evaluate_bitwise_diversity_of_parents()
self.write_output()
self.generation += 1
### Running GA algo
for generation in range(self.options['number_of_generations']):
print("Generation: ", self.generation)
print("crossover")
self.crossover()
print("mutate")
self.mutate()
if self.options['enforce_fuel_count']:
print("enforcing fuel count:", self.options['enforced_fuel_count_value'])
for ind_count, ind in enumerate(self.individuals):
ind.enforce_material_count(1, self.options['enforced_fuel_count_value'])
print("evaluate")
self.evaluate(self.options['fitness'])
print("sort")
self.individuals.sort(key=lambda x: x.keff, reverse=True)
### Evaluating diversity of population
if self.options['choose_parent_based_on_bitwise_diversity']:
print("Evaluating diversity of parents")
self.evaluate_bitwise_diversity_of_parents()
print("write output")
if self.options['write_output_csv']:
self.write_output()
self.generation += 1
def apply_constraint(self, list_of_individuals, constraint_type):
print("Applying constraint:", constraint_type)
meet_constraint = False
### Seperating constraint and options, etc.
constraint_split = constraint_type.split("#")
constraint_type_ = constraint_split[0]
constraint_run_location = constraint_split[1]
constraint_options = constraint_split[2]
if constraint_type_ == 'keff':
if 'mcnp' in self.options['solver']:
self.mcnp_keff_inputs = []
self.mcnp_file_handler = MCNP_File_Handler.mcnp_file_handler()
for individual in list_of_individuals:
### Building MCNP input file
data_dictionary_ = individual.create_discrete_material_mcnp_dictionary(
self.options['keywords_list'])
### Finding and adding the fuel location to geometry dictionary
data_dictionary_['kcode_source_x'] = str(
individual.find_fuel_location())
### Building MCNP input
self.mcnp_file_handler.write_mcnp_input(
template_file=self.
options['mcnp_keff_template_file_string'],
dictionary_of_replacements=data_dictionary_,
input_file_str=individual.keff_input_file_string)
### Building MCNP input script for cluster
self.mcnp_file_handler.build_mcnp_running_script(
individual.keff_input_file_string)
### Running MCNP input
self.mcnp_file_handler.run_mcnp_input(
individual.keff_input_file_string)
### Adding input name to list, used to determine if the jobs have completed or not
self.mcnp_keff_inputs.append(
individual.keff_input_file_string)
### Waits on the jobs to be completed (looking for "_done.dat" files)
self.wait_on_jobs('mcnp_keff')
### Grabs keff from the output files
for ind in list_of_individuals:
if self.options['fake_fitness_debug']:
ind.keff = random.uniform(0.5, 1.5)
else:
ind.keff = self.mcnp_file_handler.get_keff(
ind.keff_input_file_string)
### If that keff is above a set threshold, sets acceptable_eigenvalue to false. Else, sets it True.
if float(ind.keff
) >= self.options['enforced_maximum_eigenvalue']:
print("keff, ", ind.keff,
"too high. Skipping source calculation")
ind.acceptable_eigenvalue = False
else:
ind.acceptable_eigenvalue = True
#if 'scale' in self.options['solver']:
### create scale inputs, add filenames to list
#for individual in self.individuals:
#if individual.evaluated_keff == False:
#if self.options['geometry'] == 'cyl':
# individual.make_material_string_scale('cyl_materials')
#elif self.options['geometry'] == 'grid':
# individual.make_material_string_scale('%array%1')
#else:
# print("Geometry not handled in evaluate function")
# exit()
#scale_inputs.append(individual.setup_scale(self.generation))
#individual.evaluated_keff = True
#if self.options['fake_fitness_debug']:
# individual.keff = random.uniform(0.5, 1.5)
#self.scale_inputs = scale_inputs
### submitting all jobs and waiting on all jobs
#if self.options['solver_location'] == 'necluster':
# self.submit_jobs(self.scale_inputs)
# self.wait_on_jobs('scale')
#if self.options['solver_location'] == 'local':
# print("Cant run scale locally... yet... fix this")
# exit()
#for individual in self.individuals:
# individual.get_scale_keff()
### If "default_sort" in constraint definition, sorting individuals by
if "default_sort" in constraint_type:
list_of_individuals.sort(key=lambda x: x.keff, reverse=False)
return list_of_individuals
def __init__(self, options_dict):
self.mcnp_file_handler = MCNP_File_Handler.mcnp_file_handler()
print("Initializing GA with:", options_dict)
self.options = options_dict
### List of current generation individuals
self.individuals = []
random.seed(self.options['python_random_number_seed'])
self.generation = 0
self.individual_count = 0
### Creating initial population
for ind in range(self.options['number_of_individuals']):
self.individuals.append(
individual.individual(options_dict, self.generation,
self.individual_count))
self.individual_count += 1
if self.options['remake_duplicate_children'] == True:
self.all_individuals = copy.deepcopy(self.individuals)
print("All individuals:", self.all_individuals)
### Loading CNN if needed
#if 'cnn' in self.options['solver']:
# model_string = "CNN_3d_11x11_fm_cad_4x4_kern_v2.hdf5"
# self.cnn_handler = CNN_Handler.CNN_handler(model_string)
# self.cnn_input = []
if self.options['include_pattern']:
print("Including a pattern in initial population!")
for ind_count, pattern_to_include in enumerate(
self.options['pattern_to_include']):
self.individuals[ind_count].material_matrix = []
for material in pattern_to_include:
self.individuals[ind_count].material_matrix.append(
[material])
self.individuals[ind_count].make_material_string_scale(
'%array%1')
if self.options['enforce_material_count']:
print("enforcing material",
self.options['enforce_material_number'], ' count:',
self.options['enforced_fuel_count_value'])
for ind_count, ind in enumerate(self.individuals):
ind.enforce_material_count(
self.options['enforce_material_number'],
self.options['enforced_fuel_count_value'])
### Creating output csv if needed
if self.options['write_output_csv']:
output_csv = open(self.options['output_filename'] + '.csv', 'w')
### Writing out options for this run
for flag in self.options:
output_csv.write("{},{}\n".format(flag, self.options[flag]))
output_csv.write("%%%begin_data%%%\n")
output_csv.write(self.create_header() + "\n")
output_csv.close()
### Running eigenvalue calcs if needed
#if self.options['enforced_maximum_eigenvalue'] == True:
# getattr(self, self.options['check_eigenvalue_function'])()
### Evaluating initial population, gen 0
print("Evaluating initial population")
self.evaluate(self.options['fitness'])
if self.options['use_non_dominated_sorting'] == True:
self.parents_list = self.non_dominated_sorting()
else:
self.individuals.sort(
key=lambda x: getattr(x, self.options['fitness_sort_by']),
reverse=True)
### Pairing down individuals to be specified number
self.individuals = self.individuals[:self.options[
'number_of_individuals']]
### Evaluating diversity of population
if self.options['choose_parent_based_on_bitwise_diversity']:
print("Evaluating diversity of parents")
self.evaluate_bitwise_diversity_of_parents()
self.write_output_v2(self.parents_list)
self.generation += 1
### Running GA algo
for generation in range(self.options['number_of_generations']):
print("Generation: ", self.generation)
print("crossover")
list_of_children = self.crossover()
print("mutating")
list_of_mutated_children = self.mutate(list_of_children)
if self.options['remake_duplicate_children'] == True:
list_of_mutated_children = self.remake_duplicate_children(
list_of_mutated_children, self.all_individuals)
self.all_individuals += list_of_mutated_children
if self.options['enforce_material_count']:
print("enforcing fuel count:",
self.options['enforced_fuel_count_value'])
for ind_count, ind in enumerate(list_of_mutated_children):
ind.enforce_material_count(
self.options['enforce_material_number'],
self.options['enforced_fuel_count_value'])
print("evaluating children")
self.evaluate(self.options['fitness'], list_of_mutated_children)
#for ind_count, ind_ in enumerate(list_of_mutated_children):
# print(ind_count, ind_.ind_count, ind_.generation, ind_.representativity)
#print("CHILDREN:::")
#for ind_count, ind_ in enumerate(list_of_mutated_children):
#print(ind_count, ind_.ind_count, ind_.generation, ind_.representativity)
### Checking if any of the children have already been created/evaluated
### combining now evaluated children with previous list of individuals
self.individuals = self.parents_list + list_of_mutated_children
print("All individuals in this generation!")
for ind_count, ind_ in enumerate(self.individuals):
print(ind_count, ind_.ind_count, ind_.generation, ind_.keff,
ind_.representativity)
print("write output")
if self.options['write_output_csv']:
self.write_output_v2(self.parents_list)
self.generation += 1
if self.options['remake_duplicate_children'] == True:
self.all_individuals += list_of_mutated_children
#print("Printing all individuals!")
#for ind_ in self.all_individuals:
#print(ind_.input_file_string, ind_.representativity)
if self.options[
'output_all_individuals_at_end_of_calculation'] == True:
output_csv = open(
self.options[
'output_all_individuals_at_end_of_calculation_file_name'] +
'.csv', 'w')
for flag in self.options:
output_csv.write("{},{}\n".format(flag, self.options[flag]))
output_csv.close()
print(self.options[
'output_all_individuals_at_end_of_calculation_file_name'])
self.write_output_v2(
list_of_individuals=self.all_individuals,
output_file_name=self.options[
'output_all_individuals_at_end_of_calculation_file_name'])