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'])