def FindMinimumHSWCA(foldname):
""" Finds the true minimum corresponding:
Note Gradient Descent step should be adequately small for this to work
"""
foldpath = BASE_DIRECTORY + "/" + foldname
sysparams = load_params(foldpath)
(hs_radii, initial_coords, box_length) = load_secondary_params(foldpath)
box_length = float(box_length)
boxv = [box_length] * sysparams.ndim.value
potential = HS_WCA(
use_cell_lists=False,
eps=sysparams.eps.value,
sca=sysparams.pot_sca.value,
radii=hs_radii * sysparams.radius_sca.value,
boxvec=boxv,
ndim=sysparams.ndim.value,
distance_method=Distance.PERIODIC,
)
# ret = steepest_descent(initial_coords, potential)
# ret = fire(initial_coords, potential, iprint=1)
# E, V = print(potential.getEnergyGradient(initial_coords))
# ret = quench_mixed_optimizer(potential, initial_coords, conv_tol=1e-100)
ret = quench_mixed_optimizer(potential,
initial_coords,
conv_tol=0,
nsteps=1000)
# ret = quench_steepest(potential, initial_coords, stepsize=0.05, nsteps=2000)
print(ret.nsteps)
print(ret.nfev)
np.savetxt(foldpath + "/trueminimum.txt", ret.coords, delimiter=",")
def FindMinimumInversePower(foldname):
""" Finds the true minimum corresponding:
Note Gradient Descent step should be adequately small for this to work
"""
foldpath = BASE_DIRECTORY + "/" + foldname
sysparams = load_params(foldpath)
(hs_radii, initial_coords, box_length) = load_secondary_params(foldpath)
box_length = float(box_length)
boxv = [box_length] * sysparams.ndim.value
potential = InversePower(
sysparams.power.value,
sysparams.eps.value,
use_cell_lists=False,
ndim=sysparams.ndim.value,
radii=hs_radii * 1.0,
boxvec=boxv,
)
print(box_length, "box_length")
print(len(initial_coords))
# initial_coords = np.loadtxt(foldpath + '/coords_of_minimum.txt',
# delimiter=',')
print(initial_coords, "initial_coords")
# ret = steepest_descent(initial_coords, potential, dx=1e-4)
# ret = modifiedfire_cpp(initial_coords, potential, iprint=1, tol=1e-4)
# E, V = print(potential.getEnergyGradient(initial_coords))
# ret = quench_mixed_optimizer(potential, initial_coords, conv_tol=1e-100)
# ret = quench_mixed_optimizer(potential, initial_coords, conv_tol=1e-100, nsteps=3000)
# ret = quench_steepest(
# potential,
# initial_coords, # make sure right coords are being passed
# stepsize=0.0001,
# nsteps=1000,
# tol=1e-7)
# ret = quench_cvode_opt(initial_coords, potential, )
ret = quench_cvode_opt(initial_coords,
potential,
tol=1e-9,
rtol=1e-10,
atol=1e-10)
finalcoords = ret.coords
print(ret.coords)
# np.savetxt(foldpath + '/coords_of_minimum.txt', finalcoords, delimiter=',')
print(ret)
# print(ret.coords)
# print(ret2.coords)
# print(ret2.coords-ret.coords)
print(finalcoords)
E, V, H = potential.getEnergyGradientHessian(finalcoords)
print(np.linalg.eigvals(H), "all eigenvalues")
def get_configuration(folder_path, minima_database_name, minima_number):
""" Gets a minimum configuration i.e the coordinates and the radii
Args:
folder_path path
minima_database_name folder name
minima_number index of minima to be plotted
Returns:
minimum configuration, radii
"""
mimima_database_path = folder_path + minima_database_name
minima = np.load(mimima_database_path)
(radii, initial_coords, box_length) = load_secondary_params(folder_path)
nparticles = len(radii)
dimensions = 2
configuration = np.reshape(minima[minima_number], (nparticles, dimensions))
return radii, configuration, box_length
1.4531033229914481,
1.9008953836870657,
3.9645483931986578,
0.9724951066931532,
8.3663305823749905,
3.16224709493039,
]
ctol = 1e-2
ndim = 2
base_dir = "/home/praharsh/Dropbox/research/bv-libraries/basinerror/datainv"
foldnameInversePower = "ndim=2phi=0.9seed=0n_part=16r1=1.0r2=1.4rstd1=0.05rstd2=0.06999999999999999use_cell_lists=0power=2.5eps=1.0"
data_loc = base_dir + "/" + foldnameInversePower
minima_database_path = data_loc + "minima_database.npy"
(hs_radii, initial_coords, box_length) = load_secondary_params(data_loc)
sysparams = load_params(data_loc)
potential = InversePower(
sysparams.power.value,
sysparams.eps.value,
use_cell_lists=False,
ndim=sysparams.ndim.value,
radii=hs_radii * 1.0,
boxvec=[box_length, box_length],
)
minima_container_debug = CheckSameMinimum(
ctol,
ndim,
boxl=box_length,
minimalist_max_len=2000,
minima_database_location=minima_database_path,
print(minima_database_path)
initial_coords = data.initial_coords
order_params = data.order_params
minimalist = data.minimalist
print(order_params)
# set min max values
vmax = GLASBEY_2000_LENGTH
# print(GLASBEY_2000_LENGTH, 'glasbey length')
print(data)
vmin = 0
res = extract_min_max_spacing(initial_coords)
xlen = int(np.sqrt(len(order_params)))
(hs_radii, initial_coords,
box_length) = load_secondary_params(BASE_DIRECTORY + "/" +
foldnameInversePower)
op_2d = np.reshape(order_params, (xlen, xlen))
# print(np.max(order_params), 'order parameters')
# np.set_printoptions(threshold=np.inf)
d = lambda x: x / box_length
# print to order params txt to inspect
cmaplist = glasbey2000
cmap = colors.ListedColormap(cmaplist)
# note that the -1 is important otherwise it is not unique
vmax = len(cmaplist) - 1
print(vmax, "vmax")
print(vmax, "glasbey length")
print(z)
vmin = 0
def map_binary_inversepower(
foldername,
particle_coords,
optimizer,
parameter_dict,
random_coord_0=0,
random_coord_1=-1,
z=0,
):
"""
Finds whether a point defined by particle_coord
on the meshgrid correspond to a minimum or not for a 2d
case.
"""
foldpath = BASE_DIRECTORY + "/" + foldername
# import params
sysparams = load_params(foldpath)
(hs_radii, initial_coords, box_length) = load_secondary_params(foldpath)
assert sysparams.ndim.value == 2
minimum_coords = np.loadtxt(foldpath + "/coords_of_minimum.txt", delimiter=",")
quench_coords = initial_coords.copy()
if len(quench_coords) == 16:
quench_coords = (
quench_coords
+ particle_coords[0] * VEC_8_0
+ particle_coords[1] * VEC_8_1
+ z * VEC_8_2
)
elif len(quench_coords) == 32:
quench_coords = (
quench_coords
+ particle_coords[0] * VEC_16_0
+ particle_coords[1] * VEC_16_1
+ z * VEC_16_2
)
elif len(quench_coords) == 64:
quench_coords = (
quench_coords
+ particle_coords[0] * VEC_16_0
+ particle_coords[1] * VEC_16_1
+ z * VEC_16_2
)
else:
raise Exception("error other random coords have not been generated")
print(quench_coords, "quench")
# print(quench_coords, 'quench coords')
# box length
box_length = float(box_length)
boxv = [box_length] * sysparams.ndim.value
ncellx_scale = get_ncellsx_scale(hs_radii, boxv)
potential = InversePower(
sysparams.power.value,
sysparams.eps.value,
use_cell_lists=False,
ndim=sysparams.ndim.value,
radii=hs_radii * 1.0,
boxvec=boxv,
)
# ret = quench_mixed_optimizer(potential,
# quench_coords, # make sure right coords are being passed
# T=10,
# step=1,
# nsteps=100000,
# conv_tol=1e-8,
# tol=1e-6, rtol=1e-4, atol=1e-4)
# ret = quench_steepest(
# potential,
# quench_coords, # make sure right coords are being passed
# nsteps=2000000,
# stepsize=5e-3, # for steepest descent step size should be small
# tol=1e-4)
# ret = quench_cvode_opt(potential, quench_coords, tol=1e-6, rtol=1e-4, atol=1e-4)
try:
ret = optimizer(quench_coords, potential, **parameter_dict)
except:
print(quench_coords, "failed here")
print(initial_coords, "coords")
print(len(quench_coords))
raise Exception("failure")
# ret = lbfgs_cpp(quench_coords, potential, tol=1e-8, M=1)
# This exists because some runs don't have hessian evaluations
try:
ret["nhev"]
except:
ret["nhev"] = 0
coordarg = 0
results = (ret.coords, ret.success, coordarg, ret.nfev, ret.nsteps, ret.nhev)
# the reason the potential is being passed is because quench coords needs the potential to figure out what to do
return results
def map_binary_inversepower_mxopt_jl(
foldername,
particle_coords,
optimizer,
opt_param_dict,
random_coord_0=0,
random_coord_1=-1,
z=0,
):
"""
Finds whether a point defined by particle_coord
on the meshgrid correspond to a minimum or not for a 2d
case.
"""
foldpath = BASE_DIRECTORY + "/" + foldername
# import params
sysparams = load_params(foldpath)
(hs_radii, initial_coords, box_length) = load_secondary_params(foldpath)
assert sysparams.ndim.value == 2
minimum_coords = np.loadtxt(foldpath + "/coords_of_minimum.txt",
delimiter=",")
minimum_coords = np.loadtxt(foldpath + "/coords_of_minimum.txt",
delimiter=",")
quench_coords = initial_coords.copy()
quench_coords = (quench_coords + particle_coords[0] * VEC_16_0 +
particle_coords[1] * VEC_16_1 + z * VEC_16_2)
# quench_coords = quench_coords + \
# particle_coords[0]*VEC_8_0 + particle_coords[1]*VEC_8_1 + z*VEC_8_2
# print(quench_coords, 'quench coords')
# box length
box_length = float(box_length)
boxv = [box_length] * sysparams.ndim.value
ncellx_scale = get_ncellsx_scale(hs_radii, boxv)
print(hs_radii, "hs_radii")
print(quench_coords, "quench_coords")
print(boxv)
potential = Main.pot.InversePower(
sysparams.power.value,
sysparams.eps.value,
use_cell_lists=False,
ndim=sysparams.ndim.value,
radii=hs_radii * 1.0,
boxvec=boxv,
)
ppot = Main.PythonPotential(potential)
nls = Main.NewtonLinesearch(ppot, quench_coords, opt_param_dict["tol"])
mxd = Main.Mixed_Descent(
ppot,
Main.CVODE_BDF(),
nls,
quench_coords,
opt_param_dict["T"],
opt_param_dict["rtol"],
opt_param_dict["conv_tol"],
opt_param_dict["tol"],
)
try:
Main.run_b(mxd, 10000)
except:
print(quench_coords, "failed here")
print(initial_coords, "coords")
print(len(quench_coords))
# ret = lbfgs_cpp(quench_coords, potential, tol=1e-8, M=1)
# This exists because some runs don't have hessian evaluations
coordarg = 0
print(mxd.converged, "converged")
results = (
mxd.optimizer.x0,
mxd.converged,
0,
mxd.n_g_evals,
mxd.iter_number,
mxd.n_h_evals,
)
# the reason the potential is being passed is because quench coords needs the potential to figure out what to do
return results
def map_pointset_loop_xy(
foldname,
pointset,
optimizer,
parameter_dict,
ctol=1e-2,
ndim=2,
use_minima_database=True,
minima_database_path=None,
coord_arg_0=0,
coord_arg_1=1,
z=0,
):
""" Checks a bunch of points if they match to a minimum by using a for loop
"""
is_same_minimum_list = []
resultlist = []
foldpath = BASE_DIRECTORY + "/" + foldname
sysparams = load_params(foldpath)
(hs_radii, initial_coords, box_length) = load_secondary_params(foldpath)
minimum_coords = np.loadtxt(foldpath + "/coords_of_minimum.txt", delimiter=",")
# Initialize CheckSameMinimum
potential = InversePower(
sysparams.power.value,
sysparams.eps.value,
use_cell_lists=False,
ndim=sysparams.ndim.value,
radii=hs_radii * 1.0,
boxvec=[box_length, box_length],
)
minima_container = CheckSameMinimum(
ctol,
ndim,
boxl=box_length,
minimalist_max_len=200000,
minima_database_location=minima_database_path,
update_database=True,
rattler_check=True,
potential=potential,
hs_radii=hs_radii,
)
if use_minima_database == True:
try:
minima_container.minimalist = [
minima_container.box_reshape_coords(x)
for x in np.load(minima_database_path)
]
except:
print("warning no minima data found. generating")
minima_container.minimalist = [
# minima_container.box_reshape_coords(minimum_coords)
]
nfevlist = []
nstepslist = []
nhevlist = []
for index, point in enumerate(pointset):
res = map_binary_inversepower(
foldname,
point,
optimizer,
parameter_dict,
random_coord_0=coord_arg_0,
random_coord_1=coord_arg_1,
z=z,
)
minima_container.add_minimum(res[0], point, res[2])
# print(index)
# print(minima_container.nrattlermin, 'nrattlermin')
# print(minima_container.nfluidstates, 'nfluidstates')
nfevlist.append(res[3])
nstepslist.append(res[4])
nhevlist.append(res[5])
# print(np.average(nfevlist), 'number of function evaluations')
# print(np.average(nstepslist), 'number of steps')
# print(np.average(nstepslist), 'number of steps')
# print(np.average(nhevlist), "number of hessian evaluations")
# print(minima_container.orderparamlist)
foldpathdata = foldpath + "/" + QUENCH_FOLDER_NAME + "/z_data_30_l6/" + str(z)
os.makedirs(foldpathdata, exist_ok=True)
minima_container.dump_map(foldpathdata)
run_diagnostics = {}
run_diagnostics["nfev"] = float(np.average(nfevlist))
run_diagnostics["nhev"] = float(np.average(nhevlist))
run_diagnostics["nsteps"] = float(np.average(nstepslist))
# print(minima_container.initial_coords_list)
# print(minima_container.orderparamlist)
# print(minima_container.orderparamlist)
return run_diagnostics, is_same_minimum_list, resultlist
def construct_point_set_2d(
foldername, nmesh, boxlscale, random_coord_0=0, random_coord_1=1
):
""" Constructs a point set in 2d around a minimum for mapping the
basin projection for a single particle.
Parameters
----------
foldername : name of the folder containing
1) the coordinates of the minimum
around which we constuct the grid
2) the boxlength in a parameter file
nmesh : the number of mesh points in 2 directions
boxlscale : scale of the box
Returns
-------
out : a set of points over which we wish to map the basin
"""
foldpath = BASE_DIRECTORY + "/" + foldername
(hs_radii, initial_coords, box_length) = load_secondary_params(foldpath)
# get necessary parameters from the folder
box_length = 6
# minimum_coords = np.loadtxt(foldpath + '/coords_of_minimum.txt',
# delimiter=',')
center = initial_coords
center = [-box_length / 2, -box_length / 2]
# sets the length of the x and y range over which
# the mesh is calculated
# This division in cases is because linspace doesn't
# give the right answer for n = 1
if nmesh != 1:
# x_range = np.linspace(minimum_coords[coordarg] - xylength/2,
# minimum_coords[coordarg] + xylength/2, nmesh)
# y_range = np.linspace(minimum_coords[coordarg+1] - xylength/2,
# minimum_coords[coordarg+1] + xylength/2, nmesh)
# position minimum in the center
centered_x_of_min = center[random_coord_0] + box_length / 2
centered_y_of_min = center[random_coord_1] + box_length / 2
x_range = centered_x_of_min + np.linspace(0, box_length, nmesh)
y_range = centered_y_of_min + np.linspace(0, box_length, nmesh)
else:
x_range = np.array([center[random_coord_0]])
y_range = np.array([center[random_coord_1]])
np.savetxt(
BASE_DIRECTORY + "/" + foldnameInversePower + "xrange.txt",
x_range,
delimiter=",",
)
np.savetxt(
BASE_DIRECTORY + "/" + foldnameInversePower + "yrange.txt",
x_range,
delimiter=",",
)
pointset = []
#
for x in x_range[:-1]:
for y in y_range[:-1]:
pointset.append((x % box_length, y % box_length))
return pointset
from pele.potentials import InversePower
# change according to which minima you want to compare
m1_arg = 148
m2_arg = 159
m3_arg = 194
m4_arg = 195
foldnameInversePower = "ndim=2phi=0.9seed=0n_part=16r1=1.0r2=1.4rstd1=0.05rstd2=0.06999999999999999use_cell_lists=0power=2.5eps=1.0"
minima_database_path = (BASE_DIRECTORY + "/" + foldnameInversePower + "/" +
MINIMA_DATABASE_NAME)
th = np.load(minima_database_path)
foldpath = BASE_DIRECTORY + "/" + foldnameInversePower
sysparams = load_params(foldpath)
(hs_radii, initial_coords, box_length) = load_secondary_params(foldpath)
ctol = 1e-3
ndim = 2
potential = InversePower(
sysparams.power.value,
sysparams.eps.value,
use_cell_lists=False,
ndim=sysparams.ndim.value,
radii=hs_radii * 1.0,
boxvec=[box_length, box_length],
)
minima_container = CheckSameMinimum(
ctol,
ndim,
boxl=box_length,
minimalist_max_len=2000,
def map_binary_inversepower(
foldername,
particle_coords,
optimizer,
parameter_dict,
random_coord_0=0,
random_coord_1=-1,
z=0,
index=None,
mesh_length=None,
):
"""
Finds whether a point defined by particle_coord
on the meshgrid correspond to a minimum or not for a 2d
case.
"""
foldpath = BASE_DIRECTORY + "/" + foldername
# import params
sysparams = load_params(foldpath)
(hs_radii, initial_coords, box_length) = load_secondary_params(foldpath)
assert sysparams.ndim.value == 2
quench_coords = initial_coords.copy()
print("initial_coords", initial_coords)
print(particle_coords[0], particle_coords[1],
"vector coefficients as passed")
print("z value")
quench_coords = (quench_coords + particle_coords[0] * VEC_16_0 +
particle_coords[1] * VEC_16_1 + z * VEC_16_2)
# TODO: save this as a unit meshgrid
# print(quench_coords, 'quench coords')
# box length
box_length = float(box_length)
boxv = [box_length] * sysparams.ndim.value
ncellx_scale = get_ncellsx_scale(hs_radii, boxv)
print(hs_radii)
potential = InversePower(
sysparams.power.value,
sysparams.eps.value,
use_cell_lists=False,
ndim=sysparams.ndim.value,
radii=hs_radii * 1.0,
boxvec=boxv,
)
# save potential parameters
# writing this out since Enum to dict conversion does not give the mapping we want
potential_params_fname = "potential_params.yaml"
potential_param_dict = {
"ndim": sysparams.ndim.value,
"phi": sysparams.phi.value,
"seed": 0,
"n_part": sysparams.n_part.value,
"r1": sysparams.r1.value,
"r2": sysparams.r2.value,
"rstd1": sysparams.rstd1.value,
"rstd2": sysparams.rstd2.value,
"use_cell_lists": int(False),
"power": sysparams.power.value,
"eps": sysparams.eps.value,
}
param_str = generate_param_str_from_dict(potential_param_dict)
# make directory to emulate structure by refactored code
emulation_folder = COMPARE_FOLDER_NAME + "/" + param_str
# add README to emulation folder
os.makedirs(emulation_folder, exist_ok=True)
with open(COMPARE_FOLDER_NAME + "/README.org", "w") as f:
f.write(" \#+AUTHOR Praharsh Suryadevara .\n")
f.write("* Read First.")
f.write(
"This dirctory has been auto-generated by old code before refactoring. Do not change.\n"
)
# emulates path of the refactored code
ensemble_folder_path = emulation_folder + "/ensemble/random_plane"
os.makedirs(ensemble_folder_path, exist_ok=True)
# 0 to emulate the addition of seed
sec_param_folder_path = emulation_folder + "/sec_params/0"
os.makedirs(sec_param_folder_path, exist_ok=True)
old_code_results_folder_path = emulation_folder + "/old_data"
os.makedirs(old_code_results_folder_path, exist_ok=True)
with open(emulation_folder + "/params.yaml", "w") as param_file:
yaml.dump(potential_param_dict, param_file)
opt_param_fname = "minima_finder_params.yaml"
with open(emulation_folder + "/" + opt_param_fname, "w") as param_file:
yaml.dump(parameter_dict, param_file)
initial_coords_fname = str(index) + ".txt"
np.savetxt(ensemble_folder_path + "/" + initial_coords_fname,
quench_coords,
delimiter=",")
mesh_coords_fname = str(index) + "_mesh.txt"
np.savetxt(ensemble_folder_path + "/" + mesh_coords_fname,
particle_coords,
delimiter=",")
if mesh_length is not None:
# 2 *[particle_coords[0], particle_coords[1]]/mesh_length -0.5 form our unit mesh_grid
# centered around [0, 0]
mesh_coords = (2 * np.array([particle_coords[0], particle_coords[1]]) /
mesh_length - 0.5)
mesh_coords_fname = str(index) + "_mesh.txt"
np.savetxt(ensemble_folder_path + "/" + mesh_coords_fname,
mesh_coords,
delimiter=",")
np.savetxt(
sec_param_folder_path + "/" + "initial_coords.txt",
initial_coords,
delimiter=",",
)
np.savetxt(
sec_param_folder_path + "/" + "box_length.txt",
np.array([box_length]),
delimiter=",",
)
np.savetxt(sec_param_folder_path + "/" + "hs_radii.txt",
hs_radii,
delimiter=",")
# ret = quench_mixed_optimizer(potential,
# quench_coords, # make sure right coords are being passed
# T=10,
# step=1,
# nsteps=100000,
# conv_tol=1e-8,
# tol=1e-6, rtol=1e-4, atol=1e-4)
# ret = quench_steepest(
# potential,
# quench_coords, # make sure right coords are being passed
# nsteps=2000000,
# stepsize=5e-3, # for steepest descent step size should be small
# tol=1e-4)
# ret = quench_cvode_opt(potential, quench_coords, tol=1e-6, rtol=1e-4, atol=1e-4)
try:
ret = optimizer(quench_coords, potential, **parameter_dict)
except:
raise Exception("failure")
# ret = lbfgs_cpp(quench_coords, potential, tol=1e-8, M=1)
# This exists because some runs don't have hessian evaluations
try:
ret["nhev"]
except:
ret["nhev"] = 0
coordarg = 0
final_coords = ret["coords"]
final_coords_fname = str(index) + "_coords.txt"
np.savetxt(
old_code_results_folder_path + "/" + final_coords_fname,
final_coords,
delimiter=",",
)
energy, grad, hess = potential.getEnergyGradientHessian(final_coords)
hessian_fname = str(index) + "_hessian.txt"
np.savetxt(old_code_results_folder_path + "/" + hessian_fname,
hess,
delimiter=",")
grad_fname = str(index) + "_grad.txt"
np.savetxt(old_code_results_folder_path + "/" + grad_fname,
grad,
delimiter=",")
last_step_fname = str(index) + "_step.txt"
# np.savetxt(old_code_results_folder_path + '/' +
# last_step_fname, ret['step'], delimiter=',')
# check that the minimum hessian eigenvalue is positive
# print out the eigenvector corresponding to it
eigvals, eigvecs = np.linalg.eigh(hess)
print(eigvals[1])
print(eigvecs[:, 1])
# step_in_eigvec_basis = np.matmul(eigvecs.T, ret['step'])
# step_in_eigvec_basis_normalized = step_in_eigvec_basis/np.linalg.norm(step_in_eigvec_basis)
# -1e-15 is to avoid numerical issues
if np.min(eigvals) < -1e-3:
print("minimum Eigenvalue: ", np.min(eigvals))
print("Eigenvalues: ", eigvals)
raise Exception("negative eigenvalue")
# save heuristics as a dict
results = (
ret.coords,
ret.success,
coordarg,
ret.nfev,
ret.nsteps,
ret.nhev,
eigvecs,
)
# simplified dictionary since we're only using the success variable
res_dict = {
"success": bool(ret.success),
"nsteps": ret.nsteps,
"energy": ret.energy,
"nfev": ret.nfev,
}
# print("-------------------------------------------------steppp", step_in_eigvec_basis_normalized)
# print("eigenvalues", eigvals)
yaml_fname = str(index) + ".yaml"
# save heuristics as yaml
with open(old_code_results_folder_path + "/" + yaml_fname, "w") as f:
yaml.dump(res_dict, f)
print(ret.nsteps, "nsteps")
# the reason the potential is being passed is because quench coords needs the potential to figure out what to do
return results
# print(minima_container.orderparamlist)
# print(minima_container.Bt)
return run_diagnostics, is_same_minimum_list, resultlist
if __name__ == "__main__":
foldnameInversePower = "ndim=2phi=0.9seed=0n_part=16r1=1.0r2=1.4rstd1=0.05rstd2=0.06999999999999999use_cell_lists=0power=2.5eps=1.0"
coord_arg_0 = 0
coord_arg_1 = 1
# set nmesh =1
nmesh = 100
dim = 2
phi = 0.83
data_location = BASE_DIRECTORY + "/" + foldnameInversePower
(hs_radii, initial_coords,
box_length) = load_secondary_params(data_location)
z_frames = 1
pointset, mesh_length = construct_point_set_2d(foldnameInversePower, nmesh,
0.5, coord_arg_0,
coord_arg_1)
# th = np.array(list(map(list, pointset))).T
# folders
data_location = BASE_DIRECTORY + "/" + foldnameInversePower
(hs_radii, initial_coords,
box_length) = load_secondary_params(data_location)
minima_database_path = data_location + "/" + MINIMA_DATABASE_NAME
z_range = np.linspace(0, 6.0, z_frames)
