def __init__(self, minima_folder_path, run_folder_name,
plane_folder_name) -> None:
self.minima_folder_path = minima_folder_path
self.run_folder_name = run_folder_name
self.plane_folder_name = plane_folder_name
# last two folders in list specify location of the minim
run_folder_list = minima_folder_path.split("/")
self.radii, _, self.box_length = load_run_params_ip_binary("/".join(
run_folder_list[:-2]))
run_folder_list[-2] = FINAL_COORDS_FOLDER_NAME
run_folder_list[-1] = run_folder_name
self.run_folder_path = "/".join(run_folder_list)
playground_folder_name = "playground"
run_folder_list[-2] = playground_folder_name
self.playground_folder_path = "/".join(run_folder_list)
os.makedirs(self.playground_folder_path, exist_ok=True)
self.initialize_objs()
(
self.minima_folder_path,
self.random_plane_folder_path,
) = self.get_minima_folder_and_plane_folder(minima_folder_path,
run_folder_name,
plane_folder_name)
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 from_set_paths(
cls,
minima_folder_path,
ensemble_folder_path,
run_folder_path,
playground_folder_path,
base_path,
):
# set all paths explicitly
# TODO this should be the default constructor
# then we define an overclass as a wrapper
obj = cls.__new__(cls)
obj.radii, _, obj.box_length = load_run_params_ip_binary(base_path)
obj.minima_folder_path = minima_folder_path
obj.random_plane_folder_path = ensemble_folder_path
obj.run_folder_path = run_folder_path
obj.playground_folder_path = playground_folder_path
os.makedirs(obj.playground_folder_path, exist_ok=True)
obj.initialize_objs()
return obj
def interpose_configurations(base_path, coords_list, colors_list=None):
""" Interposes soft sphere configurations in 2d
Parameters
----------
dummy_location : str
path that helps load radii and box length
coords_list : list[coords]
list of coordinates of configurations to be plotted
colors_list : list[str]
colors to be used for the discs in the configuration
"""
print(coords_list)
radii, _, box_length = load_run_params_ip_binary(base_path)
fig, ax = plt.subplots(1, 1, figsize=(10, 10))
for coords in coords_list:
fig, ax = plot_configuration_2d(radii, coords, box_length, fig_ax=(fig, ax))
plt.show()
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
