def read_parameters(self, simpar_file=None, setup=None):
"""
Read simulation parameters.
"""
if simpar_file is None:
if self.setup == 'run':
run_dir = self.simdir
elif self.setup == 'trial':
for run in os.listdir(self.simdir):
if os.path.isdir(os.path.join(
self.simdir, run)) and 'simpar.yaml' in os.listdir(
os.path.join(self.simdir, run)):
run_dir = os.path.join(self.simdir, run)
break
elif self.setup == 'trial_set':
for trial in os.listdir(self.simdir):
for run in os.listdir(os.path.join(self.simdir, trial)):
if 'simpar.yaml' in os.listdir(
os.path.join(self.simdir, run)):
run_dir = os.path.join(self.simdir, run)
break
simpar_file = os.path.join(run_dir, 'simpar.yaml')
else:
run_dir = os.path.dirname(simpar_file)
print('Reading simulation parameters from -> %s' %
run_dir) if self.verbose else None
with open(simpar_file, 'r') as sp:
simpar = yaml.load(sp)
self.parameters = Parameters(simpar)
def test_simulation_read_trial_set():
"""Test Simulation class read method for reading a trial set"""
par = Parameters()
par.k['isotropic'] = True
par.k['average'] = True
par.thermof['kpar'] = par.k
trial_set = read_trial_set(trial_set_dir, k_par=par.k)
sim = Simulation(read=trial_set_dir, setup='trial_set', parameters=par)
assert trial_set == sim.trial_set
assert len(sim) == 4
assert str(sim) == 'ideal-mof-trial-set'
def test_simulation_read_run():
"""Test Simulation class read method for reading a single run with read_run"""
par = Parameters()
par.k['read_thermo'] = True
par.k['read_info'] = True
par.thermof['kpar'] = par.k
run_dir = os.path.join(trial_dir, 'Run1')
run_data = read_run(run_dir, k_par=par.k)
sim = Simulation(read=run_dir, parameters=par)
sim.read(run_dir, setup='run')
with open(thermo_ref_file, 'r') as tref:
thermo_ref = yaml.load(tref)
assert sim.run == run_data
assert sim.run['thermo'] == thermo_ref
assert len(sim) == 1
assert str(sim) == 'Run1'
def test_simulation_get_plot_data_for_trial():
"""Test Simulation class get_plot_data method for pulling correct data for different plots of a trial"""
par = Parameters()
sim = Simulation(read=trial_dir, parameters=par, setup='trial')
with open(time_ref_file, 'r') as tiref:
time_ref = yaml.load(tiref)
assert get_plot_data(sim, 'k')['x'] == time_ref
assert get_plot_data(sim, 'k_sub')['x'] == time_ref
assert get_plot_data(sim, 'k')['legend'] == sim.trial['runs']
def test_simulation_get_plot_data_for_run():
"""Test Simulation class get_plot_data method for pulling correct data for different plots of a run"""
par = Parameters()
par.k['read_thermo'] = True
par.thermof['kpar']['read_thermo'] = True
par.thermof['kpar']['kb'] = 0.001987
run_dir = os.path.join(trial_dir, 'Run1')
sim = Simulation(read=run_dir, parameters=par, setup='run')
with open(k_ref_file, 'r') as kref:
k_ref = yaml.load(kref)
with open(time_ref_file, 'r') as tiref:
time_ref = yaml.load(tiref)
with open(thermo_ref_file, 'r') as tref:
thermo_ref = yaml.load(tref)
assert get_plot_data(sim, 'thermo') == thermo_ref
k_plot_data = get_plot_data(sim, 'k')
assert k_plot_data['x'] == time_ref
assert k_plot_data['y'][sim.run['directions'].index('x')] == k_ref
assert k_plot_data['legend'] == sim.run['directions']
def __init__(self,
read=None,
setup=None,
parameters=None,
mof=None,
read_parameters=False):
"""
Create a Lammps simulation object.
"""
self.setup = '---'
if parameters is None:
self.parameters = Parameters()
print('WARNING!: Default simulation parameters are loaded.')
else:
self.parameters = parameters
if setup is not None:
self.setup = setup
if read is not None:
self.read(read, setup, read_parameters=read_parameters)
elif mof is not None:
self.set_mof(mof)
self.verbose = True
def write_lammps_files(simdir, parameters, verbose=True):
"""
Write Lammps files using lammps_interface.
Args:
- simdir (str): Directory to write Lammps simulation files
- parameters (Parameters): Lammps simulation parameters
Returns:
- None: Writes Lammps simulation files to simulation directory
"""
print('I. Writing Lammps input and data files...') if verbose else None
lammpspar = Parameters(parameters.lammps)
sim = LammpsSimulation(lammpspar)
cell, graph = from_CIF(lammpspar.cif_file)
sim.set_cell(cell)
sim.set_graph(graph)
sim.split_graph()
sim.assign_force_fields()
sim.compute_simulation_size()
sim.merge_graphs()
sim.write_lammps_files(simdir)
class Simulation:
"""
Reading and initializing Lammps simulations
"""
def __init__(self,
read=None,
setup=None,
parameters=None,
mof=None,
read_parameters=False):
"""
Create a Lammps simulation object.
"""
self.setup = '---'
if parameters is None:
self.parameters = Parameters()
print('WARNING!: Default simulation parameters are loaded.')
else:
self.parameters = parameters
if setup is not None:
self.setup = setup
if read is not None:
self.read(read, setup, read_parameters=read_parameters)
elif mof is not None:
self.set_mof(mof)
self.verbose = True
def __repr__(self):
"""
Returns basic simulation info
"""
return "<Simulation | setup: %s | total runs: %i>" % (self.setup,
len(self))
def __str__(self):
"""
Returns name of directory the results were read from
"""
return self.name
def __len__(self):
"""
Returns number of total runs in simulation
"""
if self.setup == 'run':
n_runs = 1
elif self.setup == 'trial':
n_runs = len(self.trial['runs'])
elif self.setup == 'trial_set':
n_runs = 0
for trial in self.trial_set['trials']:
n_runs += len(self.trial_set['data'][trial]['runs'])
return n_runs
def read(self, simdir, setup, read_parameters=False):
"""
Read Lammps simulation results from given directory.
"""
self.setup = setup
self.simdir = simdir
self.name = os.path.basename(simdir)
if read_parameters:
self.read_parameters()
if setup == 'run':
self.run = read_run(simdir, k_par=self.parameters.thermof['kpar'])
elif setup == 'trial':
self.trial = read_trial(simdir,
k_par=self.parameters.thermof['kpar'])
elif setup == 'trial_set':
self.trial_set = read_trial_set(
simdir, k_par=self.parameters.thermof['kpar'])
else:
print('Select setup: "run" | "trial" | "trial_set"')
def initialize(self):
"""
Initialize input files for a Lammps simulation.
"""
self.setup = '|'.join(self.parameters.thermof['fix'])
self.set_dir(self.simdir)
write_lammps_files(self.simdir, self.parameters, verbose=self.verbose)
write_lammps_input(self.simdir, self.parameters, verbose=self.verbose)
job_submission_file(self.simdir, self.parameters, verbose=self.verbose)
self.save_parameters()
print('Done!') if self.verbose else None
def initialize_runs(self, n_runs, run_parameters=None):
"""
Initialize input files for a Lammps simulation with multiple runs.
"""
self.setup = '|'.join(self.parameters.thermof['fix'])
self.set_dir(self.simdir)
write_lammps_files(self.simdir, self.parameters, verbose=self.verbose)
inp_file = glob.glob(os.path.join(self.simdir, 'in.*'))[0]
data_file = glob.glob(os.path.join(self.simdir, 'data.*'))[0]
jobname = self.parameters.job['name']
for run in range(1, n_runs + 1):
rundir = os.path.join(self.simdir, '%i' % run)
os.makedirs(rundir)
shutil.copy(inp_file, rundir)
shutil.copy(data_file, rundir)
self.parameters.thermof['seed'] += 1
self.parameters.job['name'] = '%s-%i' % (jobname, run)
if run_parameters is not None:
for par_key, par_val in run_parameters.items():
self.parameters.thermof[par_key] = par_val[run - 1]
write_lammps_input(rundir, self.parameters, verbose=self.verbose)
job_submission_file(rundir, self.parameters, verbose=self.verbose)
self.save_parameters(simdir=rundir)
os.remove(inp_file)
os.remove(data_file)
print('Done!') if self.verbose else None
def set_dir(self, simdir):
"""
Set simulation directory for initialization.
"""
if os.path.exists(simdir):
shutil.rmtree(simdir)
print('Removing existing simulation directory -> %s' % simdir)
os.makedirs(simdir)
self.simdir = simdir
def set_mof(self, mof_file):
"""
Set MOF file for Lammps simulation
"""
self.mof = MOF(mof_file)
self.parameters.lammps['cif_file'] = self.mof.path
self.parameters.job['name'] = self.mof.name
self.parameters.job['input'] = 'in.%s' % self.mof.name
if self.parameters.thermof['min_cell_size'] is not None:
rep = self.mof.get_replication(
self.parameters.thermof['min_cell_size'])
else:
rep = [1, 1, 1]
self.parameters.lammps['replication'] = ' '.join([str(i) for i in rep])
self.mof.volume = self.mof.get_volume(rep)
self.parameters.thermof['mof'] = dict(name=self.mof.name,
replication=rep,
volume=self.mof.volume)
self.parameters.thermof['kpar']['volume'] = self.mof.volume
def plot(self, selection, data=None):
"""
Plot Lammps simulation results.
"""
if 'plot' not in vars(self.parameters).keys():
self.parameters.plot = plot_parameters.copy()
plot_simulation(self, selection, data)
def show_parameters(self, par=None):
"""
Show selected simulation parameters.
"""
self.parameters.show(par=par)
def save_parameters(self,
simdir=None,
parameters=['thermof', 'lammps', 'job']):
"""
Save simulation parameters.
"""
if simdir is None:
simdir = self.simdir
self.parameters.save(parameters=parameters,
savedir=simdir,
verbose=self.verbose)
def read_parameters(self, simpar_file=None, setup=None):
"""
Read simulation parameters.
"""
if simpar_file is None:
if self.setup == 'run':
run_dir = self.simdir
elif self.setup == 'trial':
for run in os.listdir(self.simdir):
if os.path.isdir(os.path.join(
self.simdir, run)) and 'simpar.yaml' in os.listdir(
os.path.join(self.simdir, run)):
run_dir = os.path.join(self.simdir, run)
break
elif self.setup == 'trial_set':
for trial in os.listdir(self.simdir):
for run in os.listdir(os.path.join(self.simdir, trial)):
if 'simpar.yaml' in os.listdir(
os.path.join(self.simdir, run)):
run_dir = os.path.join(self.simdir, run)
break
simpar_file = os.path.join(run_dir, 'simpar.yaml')
else:
run_dir = os.path.dirname(simpar_file)
print('Reading simulation parameters from -> %s' %
run_dir) if self.verbose else None
with open(simpar_file, 'r') as sp:
simpar = yaml.load(sp)
self.parameters = Parameters(simpar)
def summarize(self, run_dict, padding=0):
for i in run_dict.keys():
if type(run_dict[i]) == dict:
keys = [str(i) for i in list(run_dict[i].keys())]
info = '%s%-10s -> dict: %s' % (' ' * padding, str(i),
' '.join(keys))
print(info)
self.summarize(run_dict[i], padding=padding + 5)
elif type(run_dict[i]) in [str, int, float]:
info = '%s%-10s -> %s' % (' ' * padding, i, run_dict[i])
print(info)
elif type(run_dict[i]) == list:
info = '%s%-10s -> list of length: %s' % (' ' * padding, i,
len(run_dict[i]))
print(info)
else:
info = '%s%-10s -> %s' % (' ' * padding, i, type(run_dict[i]))
print(info)