def test_param_file():
param_file_name = 'test_param_file_param.pkl'
param_file_name = ut.check_file_name(param_file_name, 'param', 'pkl')
assert param_file_name == 'test_param_file'
param_file_name = 'test_param_file.pkl'
param_file_name = ut.check_file_name(param_file_name, extension='pkl')
assert param_file_name == 'test_param_file'
param_file_name = 'test_param_file_param'
param_file_name = ut.check_file_name(param_file_name, file_type='param')
assert param_file_name == 'test_param_file'
if not os.path.exists('{}.pkl'.format(param_file_name)):
ut.make_param_file(param_file_name)
param_file = ut.read_param_file(param_file_name)
param_file = ut.update_param_file(param_file_name, 'M',
[16.0, 1.008, 1.008, 0])
assert len(param_file['M']) == 4
assert np.sum(np.array(param_file['M']) - 18.016) <= THRESH
os.remove(param_file_name + '.pkl')
def check_file_names(input_list, file_names=False):
"""
check_file_names(input_list, file_names=False)
Checks input_list to find file names
"""
if not file_names: file_names = get_file_name_defaults()
if ('-param' in input_list):
file_names['param_file_name'] = input_list[input_list.index('-param') +
1]
if ('-pos' in input_list):
file_names['pos_file_name'] = input_list[input_list.index('-pos') + 1]
if ('-traj' in input_list):
file_names['traj_file_name'] = input_list[input_list.index('-traj') +
1]
else:
file_names['traj_file_name'] = file_names['pos_file_name']
if ('-rst' in input_list):
file_names['restart_file_name'] = input_list[input_list.index('-rst') +
1]
else:
file_names['restart_file_name'] = file_names['pos_file_name']
if ('-out' in input_list):
file_names['output_file_name'] = input_list[input_list.index('-out') +
1]
else:
file_names['output_file_name'] = file_names['traj_file_name']
if ('-gif' in input_list):
file_names['gif_file_name'] = input_list[input_list.index('-gif') + 1]
else:
file_names['gif_file_name'] = file_names['traj_file_name']
if file_names['param_file_name']:
file_names['param_file_name'] = ut.check_file_name(
file_names['param_file_name'], 'param', 'pkl') + '_param'
if file_names['pos_file_name']:
file_names['pos_file_name'] = ut.check_file_name(
file_names['pos_file_name'], extension='npy')
if file_names['traj_file_name']:
file_names['traj_file_name'] = ut.check_file_name(
file_names['traj_file_name'], 'traj', 'npy') + '_traj'
if file_names['restart_file_name']:
file_names['restart_file_name'] = ut.check_file_name(
file_names['restart_file_name'], 'rst', 'npy') + '_rst'
if file_names['output_file_name']:
file_names['output_file_name'] = ut.check_file_name(
file_names['output_file_name'], 'out', 'npy') + '_out'
if file_names['gif_file_name']:
file_names['gif_file_name'] = ut.check_file_name(
file_names['gif_file_name'], extension='png')
return file_names
def analysis(current_dir, input_file_name=False):
sim_dir = current_dir + '/sim/'
gif_dir = current_dir + '/gif/'
fig_dir = current_dir + '/fig/'
data_dir = current_dir + '/data/'
ow_shg = ('-ow_shg' in sys.argv)
ow_data = ('-ow_data' in sys.argv)
mk_gif = ('-mk_gif' in sys.argv)
print("\n " + " " * 15 + "----Beginning Image Analysis----\n")
if not os.path.exists(gif_dir): os.mkdir(gif_dir)
if not os.path.exists(fig_dir): os.mkdir(fig_dir)
if not os.path.exists(data_dir): os.mkdir(data_dir)
file_names, param = setup.read_shell_input(current_dir,
sim_dir,
input_file_name,
verbosity=False)
fig_name = file_names['gif_file_name'].split('/')[-1]
keys = ['l_conv', 'res', 'sharp', 'skip', 'l_sample', 'min_sample']
print("\n Analysis Parameters found:")
for key in keys:
print(" {:<15s} : {}".format(key, param[key]))
print("\n Loading output file {}{}".format(sim_dir,
file_names['output_file_name']))
tot_energy, tot_temp, tot_press = ut.load_npy(
sim_dir + file_names['output_file_name'])
tot_energy *= param['l_fibril'] / param['n_bead']
print_thermo_results(fig_dir, fig_name, tot_energy, tot_temp, tot_press)
print("\n Loading trajectory file {}{}.npy".format(
sim_dir, file_names['traj_file_name']))
tot_pos = ut.load_npy(sim_dir + file_names['traj_file_name'])
n_frame = tot_pos.shape[0]
n_image = int(n_frame / param['skip'])
cell_dim = tot_pos[0][-1]
n_xyz = tuple(
np.array(cell_dim * param['l_conv'] * param['res'], dtype=int))
conv = param['l_conv'] / param['sharp'] * param['res']
image_md = np.moveaxis([tot_pos[n][:-1] for n in range(0, n_frame)], 2, 1)
"Perform Fibre Vector analysis"
tot_theta, tot_mag = fibre_vector_analysis(image_md, cell_dim, param)
print_vector_results(fig_dir, fig_name, param, tot_mag, tot_theta)
"Generate SHG Images"
image_file_name = ut.check_file_name(file_names['output_file_name'], 'out',
'npy') + '_{}_{}_{}_image_shg'.format(
n_frame, param['res'],
param['sharp'])
if not ow_shg:
try:
image_shg = ut.load_npy(sim_dir + image_file_name,
range(0, n_frame, param['skip']))
except:
ow_shg = True
if ow_shg:
"Generate Gaussian convoluted images and intensity derivatives"
image_shg = shg_images(image_md, param['vdw_sigma'] * conv, n_xyz,
2 * param['rc'] * conv)
print("\n Saving image files {}".format(
file_names['output_file_name']))
ut.save_npy(sim_dir + image_file_name, image_shg)
image_shg = np.array(
[image_shg[i] for i in range(0, n_frame, param['skip'])])
fig_name += '_{}_{}'.format(param['res'], param['sharp'])
"Make Gif of SHG Images"
if ow_shg or mk_gif:
print('\n Making Simulation SHG Gif {}/{}.gif'.format(
fig_dir, fig_name))
make_gif(fig_name + '_SHG', fig_dir, gif_dir, n_image, image_shg,
param, cell_dim * param['l_conv'], 'SHG')
def import_files_mpi(sim_dir,
file_names,
param,
comm,
size=1,
rank=0,
verbosity=True):
"""
import_files(sim_dir, file_names, param)
Imports existing or creates new simulation files listed in file_names
Parameters
----------
sim_dir: str
Directory in which simulation files are to be saved
file_names: list (str)
List of simulation and analysis files names
param: dict
Dictionary of simulation and analysis parameters
Returns
-------
pos: array_like (float); shape=(n_bead, n_dim)
Positions of n_bead beads in n_dim
vel: array_like, dtype=float
Velocity of each bead in all collagen fibrils
cell_dim: array_like (float); shape=(n_dim)
Simulation cell dimensions in n_dim dimensions
param: dict
Dictionary of simulation and analysis parameters
"""
from mpi4py import MPI
from simulation_mpi import equilibrate_temperature_mpi, equilibrate_density_mpi
if os.path.exists(sim_dir + file_names['restart_file_name'] + '.npy'):
if rank == 0:
if verbosity:
print(" Loading restart file {}.npy".format(
sim_dir + file_names['restart_file_name']))
restart = ut.load_npy(sim_dir + file_names['restart_file_name'])
else:
restart = None
restart = comm.bcast(restart, root=0)
pos = restart[0]
vel = restart[1]
cell_dim = pos[-1]
pos = pos[:-1]
elif os.path.exists(sim_dir + file_names['pos_file_name'] + '.npy'):
if rank == 0:
if verbosity:
print(" Loading position file {}.npy".format(
sim_dir + file_names['pos_file_name']))
pos = ut.load_npy(sim_dir + file_names['pos_file_name'])
else:
pos = None
pos = comm.bcast(pos, root=0)
cell_dim = pos[-1]
pos = pos[:-1]
pos, vel = equilibrate_temperature_mpi(sim_dir, pos, cell_dim, param,
comm, size, rank)
else:
file_names['pos_file_name'] = ut.check_file_name(
file_names['pos_file_name'], file_type='pos') + '_pos'
if rank == 0:
if verbosity:
print(" Creating input pos file {}{}.npy".format(
sim_dir, file_names['pos_file_name']))
pos, cell_dim, param = create_pos_array(param)
#param['l_conv'] = 1. / param['vdw_sigma']
keys = ['bond_matrix', 'angle_array', 'vdw_matrix'] #, 'l_conv']
for key in keys:
ut.update_param_file(sim_dir + file_names['param_file_name'],
key, param[key])
if verbosity:
print(" Saving input pos file {}{}.npy".format(
sim_dir, file_names['pos_file_name']))
ut.save_npy(sim_dir + file_names['pos_file_name'],
np.vstack((pos, cell_dim)))
else:
pos = None
cell_dim = None
pos = comm.bcast(pos, root=0)
cell_dim = comm.bcast(cell_dim, root=0)
param = comm.bcast(param, root=0)
pos, vel = equilibrate_temperature_mpi(sim_dir, pos, cell_dim, param,
comm, size, rank)
pos, vel, cell_dim = equilibrate_density_mpi(pos, vel, cell_dim, param,
comm, size, rank)
if rank == 0:
if verbosity:
print(" Saving restart file {}".format(
file_names['restart_file_name']))
ut.save_npy(sim_dir + file_names['restart_file_name'], (np.vstack(
(pos, cell_dim)), vel))
return pos, vel, cell_dim, param