def events_strain_visualization_old(path_to_data_dir, list_of_test_id): """ this function visualize/plot the strains for each events listed in tests in list_of_test_id plt.savefig if len(list_of_test_id) == 1: plt.show() """ test_id = ["test%s" % i for i in list_of_test_id] path_to_final_selected_events = path_to_data_dir + "final_selected_events.json" if os.path.exists(path_to_final_selected_events): final_selected_events = json.load( open(path_to_final_selected_events, "r")) final_interested_events = [] for event in final_selected_events: if event[0] in test_id: final_interested_events.append(event) for event in final_interested_events: single_event_strain_visualization(path_to_data_dir, event) else: for test in list_of_test_id: path_to_test_dir = data_dir_to_test_dir(path_to_data_dir, test) path_to_test_result = path_to_test_dir + "/results" path_to_event_list = path_to_test_result + "/selected_events.json" if os.path.exists(path_to_event_list): event_list = json.load(open(path_to_event_list, "r")) for value in event_list.values(): event = ["test%s" % test, [value[0], value[1], value[2]]] single_event_strain_visualization(path_to_data_dir, event) else: print "skip current test:", "test%s" % test, "there is no selected events" print "done plotting for the interested tests whose test_id is in the list", list_of_test_id
def single_event_local_atoms(event,path_to_data_dir,model,feature,target,residual_threshold =0.5): """ this function developed correlation model between feature and target for a single event whose state is saved into event return: num_of_local_atom: a list num_of_local_atom for init_sad, sad_fin, init_fin """ if 'test' in event[0]: test_id = int(event[0][4:]) else: test_id = int(event[0]) path_to_test_dir = data_dir_to_test_dir(path_to_data_dir, test_id) path_to_curr_result = path_to_test_dir + "/results" init,sad,fin = event[1][0], event[1][1], event[1][2] path_to_curr_event = path_to_curr_result + "/event_" + init + "_" + sad + "_" + fin path_to_init_sad = path_to_curr_event + "/init_sad" path_to_sad_fin = path_to_curr_event + "/sad_fin" path_to_init_fin = path_to_curr_event + "/init_fin" if feature == "displacement" and target == "shear_strain": init_sad_X,init_sad_y = get_strain_disp(path_to_init_sad) sad_fin_X,sad_fin_y = get_strain_disp(path_to_sad_fin) init_fin_X,init_fin_y = get_strain_disp(path_to_init_fin) init_sad = outlier_detector(init_sad_X,init_sad_y,model,residual_threshold) sad_fin = outlier_detector(sad_fin_X,sad_fin_y,model,residual_threshold) init_fin = outlier_detector(init_fin_X,init_fin_y,model,residual_threshold) return [init_sad, sad_fin, init_fin]
def single_event_adder(event_state, path_to_data_dir,db): if 'test' in event_state[0]: test_id = int(event_state[0][4:]) else: test_id = int(event_state[0]) path_to_test_dir = data_dir_to_test_dir(path_to_data_dir, test_id) path_to_curr_result = path_to_test_dir + "/results" init, sad, fin = event_state[1][0], event_state[1][1], event_state[1][2] path_to_curr_event = path_to_curr_result + "/event_" + init + "_" + sad + "_" + fin path_to_file_ini = path_to_test_dir + '/' + init + ".dump" path_to_file_sad = path_to_test_dir + '/' + sad + ".dump" path_to_file_fin = path_to_test_dir + '/' + fin + ".dump" initial_config_data = read_data_from_file(path_to_file_ini)[['x','y','z']] saddle_config_data = read_data_from_file(path_to_file_sad)[['x','y','z']] final_config_data = read_data_from_file(path_to_file_fin)[['x','y','z']] test_eng = event_energy(path_to_test_dir) ini_eng = test_eng[init] sad_eng = test_eng[sad] fin_eng = test_eng[fin] minimum1 = db.addMinimum(ini_eng, np.array(initial_config_data)) minimum2 = db.addMinimum(fin_eng, np.array(final_config_data)) trans = db.addTransitionState(sad_eng, np.array(saddle_config_data), minimum1, minimum2) return
def filter_events_all_tests_stage_1(path_to_data_dir, input_param, save_results=True, re_calc=False): """ this function implement stage 1 two criteria to remove a single event which does not satisfy stage 1 two criteria and finally save the filtered events into a selected_event.json """ list_of_test_id = input_param["list_of_test_id"] existed_tests = [] for i in list_of_test_id: try: path_to_curr_test = data_dir_to_test_dir(path_to_data_dir, i) existed_tests.append(i) except Exception: pass list_of_test_id = existed_tests box_dim = input_param["box_dim"] # preferably use the re_calc and num_of_proc in input_param if "num_of_proc" in input_param and "re_calc" in input_param: num_of_proc = input_param["num_of_proc"] re_calc = input_param["re_calc"] pool = mp.Pool(processes=num_of_proc) num_of_events = len(list_of_test_id) test_lists = [] for i in xrange(num_of_events): path_to_curr_test = data_dir_to_test_dir(path_to_data_dir, list_of_test_id[i]) test_lists.append(path_to_curr_test) result = pool.map( partial(event_selection, box_dim=box_dim, save_results=True, re_calc=re_calc), test_lists) print "done filtering events for all tests in list_of_test_id for stage 1"
def single_event_voronoi_classifier(event_state, path_to_data_dir): """ this function load the calculated voronoi index results file voronoi_index_results.json classify the vornoi index into ICO, ICO_LIKE, GUM according to the criterion defined at the top level of the module """ if 'test' in event_state[0]: test_id = int(event_state[0][4:]) else: test_id = int(event_state[0]) path_to_test_dir = data_dir_to_test_dir(path_to_data_dir, test_id) #path_to_test_dir = path_to_data_dir + event_state[0] path_to_curr_result = path_to_test_dir + "/results" init, sad, fin = event_state[1][0], event_state[1][1], event_state[1][2] path_to_curr_event = path_to_curr_result + "/event_" + init + "_" + sad + "_" + fin event_str = event_state[0] + "/event_" + init + "_" + sad + "_" + fin path_to_voro_results = path_to_curr_event + "/voronoi_index_results.json" if not os.path.exists(path_to_voro_results): print("the voronoi index has not been calculated for the event %s" % event_str) return None voronoi_index = json.load(open(path_to_voro_results, "r")) if voronoi_index["init"] == []: return None # classify voronoi index init_voronoi_class = classify_voronoi_index(voronoi_index["init"]) sad_voronoi_class = classify_voronoi_index(voronoi_index["sad"]) fin_voronoi_class = classify_voronoi_index(voronoi_index["fin"]) voronoi_class = { "init": init_voronoi_class, "sad": sad_voronoi_class, "fin": fin_voronoi_class } # do visualization of the fraction of voronoi class path_to_image = path_to_curr_event + "/voronoi_hist.png" plot_voronoi_histogram_3( path_to_image, [init_voronoi_class, sad_voronoi_class, fin_voronoi_class]) return voronoi_class
def single_event_strain_stats(path_to_data_dir, event): if 'test' in event[0]: test_id = int(event[0][4:]) else: test_id = int(event[0]) path_to_curr_test = data_dir_to_test_dir(path_to_data_dir, test_id) #path_to_curr_test = path_to_data_dir + event[0] path_to_curr_event = path_to_curr_test + "/results/events_stats.pkl" if os.path.exists(path_to_curr_event): result = pickle.load(open(path_to_curr_event, 'r')) for event_res in result: # event_res[3] is the event state, if equal to curr event state: event if event_res[3] == event: init_sad = event_res[0] sad_fin = event_res[1] init_fin = event_res[2] return (init_sad, sad_fin, init_fin)
def delete_art_tests(path_to_data_dir, central_atom_list): """ file_names is a list of files to be deleted in the final art tests directory """ print "begining delete tests:", central_atom_list print "confirm deleting (y/n):" if prompt_yes_no() is True: for test in central_atom_list: try: path_to_test = data_dir_to_test_dir(path_to_data_dir, test) if os.path.isdir(path_to_test): print "deleting the test %s" % path_to_test shutil.rmtree(path_to_test) else: print "test %s" % test, "does not exist in %s" % path_to_data_dir except Exception: print "test %s" % test, "does not exist in %s" % path_to_data_dir else: print "Not deleting!" print "done deleting all tests in specified list of tests in %s" % path_to_data_dir
def single_event_local_atoms_index(event,path_to_data_dir,model,feature,target,residual_threshold =0.5, save_results=True, re_calc = False): """ this function developed correlation model between feature and target for a single event whose state is saved into event return: local_atom_index: a list a list with elements contains a list of local atom index for init_sad """ if 'test' in event[0]: test_id = int(event[0][4:]) else: test_id = int(event[0]) path_to_test_dir = data_dir_to_test_dir(path_to_data_dir, test_id) path_to_curr_result = path_to_test_dir + "/results" init,sad,fin = event[1][0], event[1][1], event[1][2] path_to_curr_event = path_to_curr_result + "/event_" + init + "_" + sad + "_" + fin path_to_init_sad = path_to_curr_event + "/init_sad" path_to_local_atom_index = path_to_curr_event + "/local_atoms_index.json" print "path_to_current_event:", path_to_curr_event if re_calc is False: if os.path.exists(path_to_local_atom_index): return json.load(open(path_to_local_atom_index,'r')) print "re_calculating" if feature == "displacement" and target == "shear_strain": init_sad_X,init_sad_y = get_strain_disp(path_to_init_sad) init_sad = outlier_detector(init_sad_X,init_sad_y,model,residual_threshold, return_index = True) if save_results is True: with open(path_to_local_atom_index, 'w') as f: json.dump(init_sad,f) f.close() return init_sad
def refconfig_to_lammps_data(path_to_data_dir, event_state, input_param): """ this function converts the configuration files of a single event stored in event_state from ART output refconfig type into lammps data type """ if 'test' in event_state[0]: test_id = int(event_state[0][4:]) else: test_id = int(event_state[0]) path_to_test_dir = data_dir_to_test_dir(path_to_data_dir, test_id) init, sad, fin = event_state[1][0], event_state[1][1], event_state[1][2] #path_to_event = path_to_test_dir + "/results/event_" + init + "_" + sad + "_" + fin path_to_file_ini = path_to_test_dir + '/' + init path_to_file_sad = path_to_test_dir + '/' + sad path_to_file_fin = path_to_test_dir + '/' + fin ini_config_data = read_data_from_non_dump(path_to_file_ini) sad_config_data = read_data_from_non_dump(path_to_file_sad) fin_config_data = read_data_from_non_dump(path_to_file_fin) ini_config_data = ini_config_data[["item", "atom_id", "x", "y", "z"]] sad_config_data = sad_config_data[["item", "atom_id", "x", "y", "z"]] fin_config_data = fin_config_data[["item", "atom_id", "x", "y", "z"]] num_of_atoms = ini_config_data.shape[0] item_list = [x + 1 for x in range(num_of_atoms)] num_atom_types = len(ini_config_data['atom_id'].unique()) #print "ini_config_data:", ini_config_data #ini_config_data.insert(loc=0, column='item', value=item_list) #sad_config_data.insert(loc=0, column='item', value=item_list) #fin_config_data.insert(loc=0, column='item', value=item_list) ini_file_to_save = os.path.join(path_to_test_dir, init + ".lammps") sad_file_to_save = os.path.join(path_to_test_dir, sad + ".lammps") fin_file_to_save = os.path.join(path_to_test_dir, fin + ".lammps") box_range = input_param["box_range"] with open(ini_file_to_save, 'w') as f: f.write( '# LAMMPS data file written by OVITO\n%s atoms\n%s atom types\n%s %s xlo xhi\n%s %s ylo yhi\n%s %s zlo zhi\n\nAtoms # atomic\n\n' % (num_of_atoms, num_atom_types, box_range[0][0], box_range[0][1], box_range[1][0], box_range[1][1], box_range[2][0], box_range[2][1])) ini_config_data.to_csv(f, header=False, index=False, sep=' ') f.close() print "saving file in %s" % ini_file_to_save with open(sad_file_to_save, 'w') as f: f.write( '# LAMMPS data file written by OVITO\n%s atoms\n%s atom types\n%s %s xlo xhi\n%s %s ylo yhi\n%s %s zlo zhi\n\nAtoms # atomic\n\n' % (num_of_atoms, num_atom_types, box_range[0][0], box_range[0][1], box_range[1][0], box_range[1][1], box_range[2][0], box_range[2][1])) sad_config_data.to_csv(f, header=False, index=False, sep=' ') f.close() print "saving file in %s" % sad_file_to_save with open(fin_file_to_save, 'w') as f: f.write( '# LAMMPS data file written by OVITO\n%s atoms\n%s atom types\n%s %s xlo xhi\n%s %s ylo yhi\n%s %s zlo zhi\n\nAtoms # atomic\n\n' % (num_of_atoms, num_atom_types, box_range[0][0], box_range[0][1], box_range[1][0], box_range[1][1], box_range[2][0], box_range[2][1])) fin_config_data.to_csv(f, header=False, index=False, sep=' ') f.close() print "saving file in %s" % fin_file_to_save
def single_event_pn_calculator(event_state, path_to_data_dir, save_results=True, re_calc=False, is_non_affine=False): # go to event directory if 'test' in event_state[0]: test_id = int(event_state[0][4:]) else: test_id = int(event_state[0]) path_to_test_dir = data_dir_to_test_dir(path_to_data_dir, test_id) path_to_curr_result = path_to_test_dir + "/results" init, sad, fin = event_state[1][0], event_state[1][1], event_state[1][2] path_to_curr_event = path_to_curr_result + "/event_" + init + "_" + sad + "_" + fin if not os.path.exists(path_to_curr_event): os.makedirs(path_to_curr_event) # check if results has already been saved path_pn_number_results = os.path.join(path_to_curr_event, "pn_number.json") path_pn_index_results = os.path.join(path_to_curr_event, "pn_index.json") if re_calc is False: if os.path.exists(path_pn_number_results) and os.path.exists( path_pn_index_results): return (json.load(open(path_pn_number_results, "r")), json.load(open(path_pn_index_results, "r"))) else: print "begin calculating pn number and index" else: print "re_calculating pn number and index" # begin working on each process of this event path_to_init_sad = path_to_curr_event + "/init_sad" path_to_sad_fin = path_to_curr_event + "/sad_fin" path_to_init_fin = path_to_curr_event + "/init_fin" if is_non_affine is False: # read displacement file for each event path_to_all_displacement_init_sad = path_to_init_sad + "/displacement_results_dict.pkl" path_to_all_displacement_sad_fin = path_to_sad_fin + "/displacement_results_dict.pkl" path_to_all_displacement_init_fin = path_to_init_fin + "/displacement_results_dict.pkl" if os.path.exists( path_to_all_displacement_init_sad) and os.path.exists( path_to_all_displacement_sad_fin) and os.path.exists( path_to_all_displacement_init_fin): all_disp_init_sad = pickle.load( open(path_to_all_displacement_init_sad, 'r')) all_disp_sad_fin = pickle.load( open(path_to_all_displacement_sad_fin, 'r')) all_disp_init_fin = pickle.load( open(path_to_all_displacement_init_fin, 'r')) else: raise Exception( "displacement results have not been found in current event:%s" % path_to_curr_event) # perform the calculations according to the formulas proposed in # "Local structural excitations in model glasses" Swayamjyoti et al PRB, 2014 pn_init_sad, pn_index_init_sad = get_pn_number_index(all_disp_init_sad) pn_sad_fin, pn_index_sad_fin = get_pn_number_index(all_disp_sad_fin) pn_init_fin, pn_index_init_fin = get_pn_number_index(all_disp_init_fin) elif is_non_affine is True: path_to_all_shear_init_sad = path_to_init_sad + "/strain_results_dict.pkl" path_to_all_shear_sad_fin = path_to_sad_fin + "/strain_results_dict.pkl" path_to_all_shear_init_fin = path_to_init_fin + "/strain_results_dict.pkl" if os.path.exists(path_to_all_shear_init_sad) and os.path.exists( path_to_all_shear_sad_fin) and os.path.exists( path_to_all_shear_init_fin): all_strains_init_sad = pickle.load( open(path_to_all_shear_init_sad, 'r')) all_strains_sad_fin = pickle.load( open(path_to_all_shear_sad_fin, 'r')) all_strains_init_fin = pickle.load( open(path_to_all_shear_init_fin, 'r')) all_shear_init_sad = extract_shear_dict(all_strains_init_sad) all_shear_sad_fin = extract_shear_dict(all_strains_sad_fin) all_shear_init_fin = extract_shear_dict(all_strains_init_fin) else: raise Exception( "strain results have not been found in current event:%s" % path_to_curr_event) # perform the calculations according to the formulas proposed in # "Local structural excitations in model glasses" Swayamjyoti et al PRB, 2014 pn_init_sad, pn_index_init_sad = get_pn_number_index( all_shear_init_sad, True) pn_sad_fin, pn_index_sad_fin = get_pn_number_index( all_shear_sad_fin, True) pn_init_fin, pn_index_init_fin = get_pn_number_index( all_shear_init_fin, True) pn_number = { "init_sad": pn_init_sad, "sad_fin": pn_sad_fin, "init_fin": pn_init_fin } pn_index = { "init_sad": pn_index_init_sad, "sad_fin": pn_index_sad_fin, "init_fin": pn_index_init_fin } # save the calculated results into files if save_results is True: print("begin saving pn results into json files") with open(path_pn_number_results, 'w') as f: json.dump(pn_number, f) f.close() with open(path_pn_index_results, 'w') as f: json.dump(pn_index, f) f.close() print "pn results saved into two json files!" return (pn_number, pn_index)
def strain_events_stats_visualization_old(path_to_data_dir, list_of_test_id): """ this function visualize the strain statistics from tests listed in list_of_test_id, the user can customize the tests they want to know their statistics, among these tests, only the one has events_stat.pkl file will be used for plot path_to_data_dir: str path to the data dir list_of_tests: list a number list showing the test id number e.g. list [1,2] mean that visualizing test1, test2 data """ # set up the statistical quantities for the tests disp_ave, disp_std, disp_max , disp_ave_2, disp_std_2, disp_max_2, disp_ave_3, disp_std_3, disp_max_3 = [], [], [], [], [], [], [], [], [] shear_ave, shear_std, shear_max, shear_ave_2, shear_std_2, shear_max_2, shear_ave_3, shear_std_3, shear_max_3 = [], [], [], [], [], [], [], [], [] vol_ave, vol_std, vol_max, vol_ave_2, vol_std_2, vol_max_2, vol_ave_3, vol_std_3, vol_max_3 = [], [], [], [], [], [], [], [], [] for i in list_of_test_id: path_to_curr_test = data_dir_to_test_dir(path_to_data_dir, i) path_to_curr_event = path_to_curr_test + "/results/events_stats.pkl" # skip the test who do not have events_stats.pkl in all tests specified in # list_of_test_id if os.path.exists(path_to_curr_event): result = pickle.load(open(path_to_curr_event, 'r')) for event in result: init_sad = event[0] sad_fin = event[1] init_fin = event[2] # calculate the statistics of init_sad and sad_fin disp_ave.append(init_sad["ave"][2]) disp_std.append(init_sad["std"][2]) disp_max.append(init_sad["max"][2]) shear_ave.append(init_sad["ave"][1]) shear_std.append(init_sad["std"][1]) shear_max.append(init_sad["max"][1]) vol_ave.append(init_sad["ave"][0]) vol_std.append(init_sad["std"][0]) vol_max.append(init_sad["max"][0]) disp_ave_2.append(sad_fin["ave"][2]) disp_std_2.append(sad_fin["std"][2]) disp_max_2.append(sad_fin["max"][2]) shear_ave_2.append(sad_fin["ave"][1]) shear_std_2.append(sad_fin["std"][1]) shear_max_2.append(sad_fin["max"][1]) vol_ave_2.append(sad_fin["ave"][0]) vol_std_2.append(sad_fin["std"][0]) vol_max_2.append(sad_fin["max"][0]) disp_ave_3.append(init_fin["ave"][2]) disp_std_3.append(init_fin["std"][2]) disp_max_3.append(init_fin["max"][2]) shear_ave_3.append(init_fin["ave"][1]) shear_std_3.append(init_fin["std"][1]) shear_max_3.append(init_fin["max"][1]) vol_ave_3.append(init_fin["ave"][0]) vol_std_3.append(init_fin["std"][0]) vol_max_3.append(init_fin["max"][0]) plot_histogram_3(path_to_data_dir + "/disp_ave.png", [disp_ave, disp_ave_2, disp_ave_3]) plot_histogram_3(path_to_data_dir + "/disp_std.png", [disp_std, disp_std_2, disp_std_3]) plot_histogram_3(path_to_data_dir + "/disp_max.png", [disp_max, disp_max_2, disp_max_3]) plot_histogram_3(path_to_data_dir + "/shear_ave.png", [shear_ave, shear_ave_2, shear_ave_3]) plot_histogram_3(path_to_data_dir + "/shear_std.png", [shear_std, shear_std_2, shear_std_3]) plot_histogram_3(path_to_data_dir + "/shear_max.png", [shear_max, shear_max_2, shear_max_3]) plot_histogram_3(path_to_data_dir + "/vol_ave.png", [vol_ave, vol_ave_2, vol_ave_3]) plot_histogram_3(path_to_data_dir + "/vol_std.png", [vol_std, vol_std_2, vol_std_3]) plot_histogram_3(path_to_data_dir + "/vol_max.png", [vol_max, vol_max_2, vol_max_3]) print "done plotting strain statistics for all interested tests!"
def filter_events_all_tests_stage_2(path_to_data_dir, input_param, save_results=True, re_calc=False): """ this function implement stage 2 criteria 3 to remove the redundancy of event pairs it will sort all event pair and finally save the unique events into a pkl file as a list of strings, such as test1/event_init_sad_fin criteria 3: for the remaining refined searches, any pair is redundant if abs(D(fin - init)_1-D(fin-init)_2) < 0.1 (A) AND abs(E(fin-init)_1-E(fin-init))_2 < 0.005(eV) AND abs(E(sad-init)_1-E(sad-init))_2 < 0.01(eV) """ list_of_test_id = input_param["list_of_test_id"] existed_tests = [] for i in list_of_test_id: try: path_to_curr_test = data_dir_to_test_dir(path_to_data_dir, i) existed_tests.append(i) except Exception: pass list_of_test_id = existed_tests box_dim = input_param["box_dim"] identical_event_criteria = input_param["identical_event_criteria"] if "num_of_proc" in input_param and "re_calc" in input_param: num_of_proc = input_param["num_of_proc"] re_calc = input_param["re_calc"] if re_calc is False: path_to_final_selected_events = os.path.join( path_to_data_dir, "final_selected_events.json") if os.path.exists(path_to_final_selected_events): print "reduadancy has already been checked, total number of final selected events:" final_events = json.load(open(path_to_final_selected_events, 'r')) print len(final_events) return all_selected_events = get_list_of_selected_events_str( path_to_data_dir, list_of_test_id) # remove the 2nd identical pair events found num_of_selected_events = len(all_selected_events) print "total number of selected events:", num_of_selected_events removed_index = [] pool = mp.Pool(processes=num_of_proc) for i in xrange(num_of_selected_events): if i in removed_index: continue tests_list = [ all_selected_events[j] for j in xrange(i + 1, num_of_selected_events) ] result = pool.map( partial(identical_events, path_to_data_dir=path_to_data_dir, event_1=all_selected_events[i], box_dim=box_dim, identical_event_criteria=identical_event_criteria), tests_list) #for j in xrange(i+1,num_of_selected_events): # is_same = identical_events(path_to_data_dir, all_selected_events[i], all_selected_events[j], box_dim, identical_event_criteria) # if is_same: # removed_index.append(j) k = 0 for x in result: if x == True: removed_index.append(k + i + 1) k = k + 1 removed_index = np.unique(removed_index) # final_selected_events = np.delete(all_selected_events, removed_index).tolist() final_selected_events = [ i for j, i in enumerate(all_selected_events) if j not in removed_index ] print "total number of selected events before redundacy check:", num_of_selected_events print "total number of final selected events after removing redundacy:", len( final_selected_events) #save it into a file called final_selected_events.json if save_results is True: path_to_final_selected_events = os.path.join( path_to_data_dir, "final_selected_events.json") json.dump(final_selected_events, open(path_to_final_selected_events, 'w')) print "done redudancy check for all interested tests!"
def identical_events(event_2, path_to_data_dir, event_1, box_dim, identical_event_criteria={ "D_init_fin": 0.1, "E_init_fin": 0.005, "E_init_sad": 0.01 }): """ this function return True if two events are identical criteria 3: for the remaining refined searches, any pair is redundant if abs(D(fin - init)_1-D(fin-init)_2) < D_init_fin e.g. 0.1 (A) for Cu-Zr AND abs(E(fin-init)_1-E(fin-init)_2) < E_init_fin e.g. 0.005(eV) for Cu-Zr AND abs(E(sad-init)_1-E(sad-init)_2) < E_init_sad e.g. 0.01(eV) for Cu-Zr """ D_init_fin = identical_event_criteria["D_init_fin"] E_init_fin = identical_event_criteria["E_init_fin"] E_init_sad = identical_event_criteria["E_init_sad"] if 'test' in event_1[0]: test_id_1 = int(event_1[0][4:]) else: test_id_1 = int(event_1[0]) path_to_event_1_test = data_dir_to_test_dir(path_to_data_dir, test_id_1) if 'test' in event_2[0]: test_id_2 = int(event_2[0][4:]) else: test_id_2 = int(event_2[0]) path_to_event_2_test = data_dir_to_test_dir(path_to_data_dir, test_id_2) #path_to_event_1_test = path_to_data_dir + event_1[0] #path_to_event_2_test = path_to_data_dir + event_2[0] event_1_init, event_1_sad, event_1_fin = event_1[1][0], event_1[1][ 1], event_1[1][2] event_2_init, event_2_sad, event_2_fin = event_2[1][0], event_2[1][ 1], event_2[1][2] event_1_energy = event_energy(path_to_event_1_test) event_1_init_eng, event_1_sad_eng, event_1_fin_eng = event_1_energy[ event_1_init], event_1_energy[event_1_sad], event_1_energy[event_1_fin] event_2_energy = event_energy(path_to_event_2_test) event_2_init_eng, event_2_sad_eng, event_2_fin_eng = event_2_energy[ event_2_init], event_2_energy[event_2_sad], event_2_energy[event_2_fin] cond_1 = abs(event_1_fin_eng - event_1_init_eng - (event_2_fin_eng - event_2_init_eng)) < E_init_fin cond_2 = abs(event_1_sad_eng - event_1_init_eng - (event_2_sad_eng - event_2_init_eng)) < E_init_sad if not (cond_1 and cond_2): return False distance_1 = event_distance(path_to_event_1_test, [event_1_init, event_1_sad, event_1_fin], box_dim) distance_2 = event_distance(path_to_event_2_test, [event_2_init, event_2_sad, event_2_fin], box_dim) cond_3 = abs(distance_1 - distance_2) < D_init_fin if cond_3: return True else: return False
def single_event_voronoi_calculator(event_state, path_to_data_dir, box_range, cut_off, atom_list = None,max_edge_count=8, periodic = [True,True,True], save_results = True, re_calc = False): """ this function calculates the voronoi index of user specified atoms stored in atom_list for all configurations (init,sad,fin) in a single event that are specified in the event state Input: event_state: a list a list with the 1st element being the test_id, e.g. test1 the 2nd element being a list containing the string of init, sad, fin configuration file str, e.g. [min1000,sad1001,min1001] """ if 'test' in event_state[0]: test_id = int(event_state[0][4:]) else: test_id = int(event_state[0]) path_to_test_dir = data_dir_to_test_dir(path_to_data_dir, test_id) #path_to_test_dir = path_to_data_dir + event_state[0] path_to_curr_result = path_to_test_dir + "/results" # redundant, if exists, may cause race condition when os.makedirs act on same dir (leaf) # for parallel processing, in python3, it can be avoided by adding exist_ok=True # in python2 here, rewrite code to ensure os.makedirs act on different dir (leaf) # or using try except in # https://stackoverflow.com/questions/12468022/python-fileexists-error-when-making-directory # https://stackoverflow.com/questions/273192/how-can-i-create-a-directory-if-it-does-not-exist #if not os.path.exists(path_to_curr_result): # os.makedirs(path_to_curr_result) init, sad, fin = event_state[1][0], event_state[1][1], event_state[1][2] path_to_curr_event = path_to_curr_result + "/event_" + init + "_" + sad + "_" + fin if not os.path.exists(path_to_curr_event): os.makedirs(path_to_curr_event) path_to_voro_results = path_to_curr_event + "/voronoi_index_results.json" if re_calc is False: if os.path.exists(path_to_voro_results): return json.load(open(path_to_voro_results,"r")) path_to_file_ini = path_to_test_dir + '/' + init + ".dump" path_to_file_sad = path_to_test_dir + '/' + sad + ".dump" path_to_file_fin = path_to_test_dir + '/' + fin + ".dump" initial_config_data = read_data_from_file(path_to_file_ini) saddle_config_data = read_data_from_file(path_to_file_sad) final_config_data = read_data_from_file(path_to_file_fin) box_dim = [box_range[0][1] - box_range[0][0], box_range[1][1] - box_range[1][0], box_range[2][1] - box_range[2][0]] path_to_local_atom_index = path_to_curr_event + "/local_atoms_index.json" if atom_list is None: atom_list = (initial_config_data["item"]).tolist() if atom_list == "local": if os.path.exists(path_to_local_atom_index): # for local mode of voronoi calculation print ("\n starting local mode voronoi calculations") local_atom_list = json.load(open(path_to_local_atom_index,"r")) if local_atom_list == []: return None atom_list = [atom + 1 for atom in local_atom_list] else: raise Exception("local_atoms_index.json does not exist in %s"%path_to_curr_event) init_voronoi_index = single_config_voronoi_calculator(initial_config_data, box_range, cut_off, atom_list=atom_list, max_edge_count = max_edge_count, periodic=periodic) sad_voronoi_index = single_config_voronoi_calculator(saddle_config_data, box_range, cut_off, atom_list=atom_list, max_edge_count = max_edge_count, periodic=periodic) fin_voronoi_index = single_config_voronoi_calculator(final_config_data, box_range, cut_off, atom_list=atom_list, max_edge_count = max_edge_count, periodic=periodic) voronoi_index = {"init":init_voronoi_index, "sad":sad_voronoi_index, "fin":fin_voronoi_index} if save_results is True: print ("begin saving voronoi results into json file") with open(path_to_voro_results, 'w') as f: json.dump(voronoi_index,f) f.close() return voronoi_index
def single_event_data_extractor(event_state, path_to_data_dir, atom_list): # go to event directory if 'test' in event_state[0]: test_id = int(event_state[0][4:]) else: test_id = int(event_state[0]) path_to_test_dir = data_dir_to_test_dir(path_to_data_dir, test_id) path_to_curr_result = path_to_test_dir + "/results" init, sad, fin = event_state[1][0], event_state[1][1], event_state[1][2] path_to_curr_event = path_to_curr_result + "/event_" + init + "_" + sad + "_" + fin print "extracting atom_list:" path_to_file_ini = path_to_test_dir + '/' + init + ".dump" initial_config_data = read_data_from_file(path_to_file_ini) (atom_list_init_sad, atom_list_sad_fin, atom_list_init_fin) = get_list_of_atoms_from_atom_list( path_to_curr_event, initial_config_data, atom_list) atom_num_init_sad, atom_num_sad_fin, atom_num_init_fin = len( atom_list_init_sad), len(atom_list_sad_fin), len(atom_list_init_fin) print "extracting energy data:" event, act_eng, relax_eng = event_act_relax_energy(event_state, path_to_data_dir) init_sad_eng, sad_fin_eng, init_fin_eng = act_eng, -relax_eng, act_eng - relax_eng print "extracting strain and displacement data:" # strain = {"init_sad":[], "sad_fin":[], "init_fin:[]"} # displacement = {"init_sad":[], "sad_fin":[], "init_fin:[]"} # atom_list= {"init_sad":[], "sad_fin":[], "init_fin:[]"} atom_list = { "init_sad": atom_list_init_sad, "sad_fin": atom_list_sad_fin, "init_fin": atom_list_init_fin } ave_vol_strain, ave_shear_strain, ave_disp = event_ave_strain_displacement( event_state, path_to_data_dir, atom_list) print "extracting voronoi volume data:" init_vol, sad_vol, fin_vol = event_voronoi_volume(event_state, path_to_data_dir) init_sad_vol, sad_fin_vol, init_fin_vol = sad_vol - init_vol, fin_vol - sad_vol, fin_vol - init_vol event_voro_res = event_voronoi_class(event_state, path_to_data_dir) event_init_sad = pd.DataFrame(dtype=object) event_init_sad.at[0, "event_id"] = str(event_state) event_init_sad.at[0, "atom_list"] = str(atom_list_init_sad) event_init_sad.at[0, "num_of_atoms"] = str(atom_num_init_sad) event_init_sad.at[0, "ave_vol_strain"] = str(ave_vol_strain["init_sad"]) event_init_sad.at[0, "ave_shear_strain"] = str(ave_shear_strain["init_sad"]) event_init_sad.at[0, "ave_disp"] = str(ave_disp["init_sad"]) event_init_sad.at[0, "start_ICO_frac"] = str(event_voro_res["init"][0]) event_init_sad.at[0, "start_ICO_like_frac"] = str(event_voro_res["init"][1]) event_init_sad.at[0, "start_GUM_frac"] = str(event_voro_res["init"][2]) event_init_sad.at[0, "end_ICO_frac"] = str(event_voro_res["sad"][0]) event_init_sad.at[0, "end_ICO_like_frac"] = str(event_voro_res["sad"][1]) event_init_sad.at[0, "end_GUM_frac"] = str(event_voro_res["sad"][2]) event_init_sad.at[0, "vol_diff"] = str(init_sad_vol) event_init_sad.at[0, "eng_diff"] = str(init_sad_eng) event_sad_fin = pd.DataFrame(dtype=object) event_sad_fin.at[0, "event_id"] = str(event_state) event_sad_fin.at[0, "atom_list"] = str(atom_list_sad_fin) event_sad_fin.at[0, "num_of_atoms"] = str(atom_num_sad_fin) event_sad_fin.at[0, "ave_vol_strain"] = str(ave_vol_strain["sad_fin"]) event_sad_fin.at[0, "ave_shear_strain"] = str(ave_shear_strain["sad_fin"]) event_sad_fin.at[0, "ave_disp"] = str(ave_disp["sad_fin"]) event_sad_fin.at[0, "start_ICO_frac"] = str(event_voro_res["sad"][0]) event_sad_fin.at[0, "start_ICO_like_frac"] = str(event_voro_res["sad"][1]) event_sad_fin.at[0, "start_GUM_frac"] = str(event_voro_res["sad"][2]) event_sad_fin.at[0, "end_ICO_frac"] = str(event_voro_res["fin"][0]) event_sad_fin.at[0, "end_ICO_like_frac"] = str(event_voro_res["fin"][1]) event_sad_fin.at[0, "end_GUM_frac"] = str(event_voro_res["fin"][2]) event_sad_fin.at[0, "vol_diff"] = str(sad_fin_vol) event_sad_fin.at[0, "eng_diff"] = str(sad_fin_eng) event_init_fin = pd.DataFrame(dtype=object) event_init_fin.at[0, "event_id"] = str(event_state) event_init_fin.at[0, "atom_list"] = str(atom_list_init_fin) event_init_fin.at[0, "num_of_atoms"] = str(atom_num_init_fin) event_init_fin.at[0, "ave_vol_strain"] = str(ave_vol_strain["init_fin"]) event_init_fin.at[0, "ave_shear_strain"] = str(ave_shear_strain["init_fin"]) event_init_fin.at[0, "ave_disp"] = str(ave_disp["init_fin"]) event_init_fin.at[0, "start_ICO_frac"] = str(event_voro_res["init"][0]) event_init_fin.at[0, "start_ICO_like_frac"] = str(event_voro_res["init"][1]) event_init_fin.at[0, "start_GUM_frac"] = str(event_voro_res["init"][2]) event_init_fin.at[0, "end_ICO_frac"] = str(event_voro_res["fin"][0]) event_init_fin.at[0, "end_ICO_like_frac"] = str(event_voro_res["fin"][1]) event_init_fin.at[0, "end_GUM_frac"] = str(event_voro_res["fin"][2]) event_init_fin.at[0, "vol_diff"] = str(init_fin_vol) event_init_fin.at[0, "eng_diff"] = str(init_fin_eng) #event_init_sad = = pd.DataFrame({"event_id":event_state,"atom_list":atom_list_init_sad,"num_of_atoms":atom_num_init_sad,"ave_vol_strain":ave_vol_strain["init_sad"],"ave_shear_strain":ave_shear_strain["init_sad"],"ave_disp":ave_disp["init_sad"],"start_ICO_frac":event_voro_res["init"][0],"start_ICO_like_frac":event_voro_res["init"][1],"start_GUM_frac":event_voro_res["init"][2],"end_ICO_frac":event_voro_res["sad"][0],"end_ICO_like_frac":event_voro_res["sad"][1],"end_GUM_frac":event_voro_res["sad"][2], "vol_diff":init_sad_vol,"eng_diff":init_sad_eng}) #event_sad_fin = pd.DataFrame({"event_id":event_state,"atom_list":atom_list_sad_fin,"num_of_atoms":atom_num_sad_fin,"ave_vol_strain":ave_vol_strain["sad_fin"],"ave_shear_strain":ave_shear_strain["sad_fin"],"ave_disp":ave_disp["sad_fin"],"start_ICO_frac":event_voro_res["sad"][0],"start_ICO_like_frac":event_voro_res["sad"][1],"start_GUM_frac":event_voro_res["sad"][2],"end_ICO_frac":event_voro_res["fin"][0],"end_ICO_like_frac":event_voro_res["fin"][1],"end_GUM_frac":event_voro_res["fin"][2],"vol_diff": sad_fin_vol,"eng_diff":sad_fin_eng}) #event_init_fin = pd.DataFrame({"event_id":event_state,"atom_list":atom_list_init_fin,"num_of_atoms":atom_num_init_fin,"ave_vol_strain":ave_vol_strain["init_fin"],"ave_shear_strain":ave_shear_strain["init_fin"],"ave_disp":ave_disp["init_fin"],"start_ICO_frac":event_voro_res["init"][0],"start_ICO_like_frac":event_voro_res["init"][1],"start_GUM_frac":event_voro_res["init"][2],"end_ICO_frac":event_voro_res["fin"][0],"end_ICO_like_frac":event_voro_res["fin"][1],"end_GUM_frac":event_voro_res["fin"][2],"vol_diff": init_fin_vol,"eng_diff":init_fin_eng}) return (event_init_sad, event_sad_fin, event_init_fin)
def delete_unused_events_data(path_to_data_dir, input_param): """ this function delete the configuration files of un-used events data inside each test of an art data project to save disk space, especially when users has not used WRITE_REJECTED_EVENTS = .False. option in bart.sh First, it will read the final_selected_events.json, which stores all useful events. Second, it will delete all configuration files that are not saved in the final_selected_events.json """ path_to_final_selected_events = os.path.join(path_to_data_dir, "final_selected_events.json") if os.path.isfile(path_to_final_selected_events): print "reading final_selected_events.json, ensure that you always get most updated final_selected_events.json by --filter --re_calc if you have calculated more tests" final_selected_events = json.load( open(path_to_final_selected_events, "r")) else: raise Exception("final_selected_events.json does not exist in %s" % path_to_data_dir) all_tests_events = dict() for event in final_selected_events: test_id = int(event[0][4:]) init, sad, fin = event[1][0], event[1][1], event[1][2] if test_id in all_tests_events: all_tests_events[test_id].extend([init, sad, fin]) else: all_tests_events[test_id] = [init, sad, fin] #all_tests_id.append(test_id) print "confirm deleting (y/n):" if prompt_yes_no() is False: print "response received, not deleting" return None else: print "response received, begin deleting" path_to_central_atom_list = os.path.join(path_to_data_dir, "central_atom_list.json") if os.path.isfile( path_to_central_atom_list) or "central_atom_list" in input_param: if os.path.isfile(path_to_central_atom_list): print "reading central_atom_list.json" central_atom_list = json.load(open(path_to_central_atom_list, 'r')) elif "central_atom_list" in input_param: print "reading central_atom_list from input SETTINGs file" central_atom_list = input_param['central_atom_list'] delete_tests_list = [] saved_tests_list = [] for test_id in central_atom_list: if test_id not in all_tests_events: delete_tests_list.append(test_id) else: saved_tests_list.append(test_id) delete_art_tests(path_to_data_dir, delete_tests_list) print ">>> confirm updating central_atom_list.json file (y/n): save original central_atom_list.json if necessary" if prompt_yes_no() is True: print "response received, updating!" update_central_atom_list(path_to_data_dir, saved_tests_list) else: print "response received, not updating" else: print "central_atom_list.json does not exist in %s" % path_to_data_dir print "central_atom_list key does not exist in input SETTING file" print ">>> only deleting unused events for all tests stored in final_selected_events.json" print "\n Now begin deleting unused events configuration files for all tests stored in final_selected_events.json" for test_id in all_tests_events: path_to_test_dir = data_dir_to_test_dir(path_to_data_dir, test_id) for f in os.listdir(path_to_test_dir): is_match_config = re.match(r"min[0-9]+", f) or re.match( r"sad[0-9]+", f) or re.match(r"min[0-9]+.dump", f) or re.match( r"sad[0-9]+.dump", f) path_to_file = os.path.join(path_to_test_dir, f) is_file = os.path.isfile(path_to_file) if is_match_config and is_file: if f.endswith('.dump'): config_id = f[:-5] else: config_id = f if config_id not in all_tests_events[test_id]: print "deleting the file %s" % path_to_file os.remove(path_to_file) print "done deleting unused events data!"
def check_tests_status(path_to_data_dir, input_param): """ check the status of each test of central_atom_list in input_param under path_to_data_dir as finished test or unfinished test This function will always overwrite the most update test status result into input SETTINGS file input_tests_done.json and input_tests_undone.json for the following processing Return: tests_undone: list the list of test id that has not been done yet """ # read the Max_num_events from bart.sh in path_to_input_files path_to_input_files = input_param['path_to_input_files'] path_to_bart = os.path.join(path_to_input_files, "bart.sh") with open(path_to_bart, 'r') as f: data = f.read() pattern = "(setenv[\s]+Max_Number_Events[\s]+)([\d]+)" match = re.search(pattern, data) max_num_events = int(match.group(2)) #list_of_test_id = input_param["list_of_test_id"] central_atom_list = input_param['central_atom_list'] tests_not_done = [] tests_done = [] for test in central_atom_list: try: path_to_test = data_dir_to_test_dir(path_to_data_dir, test) except Exception: tests_not_done.append(test) # check if this test contains the final configuration file # based on max_num_events final_min_id = 1000 + max_num_events path_to_final_min = os.path.join(path_to_test, "min%s" % final_min_id) if os.path.isfile(path_to_final_min): tests_done.append(test) else: tests_not_done.append(test) print "In %s , finished tests ids in central_atom_list of current input SETTINGS file are:" % path_to_data_dir, tests_done print "In %s , un-finished tests ids in central_atom_list of current input SETTINGS file are:" % path_to_data_dir, tests_not_done print "In %s, start creating art_data input SETTINGs files for finished tests (input_tests_done.json) and unfinished tests(input_tests_undone.json):" % path_to_data_dir path_to_tests_done = os.path.join(path_to_data_dir, "input_tests_done.json") path_to_tests_undone = os.path.join(path_to_data_dir, "input_tests_undone.json") input_param_tests_done = copy.deepcopy(input_param) input_param_tests_undone = copy.deepcopy(input_param) input_param_tests_done["central_atom_list"] = tests_done input_param_tests_undone["central_atom_list"] = tests_not_done input_param_tests_done["list_of_test_id"] = tests_done input_param_tests_undone["list_of_test_id"] = tests_not_done with open(path_to_tests_done, 'w') as f: json.dump(input_param_tests_done, f, indent=2) with open(path_to_tests_undone, 'w') as f: json.dump(input_param_tests_undone, f, indent=2) print "\n" print "For finished tests:" print "Now user can check only the results of finished tests by using art_data -s input_tests_done.json --filter, art_data -s input_tests_done.json --eng --calc etc" print "For unfinished tests:" print "Now user can choose to delete these unfinished tests completely by using art_data -s input_tests_undone.json --art --delete_tests" print "Then user can continue to run these unfinished tests from the beginning by using art_data -s input_tests_undone.json --art --run" print "test status check done!" return tests_not_done
def single_event_strain_visualization(path_to_data_dir, event): """ this function plot the shear strain volumetric strain and displacement for a single event """ if 'test' in event[0]: test_id = int(event[0][4:]) else: test_id = int(event[0]) path_to_test_dir = data_dir_to_test_dir(path_to_data_dir, test_id) path_to_test_result = path_to_test_dir + "/results" init, sad, fin = event[1][0], event[1][1], event[1][2] path_to_curr_event = path_to_test_result + "/event_" + init + "_" + sad + "_" + fin path_to_init_sad = path_to_curr_event + "/init_sad" path_to_sad_fin = path_to_curr_event + "/sad_fin" path_to_init_fin = path_to_curr_event + "/init_fin" path_to_init_sad_strain = path_to_init_sad + "/strain_results_dict.pkl" path_to_init_sad_displacement = path_to_init_sad + "/displacement_results_dict.pkl" path_to_sad_fin_strain = path_to_sad_fin + "/strain_results_dict.pkl" path_to_sad_fin_displacement = path_to_sad_fin + "/displacement_results_dict.pkl" path_to_init_fin_strain = path_to_init_fin + "/strain_results_dict.pkl" path_to_init_fin_displacement = path_to_init_fin + "/displacement_results_dict.pkl" init_sad_strain = pickle.load(open(path_to_init_sad_strain, 'r')) init_sad_displacement = pickle.load( open(path_to_init_sad_displacement, 'r')) sad_fin_strain = pickle.load(open(path_to_sad_fin_strain, 'r')) sad_fin_displacement = pickle.load(open(path_to_sad_fin_displacement, 'r')) init_fin_strain = pickle.load(open(path_to_init_fin_strain, 'r')) init_fin_displacement = pickle.load( open(path_to_init_fin_displacement, 'r')) init_sad_vol_strain, init_sad_shear_strain, init_sad_disp = event_strain_disp( init_sad_strain, init_sad_displacement) sad_fin_vol_strain, sad_fin_shear_strain, sad_fin_disp = event_strain_disp( sad_fin_strain, sad_fin_displacement) init_fin_vol_strain, init_fin_shear_strain, init_fin_disp = event_strain_disp( init_fin_strain, init_fin_displacement) path_to_init_sad_disp_strain = path_to_init_sad + '/disp_shear_strain.png' plot_2d_shear(path_to_init_sad_disp_strain, init_sad_disp, init_sad_shear_strain) path_to_init_sad_disp_vol_strain = path_to_init_sad + '/disp_vol_strain.png' plot_2d_vol(path_to_init_sad_disp_vol_strain, init_sad_disp, init_sad_vol_strain) path_to_sad_fin_disp_strain = path_to_sad_fin + '/disp_shear_strain.png' plot_2d_shear(path_to_sad_fin_disp_strain, sad_fin_disp, sad_fin_shear_strain) path_to_sad_fin_disp_vol_strain = path_to_sad_fin + '/disp_vol_strain.png' plot_2d_vol(path_to_sad_fin_disp_vol_strain, sad_fin_disp, sad_fin_vol_strain) path_to_init_fin_disp_strain = path_to_init_fin + '/disp_shear_strain.png' plot_2d_shear(path_to_init_fin_disp_strain, init_fin_disp, init_fin_shear_strain) path_to_init_fin_disp_vol_strain = path_to_init_fin + '/disp_vol_strain.png' plot_2d_vol(path_to_init_fin_disp_vol_strain, init_fin_disp, init_fin_vol_strain) plot_histogram_3(path_to_curr_event + "/disp_histogram.png", [init_sad_disp, sad_fin_disp, init_fin_disp]) plot_histogram_3( path_to_curr_event + "/shear_strain_histogram.png", [init_sad_shear_strain, sad_fin_shear_strain, init_fin_shear_strain]) plot_histogram_3( path_to_curr_event + "/vol_strain_histogram.png", [init_sad_vol_strain, sad_fin_vol_strain, init_fin_vol_strain]) print "done plotting for the current event:" + event[ 0] + "/event_" + init + "_" + sad + "_" + fin
def archived_file_names(path_to_data_dir): path_to_final_selected_events = os.path.join(path_to_data_dir,"final_selected_events.json") #path_to_central_atom_list = os.path.join(path_to_data_dir,"central_atom_list.json") #path_to_int_atom_list = os.path.join(path_to_data_dir, "interested_atom_list.json") print "reading final_selected_events.json" if os.path.exists(path_to_final_selected_events): print "loading final_selected_events.json, ensure that you always get most updated final_selected_events.json by --filter --re_calc if you have calculated more tests" final_selected_events = json.load(open(path_to_final_selected_events,"r")) else: raise Exception("final_selected_events.json does not exist in %s"%path_to_data_dir) list_of_file_names = [["final_selected_events.json",path_to_final_selected_events]] #if os.path.exists(path_to_central_atom_list): # print "archiving central_atom_list.json, ensure central_atom_list.json is updated by --update_input if using --art --run_more" # central_file = ["central_atom_list.json",path_to_central_atom_list] # list_of_file_names.append(central_file) #if os.path.exists(path_to_int_atom_list): # print "archiving interested_atom_list.json" # int_file = ["interested_atom_list.json",path_to_int_atom_list] # list_of_file_names.append(int_file) file_dirs = os.listdir(path_to_data_dir) for f in file_dirs: if f == "final_selected_events.json" or f == "art_data_project.zip" or f == "central_atom_list.json": continue path_to_file = os.path.join(path_to_data_dir,f) if os.path.isfile(path_to_file): list_of_file_names.append([f,path_to_file]) all_tests_id = [] for event in final_selected_events: test_id = int(event[0][4:]) all_tests_id.append(test_id) path_to_test_dir = data_dir_to_test_dir(path_to_data_dir,test_id) init, sad, fin = event[1][0],event[1][1],event[1][2] #path_to_init = os.path.join(path_to_test_dir,init) #path_to_sad = os.path.join(path_to_test_dir,sad) #path_to_fin = os.path.join(path_to_test_dir,fin) init_file = return_file_names(path_to_test_dir, init) sad_file = return_file_names(path_to_test_dir, sad) fin_file = return_file_names(path_to_test_dir, fin) list_of_file_names.append(init_file) list_of_file_names.append(sad_file) list_of_file_names.append(fin_file) final_tests_id = list(set(all_tests_id)) # update the central_atom_list.json print "update the central_atom_list.json to be all test id saved in final_selected_events.json" print ">>> confirm updating central_atom_list.json file (y/n): save original central_atom_list.json if necessary" if prompt_yes_no() is True: print "response received, updating!" update_central_atom_list(path_to_data_dir,final_tests_id) else: print "response received, not updating" list_of_file_names.append(["central_atom_list.json", os.path.join(path_to_data_dir, "central_atom_list.json")]) for test in final_tests_id: path_to_test_dir = data_dir_to_test_dir(path_to_data_dir,test) test_file = return_test_results_file_name(path_to_test_dir) list_of_file_names.extend(test_file) return list_of_file_names
def strain_calculator_run_all_tests_mp(path_to_data_dir, input_param): """ this function run strain calculations on all tests under multiple processors """ cut_off_distance = input_param["cut_off"] box_dim = input_param['box_dim'] #num_of_tests = input_param['num_of_tests'] list_of_test_id = input_param['list_of_test_id'] num_of_proc = input_param['num_of_proc'] re_calc = input_param["re_calc"] # default None calculating all atoms, # if local, make it a dict {"local":8}, only used after calculating all atom strains # and perform correlation modeling to find the local number of atoms, then rerun with local mode atom_list = input_param["atom_list"] tests_list = [] #for i in xrange(num_of_tests+1): for i in list_of_test_id: try: path_to_curr_test = data_dir_to_test_dir(path_to_data_dir, i) tests_list.append(path_to_curr_test) except Exception: pass disp_ave, disp_std, disp_max , disp_ave_2, disp_std_2, disp_max_2,disp_ave_3, disp_std_3, disp_max_3 = [], [], [], [], [], [], [], [], [] shear_ave, shear_std, shear_max, shear_ave_2, shear_std_2, shear_max_2,shear_ave_3, shear_std_3, shear_max_3 = [], [], [], [], [], [], [], [], [] vol_ave, vol_std, vol_max, vol_ave_2, vol_std_2, vol_max_2,vol_ave_3, vol_std_3, vol_max_3 = [], [], [], [], [], [], [], [], [] pool = mp.Pool(processes = num_of_proc) #partial(my_fun2, general_const=my_const), input_list) # search python pool map partial # pool.map result preserve the order of input result_list = pool.map(partial(strain_calculator_run_single_test,cut_off_distance=cut_off_distance, atom_list=atom_list, box_dim=box_dim, re_calc=re_calc), tests_list) for curr_test in result_list: # if this test do not have data and strain calculation gives None # skip this test if curr_test is None: continue for event in curr_test: init_sad = event[0] sad_fin = event[1] init_fin = event[2] # calculate the statistics of init_sad and sad_fin disp_ave.append(init_sad["ave"][2]) disp_std.append(init_sad["std"][2]) disp_max.append(init_sad["max"][2]) shear_ave.append(init_sad["ave"][1]) shear_std.append(init_sad["std"][1]) shear_max.append(init_sad["max"][1]) vol_ave.append(init_sad["ave"][0]) vol_std.append(init_sad["std"][0]) vol_max.append(init_sad["max"][0]) disp_ave_2.append(sad_fin["ave"][2]) disp_std_2.append(sad_fin["std"][2]) disp_max_2.append(sad_fin["max"][2]) shear_ave_2.append(sad_fin["ave"][1]) shear_std_2.append(sad_fin["std"][1]) shear_max_2.append(sad_fin["max"][1]) vol_ave_2.append(sad_fin["ave"][0]) vol_std_2.append(sad_fin["std"][0]) vol_max_2.append(sad_fin["max"][0]) disp_ave_3.append(init_fin["ave"][2]) disp_std_3.append(init_fin["std"][2]) disp_max_3.append(init_fin["max"][2]) shear_ave_3.append(init_fin["ave"][1]) shear_std_3.append(init_fin["std"][1]) shear_max_3.append(init_fin["max"][1]) vol_ave_3.append(init_fin["ave"][0]) vol_std_3.append(init_fin["std"][0]) vol_max_3.append(init_fin["max"][0]) pickle.dump({"ave":disp_ave,"std":disp_std,"max":disp_max}, open(path_to_data_dir+"/init_sad_disp_stats.pkl",'w')) pickle.dump({"ave":shear_ave,"std":shear_std,"max":shear_max}, open(path_to_data_dir+"/init_sad_shear_stats.pkl",'w')) pickle.dump({"ave":vol_ave,"std":vol_std,"max":vol_max}, open(path_to_data_dir+"/init_sad_vol_stats.pkl",'w')) pickle.dump({"ave":disp_ave_2,"std":disp_std_2,"max":disp_max_2}, open(path_to_data_dir+"/sad_fin_disp_stats.pkl",'w')) pickle.dump({"ave":shear_ave_2,"std":shear_std_2,"max":shear_max_2}, open(path_to_data_dir+"/sad_fin_shear_stats.pkl",'w')) pickle.dump({"ave":vol_ave_2,"std":vol_std_2,"max":vol_max_2}, open(path_to_data_dir+"/sad_fin_vol_stats.pkl",'w')) pickle.dump({"ave":disp_ave_3,"std":disp_std_3,"max":disp_max_3}, open(path_to_data_dir+"/init_fin_disp_stats.pkl",'w')) pickle.dump({"ave":shear_ave_3,"std":shear_std_3,"max":shear_max_3}, open(path_to_data_dir+"/init_fin_shear_stats.pkl",'w')) pickle.dump({"ave":vol_ave_3,"std":vol_std_3,"max":vol_max_3}, open(path_to_data_dir+"/init_fin_vol_stats.pkl",'w')) plot_histogram_3(path_to_data_dir+"/disp_ave.png", [disp_ave,disp_ave_2,disp_ave_3]) plot_histogram_3(path_to_data_dir+"/disp_std.png", [disp_std,disp_std_2,disp_std_3]) plot_histogram_3(path_to_data_dir+"/disp_max.png", [disp_max,disp_max_2,disp_max_3]) plot_histogram_3(path_to_data_dir+"/shear_ave.png", [shear_ave,shear_ave_2,shear_ave_3]) plot_histogram_3(path_to_data_dir+"/shear_std.png", [shear_std,shear_std_2,shear_std_3]) plot_histogram_3(path_to_data_dir+"/shear_max.png", [shear_max,shear_max_2,shear_max_3]) plot_histogram_3(path_to_data_dir+"/vol_ave.png", [vol_ave,vol_ave_2,vol_ave_3]) plot_histogram_3(path_to_data_dir+"/vol_std.png", [vol_std,vol_std_2,vol_std_3]) plot_histogram_3(path_to_data_dir+"/vol_max.png", [vol_max,vol_max_2,vol_max_3]) print "done!"