def read_all_hd( template, lu: list, ) -> list: # Initialisations hd = [] # Loop through all units for i in range(0, len(lu)): # Create the file path of the results file fp_r_f = create_fp_file(template, "Hausdorff Distance_" + lu[i] + "_2", "r") # Store the results from the file hd.append(linecache.getline(fp_r_f, 1)) # Clean the list hd = [i.rstrip() for i in hd] # Cast the list items to floats and check for any failed results (hd, hd_f) = utility.list_to_float(hd) # Output a warning if any models failed to deliver results if hd_f != 0: print("Warning: {} models failed to deliver results!".format(hd_f)) hd = list(map(abs, hd)) return hd
def open_v( template, l: str, ): """Open a variable saved to a file Parameters ---------- fp : str The file path Returns ------- The saved variable """ fp = file_paths.create_fp_file(template, l, "v") # Open the file to be read from f = open(fp, "rb") # Store the variable v = pickle.load(f) # Close the file f.close() return v
def save_v( template, v, l: str, ) -> None: """Save a variable as a file Parameters ---------- v : The variable to be saved l : str The file path """ fp = file_paths.create_fp_file(template, l, "v") # Open the file to be written to f = open(fp, 'wb') # Save the variable pickle.dump(v, f) # Close the file f.close() return
def read_val( template, l: str, ) -> float: """Read a specific value from a results file Parameters ---------- template The unit template parameters l : str The label for the results file Either a template or unit identifier Returns ------- float The found value """ # Create the file path of the results file fp_r_f = create_fp_file(template, l, "r") # Read the value as a float if possible try: val = float(linecache.getline(fp_r_f, template.n_steps + 1)) except: val = None return val
def save_numpy_array_to_csv( template, l: str, data: numpy.array, ) -> None: """Write the results to .csv files Parameters ---------- template The unit template parameters l : str The label of the data data : numpy.array The results to be stored """ # Create the file path of the results file fp_r_f = create_fp_file(template, l, "r") # Write the data to the results file numpy.savetxt(fp_r_f, data, delimiter=",") print("{}.csv saved".format(l)) return
def save_2d_list_to_csv( template, l: str, data: numpy.array, ) -> None: """Write the results to .csv files Parameters ---------- template The unit template parameters l : str The label of the data data : numpy.array The results to be stored """ # Create the file path of the results file fp_r_f = create_fp_file(template, l, "r") # Write the data to the results file with open(fp_r_f, 'w') as f: wr = csv.writer(f) wr.writerows(data) print("{}.csv saved".format(l)) return
def save_plot( template, t: str, tm: str, ) -> None: """Save a figure Parameters ---------- template The unit template parameters t : str The title of the graph tm : str The timestamp of the current simulation """ # Create the file path of the figure fp_p = file_paths.create_fp_file(template, t + tm, "g") plot.tight_layout() # Save the figure plot.savefig(fp_p, dpi = 300) # Close the figure plot.close() return
def create_fp_list( self, ext: str, ) -> list: """Create a list of unit file paths Parameters ---------- ext : str The extension to add to the file path Returns ------- list The list of file paths """ fp_list = [] for i in range(1, 4): fp_list.append( create_fp_file(self.template, "_job_{}.{}".format(i, ext), "u", self)) return fp_list
def internal_energy( template, l: str, ) -> None: """Calculate the internal energy for a unit Parameters ---------- template The unit template parameters l : str The label for the results file Either a template or unit identifier """ # Initialisations label = [] label.append("Comp 11 of Total Strain") label.append("Comp 22 of Total Strain") label.append("Total Strain Energy Density") label_i_e = [] label_i_e.append("Internal Energy X") label_i_e.append("Internal Energy Y") label_i_e.append("Internal Energy") s = numpy.zeros((len(label), template.n_steps + 1, template.n_n)) # Loop through all the variable labels for i in range(0, len(label)): # Create the file path of the results file fp_r_f = create_fp_file(template, label[i] + "_" + l, "r") # Store the results from the file s[i] = numpy.genfromtxt(fp_r_f, delimiter=",") # Loop through all the internal energy labels for i in range(0, len(label_i_e)): # Initialise the internal energy array i_e = numpy.zeros(len(s[i])) # Loop through every step in the unit for j in range(0, len(s[i])): # Loop through every external node for k in range(0, len(s[i, i])): # Calculate the internal energy for the current step i_e[j] += s[i, j, k] # Save the internal energy to a .csv file save_numpy_array_to_csv(template, label_i_e[i] + "_" + l, i_e) return
def read_all( template, lu: list, l: str, ) -> list: """Read all result values from a list of units and plot them Parameters ---------- l : str The result label lu : list The list of units template : template The unit template parameters Returns ------- list The list of values """ # Initialisations v = [] # Loop through all units for i in range(0, len(lu)): # Initialisations v.append([]) # Create the file path of the results file fp_r_f = create_fp_file(template, l + "_" + lu[i] + "_2", "r") # Store the results from the file v[i] = linecache.getline(fp_r_f, template.n_steps + 1) # Clean the list v = [i.rstrip() for i in v] # Cast the list items to floats and check for any failed results (v, v_f) = utility.list_to_float(v) # Output a warning if any models failed to deliver results if v_f != 0: print("Warning: {} models failed to deliver results!".format(v_f)) v = list(map(abs, v)) return v
def disp( template, l: str, ) -> list: """Read the displacement values for a unit Parameters ---------- template : template The unit template parameters l : str The label for the results file Either a template or unit identifier Returns ------- list The list of displacement values """ # Initialisations label = [] label.append("Displacement X") label.append("Displacement Y") d = numpy.zeros((len(label), template.n_steps + 1, template.n_n)) # Loop through the list of labels for i in range(0, len(label)): # Create the file path of the results file fp_r_f = create_fp_file(template, label[i] + "_" + l, "r") # Store the results from the file d[i] = numpy.genfromtxt(fp_r_f, delimiter=",") # Decrement the node IDs of the external nodes by 1 to be used as array indices n_external_i = [i - 1 for i in template.n_external] # Store only the external node values d_ex = d[:, :, n_external_i] # Store only the final values in the simulation d_ex = d_ex[:, template.n_steps] return d_ex
def read_all_fit( template, lu: list, ) -> list: if template.case == 1: # Initialisations r = [] w = [] # Loop through all units for i in range(0, len(lu)): # Create the file path of the results file fp_r_f = create_fp_file(template, "Case 1 Fitness Measures_" + lu[i] + "_2", "r") # Store the results from the file r.append(linecache.getline(fp_r_f, 1)) w.append(linecache.getline(fp_r_f, 2)) # Clean the list r = [i.rstrip() for i in r] w = [i.rstrip() for i in w] # Cast the list items to floats and check for any failed results (r, r_f) = utility.list_to_float(r) (w, w_f) = utility.list_to_float(w) # Output a warning if any models failed to deliver results if r_f != 0: print("Warning: {} models failed to deliver results!".format(r_f)) if w_f != 0: print("Warning: {} models failed to deliver results!".format(w_f)) r = list(map(abs, r)) w = list(map(abs, w)) fit_m = [r, w] return fit_m
def run_units( template, l_u: list, meth: str, ) -> [list, str, str]: """Run a list of units Parameters ---------- template : template The unit template parameters l_u : list The list of unit parameters meth : str The unit generation method l: L-Systems c: CPPNs r: Random Returns ------- [str, str] The file paths of the list of units generated and ranked """ # The time the unit generation starts as a string label t = time.strftime("_%Y-%m-%d--%H-%M-%S", time.gmtime()) # Create the file paths of the log files of units created during the simulation # 0: all # 1: successful # 2: failed # 3: empty # 4: full # 5: ranked fp_lu = [ create_fp_file(template, t, "l"), create_fp_file(template, t + "_success", "l"), create_fp_file(template, t + "_failed", "l"), create_fp_file(template, t + "_empty", "l"), create_fp_file(template, t + "_full", "l"), create_fp_file(template, t + "_ranked", "l") ] # Run the empty and full units empty_id, full_id = empty_full(template, fp_lu) # Loop through the list of units generated for i in l_u: # Open the template file modify.open_model(template.fp_t_mud) # Generate the grid with elements removed, search for any free element clusters, and update the grid and list grid_rem, rem = gen_grid_rem_free(template, i[0]) # Check if all internal elements were removed from the current unit if len(rem) == len(template.e_internal): # Add an exception for an empty unit add_exc(template, fp_lu, rem, grid_rem, empty_id, meth, i[1]) elif len(rem) == 0: # Add an exception for an empty unit add_exc(template, fp_lu, rem, grid_rem, full_id, meth, i[1]) else: # Check if the unit generation method is set to L-Systems if meth == "l": # Remove the elements, save and run the model and obtain the desired results rem_el_run_results(template, rem, grid_rem, fp_lu, ls=i[1]) # Check if the unit generation method is set to CPPNs elif meth == "c": # Remove the elements, save and run the model and obtain the desired results rem_el_run_results(template, rem, grid_rem, fp_lu, cp=i[1]) # Check if the unit generation method is set to random else: # Remove the elements, save and run the model and obtain the desired results rem_el_run_results(template, rem, grid_rem, fp_lu) return fp_lu, empty_id, full_id
def constraint_energy( template, l: str, ) -> None: """Calculate the constraint energy for a unit Parameters ---------- template : template The unit template parameters l : str The label for the results file Either a template or unit identifier """ # Initialisations label = [] label.append("Displacement X") label.append("Displacement Y") label.append("Displacement") label.append("Reaction Force X") label.append("Reaction Force Y") label.append("Reaction Force") label_c_e = [] label_c_e.append("Constraint Energy X") label_c_e.append("Constraint Energy Y") label_c_e.append("Constraint Energy") v = numpy.zeros((len(label), template.n_steps + 1, template.n_n)) # Loop through all the variable labels for i in range(0, len(label)): # Create the file path of the results file fp_r_f = create_fp_file(template, label[i] + "_" + l, "r") # Store the results from the file v[i] = numpy.genfromtxt(fp_r_f, delimiter=",") # Decrement the node IDs of the external nodes by 1 to be used as array indices n_external_i = [i - 1 for i in template.n_external] # Store only the external node values v_ex = v[:, :, n_external_i] # Loop through every constraint energy label for i in range(0, len(label_c_e)): # Initialise the constraint energy array c_e = numpy.zeros(len(v_ex[i])) # Loop through every step in the unit for j in range(0, len(v_ex[i])): # Loop through every external node for k in range(0, len(v_ex[i, i])): # Calculate the constraint energy for the current step c_e[j] += v_ex[i, j, k] * v_ex[i + len(label_c_e), j, k] / 1000 # Save the constraint energy to a .csv file save_numpy_array_to_csv(template, label_c_e[i] + "_" + l, c_e) return
class template: """Unit template parameters """ def __init__( self, case: int, x_e: int, y_e: int, e_s: float, b: int, ogd_mat: ogd_mat, n_steps: int, tab_nam: str, d_mag: float, p_mag: float, run_success: bool = False, c_e: list = [0, 0, 0], i_e: list = [0, 0, 0], ) -> None: """[summary] Parameters ---------- case : int The unit template case identifier x_e : int The number of elements in the x-direction y_e : int The number of elements in the y-direction e_s : float The element size in mm b : int The number of elements in the boundary of the unit ogd_mat : ogd_mat The Ogden material model n_steps : int The number of steps in the second of the simulation tab_nam : str The name of the table containing the function of the load to be applied d_mag : float The magnitude of the applied displacement in mm p_mag : float The magnitude of the applied internal pressure in MPa run_success : bool, optional The success of the unit template's run, by default False c_e : list, optional The constraint energy of the unit template, by default [0, 0, 0] i_e : list, optional The internal energy of the unit template, by default [0, 0, 0] """ self.case = case if x_e % 2 == 0: self.x_e = x_e + 1 else: self.x_e = x_e if y_e % 2 == 0: self.y_e = y_e + 1 else: self.y_e = y_e self.e_s = e_s self.b = b self.ogd_mat = ogd_mat self.n_steps = n_steps self.tab_nam = tab_nam self.d_mag = d_mag self.p_mag = p_mag self.run_success = run_success self.c_e = c_e self.i_e = i_e self.x_s = self.e_s * self.x_e self.y_s = self.e_s * self.x_e # The number of nodes in the x-direction self.x_n = self.x_e + 1 # The number of nodes in the y-direction self.y_n = self.y_e + 1 # The total number of elements self.n_e = self.x_e * self.y_e # The total number of nodes self.n_n = self.x_n * self.y_n # The list of internal elements self.e_internal = inspect.find_e_internal(self.x_e, self.y_e, self.b) # The list of external nodes self.n_external = inspect.find_n_external(self.x_n, self.y_n) # The total number of elements as a string label self.n_e_l = utility.list_to_str([self.x_e, self.y_e], "x") # The size of the grid as a string label self.s_l = utility.list_to_str([self.x_s, self.y_s], "x") # The template ID self.t_id = str( self.case) + "_" + self.n_e_l + "_" + self.s_l + "_" + str(self.b) # The representative grid of ones self.grid = rep_grid.create_grid(self.x_e, self.y_e, 1) # The file path of the template file self.fp_t_mud = create_fp_file(self, ".mud", "t") # The file path of the template file log self.fp_t_log = create_fp_file(self, "_job_1.log", "t") # The file path of the unit t16 file self.fp_t_t16 = create_fp_file(self, "_job_1.t16", "t") # The file path of the template file log self.fp_t_l = create_fp_file(self, ".log", "t")
def __init__( self, template: template, rem: list, grid: list, ls=None, cp=None, run_success: bool = False, c_e: list = [0, 0, 0], i_e: list = [0, 0, 0], d: list = [], ) -> None: """The unit parameters Parameters ---------- template : template The unit template parameters rem : list The list of elements removed from the unit grid : list The representative grid with the elements removed ls : lsystem, optional The L-System, by default None cp : cppn_i, optional The CPPN model, by default None run_success : bool, optional The success of the unit's run, by default False c_e : list, optional The constraint energy of the unit template, by default [0, 0, 0] i_e : list, optional The internal energy of the unit template, by default [0, 0, 0] d : list, optional [description], by default [] """ self.template = template self.rem = rem self.grid = grid self.ls = ls self.cp = cp self.run_success = run_success self.c_e = c_e self.i_e = i_e self.d = d # The list of elements removed from the unit as a string self.rem_l = utility.list_to_str(rem, "_") # Generate the unique unit ID according to the method of unit generation if self.ls != None: self.u_id = str(len(self.rem)) + "_" + utility.gen_hash( utility.list_to_str(self.ls.gramm, "_")) elif self.cp != None: self.u_id = str(len(self.rem)) + "_" + str( self.cp.mod_id) + "_" + str(self.cp.cppn.seed) + "_" + str( self.cp.cppn.scale) + "_" + str( self.cp.cppn.hl_n) + "_" + str( self.cp.cppn.hl_s) + "_" + str(self.cp.cppn.thresh) else: self.u_id = str(len(self.rem)) + "_" + utility.gen_hash(self.rem_l) # The representative grid with the elements removed as a string label self.grid_l = self.format_grid() # The file path of the unit file self.fp_u_mud = create_fp_file(self.template, ".mud", "u", self) # The file path of the unit log file self.fp_u_log = self.create_fp_list("log") # The file path of the unit t16 file self.fp_u_t16 = self.create_fp_list("t16") # The file path of the unit file log self.fp_u_l = create_fp_file(self.template, ".log", "u", self)
def main(): # Reload the modules importlib.reload(classes) importlib.reload(file_paths) importlib.reload(plotting) importlib.reload(utility) importlib.reload(cppns) importlib.reload(gen_alg) importlib.reload(lsystems) importlib.reload(analyse) importlib.reload(obtain) importlib.reload(create) importlib.reload(inspect) importlib.reload(modify) importlib.reload(rep_grid) # Initialisations # The template case identifier case = 1 # The number of elements in each axis direction x_e = 15 y_e = 15 # The length of each side in mm e_s = 10 # The thickness of the unit boundary b = 3 # The number of increments per second to analyse n_steps = 5 # The text name of the table used for the applied displacement and load table_name = "ramp_input" # The magnitude of the applied displacement in mm d_mag = y_e*e_s/2 # The magnitude of the applied internal pressure in MPa p_mag = 0.025 # The unit generation method g_meth = "r" # The analysis method a_meth = "g" # Genetic algorithm parameters gen = 15 prob = [0.5, 0.1, 0.5] point = [1, 2, 2] # Prepare the unit parameters temp = classes.template(case, x_e, y_e, e_s, b, classes.mold_star_15, n_steps, table_name, d_mag, p_mag) # for i in range(1, 10): # l = lsystems.lsystem(lsystems.e_vocabulary, [["F", "FF++f"], ["f", "--FFF"]], lsystems.a_rot_hor, i) # c = lsystems.interpret_word_raw(l.word) # grid = utility.coord_to_grid(c) # plotting.grid_plot(temp, "_layout", grid, "ls_" + str(i)) # for xy in range (5, 31, 5): # c = cppns.cppn(29, 29, 2, 11, 23, 42, xy, xy) # c_i = cppns.cppn_i(c, 28) # plotting.grid_plot(temp, "_layout", c_i.grid, "cppn_" + str(xy)) t = "_2020-10-28--16-00-12" # 2020-10-29--14-18-46 # 2020-11-14--07-51-17 # 2020-10-28--16-00-12 # 2020-11-19--12-47-03 # Generate the grid with all elements removed grid_rem_e, rem_e = create.gen_grid_rem_free(temp, temp.e_internal) # Generate the unit ID of the empty unit empty_id = str(len(rem_e)) + "_" + utility.gen_hash(utility.list_to_str(rem_e, "_")) # Generate the grid with all elements removed grid_rem_f, rem_f = create.gen_grid_rem_free(temp, []) # Generate the unit ID of the full unit full_id = str(len(rem_f)) + "_" + utility.gen_hash(utility.list_to_str(rem_f, "_")) fp_lu = [create_fp_file(temp, t, "l"), create_fp_file(temp, t + "_success", "l"), create_fp_file(temp, t + "_failed", "l"), create_fp_file(temp, t + "_empty", "l"), create_fp_file(temp, t + "_full", "l"), create_fp_file(temp, t + "_ranked", "l")] data = analyse.rank_u(temp, g_meth, empty_id, full_id, fp_lu) data["Constraint Energy"] = data["Constraint Energy"]*1000 data = data[(data["Constraint Energy"] >= 0) & (data["Constraint Energy"] < 0.1)] plotting.hist(temp, t, data, "Constraint Energy") plotting.hist(temp, t, data, "Internal Energy") # data_x = ["Number of Hidden Layers", "Size of the Initial Hidden Layer"] data_y = ["Constraint Energy", "Internal Energy"] # plotting.scat_all(temp, t, data, ["Size of the Initial Hidden Layer"], data_y) # plotting.boxp_all(temp, t, data, ["Number of Hidden Layers"], data_y) plotting.lreg_all(temp, t, data, ["Number of Elements Removed"], data_y) return