def generate_random_points(n_ensemble): """ Generate n_points random points in the unit square """ # make folder for runs folder = params.make_system_folder(TestSystemParamInversePowerBinary, BASE_FOLDER_PATH_INVERSE_POWER) # generate radii, box length etc. folder = params.generate_save_all_params_ip_binary( TestSystemParamInversePowerBinary, BASE_FOLDER_PATH_INVERSE_POWER, seed=0) # get last folder # test getting parameters from folder param_string = params.get_param_string_from_path(folder) tp = params.get_system_parameters_from_param_str(param_string) hs_radii, coords, box_length = params.load_run_params_ip_binary(folder) # test generating the ensemble ensemble = random_points.construct_save_random_configurations( folder, n_ensemble, tp["n_part"], tp["ndim"], box_length) # test loading the ensemble ensemble = random_points.load_random_configurations(folder, n_ensemble=n_ensemble) # test loading the ensemble return ensemble, param_string
def setup_minima_map_random_planes(data_folder=BASE_FOLDER_INVERSE_POWER): """ Sets up the minima map for random planes """ # make folder for runs folder = params.make_system_folder(TestSystemParamInversePowerBinary, data_folder) # generate radii, box length etc. folder = params.generate_save_all_params_ip_binary( TestSystemParamInversePowerBinary, data_folder, seed=0) # test getting parameters from folder param_string = params.get_param_string_from_path(folder) tp = params.get_system_parameters_from_param_str(param_string) hs_radii, coords, box_length = params.load_run_params_ip_binary(folder) # list of point nmesh_list = [100, 50] # initial coordinates are random anyway so we can construct points around it vec_list = random_plane.VEC_DICT[tp["n_part"]][:2] # only use first two n_scale = [12, 6] # 3 particle diameters print("box_length", box_length) plane_folder_path = random_plane.construct_and_save_plane_points( folder, coords, nmesh_list, vec_list, n_scale, runs_per_file=2) # ensemble = random_points.construct_save_random_configurations( # folder, n_ensemble, tp['n_part'], tp['ndim'], box_length) # test generating the ensemble print("plane folder path", plane_folder_path) plane_folder = plane_folder_path.split("/")[-1] # test loading the ensemble ensemble = random_plane.load_plane_points(plane_folder_path) # define minima finder minima_finder_args = [ data_folder, param_string, quench_cvode_opt, ] quench_kwargs = { "rtol": 1e-7, "atol": 1e-7, "tol": 1e-6, "iterative": False, "use_newton_stop_criterion": True, } # find minima minima_finder_class = PeleMinimaFinder m_map = MinimaMap( data_folder, param_string, plane_folder, minima_finder_class, minima_finder_args, quench_kwargs=quench_kwargs, ) return m_map
def setup_minima_map_random_planes(): """ Sets up the minima map for random planes """ # make folder for runs folder = params.make_system_folder( TestSystemParamInversePowerBinary, BASE_FOLDER_INVERSE_POWER ) # generate radii, box length etc. folder = params.generate_save_all_params_ip_binary( TestSystemParamInversePowerBinary, BASE_FOLDER_INVERSE_POWER, seed=0 ) # test getting parameters from folder param_string = params.get_param_string_from_path(folder) tp = params.get_system_parameters_from_param_str(param_string) hs_radii, coords, box_length = params.load_run_params_ip_binary(folder) # test generating the ensemble nmesh_l = [3, 3] # initial coordinates are random anyway so we can construct points around it # only use first two vec_list = random_plane.VEC_DICT[tp["n_part"]][:2] # vec_list = random_plane.translate_first_and_last_particle( # tp['n_part'], tp['ndim']) print(vec_list) n_scale = [1, 1] # 3 particle diameters plane_folder_path = random_plane.construct_and_save_plane_points( folder, coords, nmesh_l, vec_list, n_scale ) plane_folder_name = plane_folder_path.split("/")[-1] # ensemble = random_points.construct_save_random_configurations( # folder, n_ensemble, tp['n_part'], tp['ndim'], box_length) # test generating the ensemble # test loading the ensemble ensemble = random_plane.load_plane_points(plane_folder_path) # define minima finder minima_finder_args = [BASE_FOLDER_INVERSE_POWER, param_string, quench_cvode_opt] quench_kwargs = {"rtol": 1e-7, "atol": 1e-7, "tol": 1e-6, "iterative": False} # find minima minima_finder_class = PeleMinimaFinder m_map = MinimaMap( BASE_FOLDER_INVERSE_POWER, param_string, plane_folder_name, minima_finder_class, minima_finder_args, quench_kwargs, ) m_map.map_all() return m_map.final_minima_folder_name, plane_folder_name
def setup_minima_map_random_points(): """ Sets up the minima map for the test. """ # make folder for runs folder = params.make_system_folder( TestSystemParamInversePowerBinary, BASE_FOLDER_INVERSE_POWER ) # generate radii, box length etc. folder = params.generate_save_all_params_ip_binary( TestSystemParamInversePowerBinary, BASE_FOLDER_INVERSE_POWER, seed=0 ) # get last folder # test getting parameters from folder param_string = params.get_param_string_from_path(folder) tp = params.get_system_parameters_from_param_str(param_string) hs_radii, coords, box_length = params.load_run_params_ip_binary(folder) # test generating the ensemble n_ensemble = 10 ensemble = random_points.construct_save_random_configurations( folder, n_ensemble, tp["n_part"], tp["ndim"], box_length ) # test loading the ensemble ensemble = random_points.load_random_configurations(folder, n_ensemble=n_ensemble) # define minima finder quench = quench_mixed_optimizer minima_finder_args = [ BASE_FOLDER_INVERSE_POWER, param_string, quench_mixed_optimizer, ] # find minima minima_finder_class = PeleMinimaFinder quench_kwarg_dict = {"rtol": 1e-5, "atol": 1e-5, "T": 30, "iterative": True} m_map = MinimaMap( BASE_FOLDER_INVERSE_POWER, param_string, random_points.FOLDER_NAME, minima_finder_class, minima_finder_args, quench_kwarg_dict, n_ensemble, ) return m_map
def setup_minima_from_old_data(): # copy the all the old data into the working folder if os.path.exists(WORKING_FOLDER): shutil.rmtree(WORKING_FOLDER) os.system("cp -r " + OLD_DATA_FOLDER + " " + WORKING_FOLDER) # remove README file from working dir os.system("rm " + WORKING_FOLDER + "/README.org") # assert that the working directory contains only one folder assert len(os.listdir(WORKING_FOLDER)) == 1 working_path = WORKING_FOLDER + "/" + os.listdir(WORKING_FOLDER)[0] plane_folder_name = "random_plane" plane_folder_path = working_path + plane_folder_name # assuming that the working folder has been generated by the ensemble module # random_plane.load_plane_points(plane_folder_path) # we now want to use the minima_map module to generate the minimap param_string = get_param_string_from_path(working_path) # define minima finder minima_finder_args = [WORKING_FOLDER, param_string, quench_cvode_opt] # load minima finder params from working folder with open(working_path + "/minima_finder_params.yaml", "r") as minima_finder_param_file: minima_finder_params = yaml.load(minima_finder_param_file, Loader=yaml.FullLoader) # find minima minima_finder_class = PeleMinimaFinder m_map = MinimaMap( WORKING_FOLDER, param_string, plane_folder_name, minima_finder_class, minima_finder_args, minima_finder_params, ) m_map.map_all() return m_map.final_minima_folder_path, plane_folder_name
def setup_minima_map_random_planes(param_enum, nmesh, nscale, nprocs, runs_per_file): """ Sets up the minima map for random planes """ # make folder for runs folder = params.make_system_folder(param_enum, BASE_FOLDER_PATH_INVERSE_POWER) # generate radii, box length etc. folder = params.generate_save_all_params_ip_binary( param_enum, BASE_FOLDER_PATH_INVERSE_POWER, seed=0) # test getting parameters from folder param_string = params.get_param_string_from_path(folder) tp = params.get_system_parameters_from_param_str(param_string) hs_radii, coords, box_length = params.load_run_params_ip_binary(folder) print(tp) # test generating the ensemble nmesh_l = [nmesh, nmesh] # initial coordinates are random anyway so we can construct points around it n_scale = [nscale, nscale] # 3 particle diameters n_particles = len(hs_radii) vec_list = generate_random_unit_gauss_3(n_particles, 2, 0)[:2] plane_folder_path = random_plane.construct_and_save_plane_points( folder, coords, nmesh_l, vec_list, n_scale, runs_per_file) # ensemble = random_points.construct_save_random_configurations( # folder, n_ensemble, tp['n_part'], tp['ndim'], box_length) # test generating the ensemble plane_folder = plane_folder_path.split("/")[-1] # test loading the ensemble ensemble = random_plane.load_plane_points(plane_folder_path) return ensemble, param_string, plane_folder_path
def full_run_minima_map_torus_points(): """ Sets up the map to the basins of attraction for points on a torus. """ # TODO: You should condense this into a single function # generate radii, box length etc. folder = params.generate_save_all_params_ip_binary( TestSystemParamInversePowerBinary, BASE_FOLDER_INVERSE_POWER, seed=0) # get last folder # test getting parameters from folder param_string = params.get_param_string_from_path(folder) tp = params.get_system_parameters_from_param_str(param_string) hs_radii, coords, box_length = params.load_run_params_ip_binary(folder) # generate torus points and save them torus_center = coords scale_x = 12.0 scale_y = 6.0 dim = 2 seed = 0 unit_vec_x, unit_vec_y, unit_vec_z = generate_random_unit_gauss_3( len(hs_radii), dim, seed) x_vec = scale_x * unit_vec_x y_vec = scale_y * unit_vec_y n_mesh_x = 4 n_mesh_y = 2 # since we want a cylinder torus_radius = scale_y n_theta = 2 torus = RectangularTorus( torus_center, torus_radius, x_vec, y_vec, unit_vec_z, n_mesh_x, n_mesh_y, n_theta, r_along_x=False, ) id_tol = 1e-3 id_tol_str = str(id_tol) torus.generate_plane_list() torus_folder_path = torus.save_points(folder, 4, 1) torus_folder_name = os.path.basename(torus_folder_path) quench = quench_cvode_opt minima_finder_args = [ BASE_FOLDER_INVERSE_POWER, param_string, quench, ] minima_finder_class = PeleMinimaFinder quench_kwarg_dict = { "rtol": 1e-5, "atol": 1e-5, "use_newton_stop_criterion": True, "tol": 1e-7, } job_processes = 1 m_map = BatchJobMinimaMap( BASE_FOLDER_INVERSE_POWER, param_string, torus_folder_name, minima_finder_args, job_script_base=cluster_job_script_base, quench_config=quench_kwarg_dict, job_command="bash", job_processes=job_processes, ) m_map.map_all(submit=True) # run identification process on the folders subprocess.run([ "julia", "../basinerror/scripts/identify_basins.jl", m_map.final_minima_folder_path, "-i", id_tol_str, ])
def main(point_generation_processes=1, ): base_folder = SAVE_PATH ### ALL PARAMETERS ### ## torus parameters dim = System.ndim.value seed = 0 scale_x = 12 scale_y = 6.75 n_mesh_x = 1920 n_mesh_y = 1080 n_theta = 900 r_along_x = False # For how many coordinates to sve in a single file runs_per_file = 120 * 120 # because gcd squared # runs_per_file = 4000 # slurm parameters time_str = "02:00:00" mem_str = "10g" ## run parameters quench_kwarg_dict = { "rtol": 1e-5, "atol": 1e-5, "use_newton_stop_criterion": True, "tol": 1e-6, } # for multiproc, how many minimization processes to run at once # in the job job_processes = 10 quench = quench_cvode_opt os.makedirs(base_folder, exist_ok=True) parameter_specified_folder = params.generate_save_all_params_ip_binary( System, base_folder, seed=0) param_string = params.get_param_string_from_path( parameter_specified_folder) hs_radii, coords, box_length = params.load_run_params_ip_binary( parameter_specified_folder) print("box length:", box_length) torus_center = coords unit_vec_x, unit_vec_y, unit_vec_z = generate_random_unit_gauss_3( len(hs_radii), dim, seed) x_vec = scale_x * unit_vec_x y_vec = scale_y * unit_vec_y torus_radius = scale_y torus = RectangularTorus( torus_center, torus_radius, x_vec, y_vec, unit_vec_z, n_mesh_x, n_mesh_y, n_theta, r_along_x=r_along_x, ) torus.generate_plane_list() torus_folder_path = torus.save_points(parameter_specified_folder, runs_per_file, point_generation_processes) torus_folder_name = os.path.basename(torus_folder_path) time_memory_formatted_template = PLANE_GREENE_TEMPLATE.format( time_str=time_str, mem_str=mem_str, job_processes="job_processes", # strings for formatting later final_minima_folder_name="final_minima_folder_name", ensemble_directory="ensemble_directory", HOME=r"{HOME}", ) minima_finder_args = [base_folder, param_string, quench] m_map = BatchJobMinimaMap( base_folder, param_string, torus_folder_name, minima_finder_args, job_script_base=time_memory_formatted_template, quench_config=quench_kwarg_dict, job_command="sbatch", job_processes=job_processes, ) m_map.map_all() # IMPORTANT: last line is used by the shell script to cd into the script folder print(m_map.final_minima_folder_path)
def setup_minima_map_random_planes( parameter_enum, n_mesh_x, n_mesh_y, nscale_x, nscale_y, n_processes, runs_per_file, save_location, ): """ Sets up the minima map for random planes """ # make folder for runs folder = params.make_system_folder(parameter_enum, save_location) # generate radii, box length etc. folder = params.generate_save_all_params_ip_binary( parameter_enum, save_location, seed=0 ) # test getting parameters from folder param_string = params.get_param_string_from_path(folder) hs_radii, coords, box_length = params.load_run_params_ip_binary(folder) # test generating the ensemble n_mesh_list = [n_mesh_x, n_mesh_y] # initial coordinates are random anyway so we can construct points around it n_scale_list = [nscale_x, nscale_y] # 3 particle diameters n_particles = len(hs_radii) vec_list = generate_random_unit_gauss_3(n_particles, 2, 0)[:2] plane_folder_path = random_plane.construct_and_save_plane_points( folder, coords, n_mesh_list, vec_list, n_scale_list, runs_per_file ) plane_folder = plane_folder_path.split("/")[-1] # test loading the ensemble ensemble = random_plane.load_plane_points(plane_folder_path) # define minima finder minima_finder_args = [save_location, param_string, quench_cvode_opt] # find minima rtol = 1e-5 atol = rtol opt_tol = 1e-6 quench_kwarg_dict = { "rtol": rtol, "atol": atol, "tol": opt_tol, "use_newton_stop_criterion": True, } minima_finder_class = PeleMinimaFinder m_map = MinimaMap( save_location, param_string, plane_folder, minima_finder_class, minima_finder_args, quench_kwargs=quench_kwarg_dict, ) # , checkpointing=True, final_minima_folder_name='random_plane_quench_cvode_opt' m_map.map_all_parallel(production=True, processes=n_processes) return m_map